Saravanan666/pypi-org huggingface dataset:
Package: scalabis
Welcome to scalabisA Python3 module for fast & easy sequence comparisonscalabis is built on numba and numpy, taking advantage of JIT compiled functions for speedy mismatched sequence comparisons.InstructionsInstall scalabis using pip:pip install scalabisImport it as any other python module:import scalabis as scUsage examples. See help(function) after import for more use details:sequence1 = "pihton"sequence2 = "Hello there, this is a test for a fast & easy mismatch matching python module. Allegedly, it is efficient"count by how many mismatches 2 same lenght sequences diverge:sc.mismatch_counter(sequence1,sequence2)find one sequence in another, with mismatches. return_template=True returnssc.find(sequence1,sequence2,mismatch=1)without return in a classsc.find(sequence1,sequence2,mismatch=2,dict_return=False)compare two sequences, searching from the search sequence from a specified starting point (default=0),
returning the full aligned matrix whrere mismatches are 1, and matches are 0.
Mismatches are the total mismatches in the compared matrixsc.comparefromfound(sequence1,sequence2,mismatch=0,start=0,dict_return=True)compare two sequences, returning all the locations in which they differsc.compareandlocate(start=0,search=sequence1,template=sequence2)compare two sequences, returning the full aligned matrix. starting point can be specifiedsc.compare(search=sequence1,template=sequence2,start=0,dict_return=False)
Package: scalablewritingpyxel
pyxel_scalable_writingThis module is made to run with pyxelThis module allow to write with a scaling text functionyou MUST have a pyxres file that contain a white square of 20 pyxel width named writing_module.pyxres, you can use the one of the githubWON'T work with a white square superior to 20 pxTo show your personnalised text, you must use the method parsing of class CharacterCharacters.parsing(string, x_depart, y_depart, unity_width, transparence)stringis the text you want to show usx_departandy_departis the top left position coordinates of your textunity_widthis an optional paremeter, it's the width of an unity of your image (like a pixel but bigger), its default value is 5transparenceis an optional element that is True by default, if you want to have your text on a black background, call it as Falseon pypi !
Package: scalaccf
Metaprogramming. Scala style and documentation fixerRequirementsPython: 3.4Install PyPI packagepip install scalaccfHelpusage: ScalaCCF.py [-h] [-p P] [-d D] [-f F] [-v] [-t]

ScalaCCF - utility to fix style and documentation comments in Scala files

optional arguments:
  -h, --help    show this help message and exit
  -p P          Path to scala project directory to fix.
  -d D          Path to directory with Scala files to fix.
  -f F          Path to Scala file to fix.
  -v, --verify  Verify style and documentation comments
  -t, --trace   Fix style and documentation commentsExamplespython ScalaCCF.py -f 'C:\Users\Me\Scala\MyClass.scala' --tracepython ScalaCCF.py -p 'C:\Users\Me\Projects\MyProject' --traceUsing installed PyPI package:scalaccf -f 'C:\Users\Me\Scala\MyClass.scala' --traceOtherIf namings in path of package or file have incorrect naming utility creates new package or file with correct namings.
Package: scalalike.collections
scala collection like interface for python iterato.rIterable object:>>> from scalalike.collections import Iterable
>>> it = Iterable(range(10))
>>> it
<scalalike.collections.collection.Iterable object at 0x9b0428c>
>>> it.to_list()
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> it.map(lambda x:x*2).to_list()
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> it.filter(lambda x:x%2 == 0).to_list()
[0, 2, 4, 6, 8]
>>> it.filter(lambda x:x%2 == 0).map(lambda x:x*2).to_list()
[0, 4, 8, 12, 16]
>>> it.flatmap(lambda x: [x, x]).to_list()
[0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9]
>>> it.take(4).to_list()
[0, 1, 2, 3]
>>> it.foldleft(lambda x, y: x+y)
45Map object:>>> from scalalike.collections import Iterable
>>> mp = Map(aa=10, bb=20)
>>> mp
{'aa': 10, 'bb': 20}
>>> mp.map(lambda (k, v): (k, v*2))
{'aa': 20, 'bb': 40}
>>> mp.filter(lambda (k, v): k == 'bb')
{'bb': 20}
Package: scalapack4py
Dynamics ScaLAPACK wrapper for PythonPython wrapper for dynamically loaded ScaLAPACK and BLACS librariesfrom scalapack4py import ScaLAPACK4py, parprint, ordprint
from ctypes import cast, py_object, CDLL, RTLD_GLOBAL

scalapack_lib = CDLL('libscalapack-openmpi.so.2.0', mode=RTLD_GLOBAL)
sl = ScaLAPACK4py(scalapack_lib)

...

descr = sl.wrap_blacs_desc(descr)
locshape = (descr.locrow, descr.loccol)
data = np.ctypeslib.as_array(data, shape=locshape)
sl.scatter(data_src, descr, data)
Package: scalaps
scalapsSee blog post,Introducing scalaps: Scala-inspired data structures for Pythonto learn about using this library.A functional, object-oriented approach for working with sequences and collections. Also similar to Java Streams. Hope you find they simplify your code by providing a plethora of common algorithms for working with sequences and collections.ExamplefromscalapsimportScSeq(ScSeq(range(10)).map(lambdax:x+3).filter(lambdax:x%2==0).group_by(lambdax:x%3).items().for_each(print))Output(1, ScList([4, 10]))
(0, ScList([6, 12]))
(2, ScList([8]))ExamplesSee examples/ directory for additional examples of using scalaps.Also see example usages incareer_village_entities.Closing RemarksVery much a work in progress. Expect major changes as the library evolves.
I'd appreciate other people's input, so feel free to submit a PR.Contact: Matt Hagymatthew.hagy@gmail.com
Package: scalar
Python Matrix library, built on theMatrix Client-Server
SDKsetuppipinstallscalarCreate a configuration.mkdir-p~/.config/scalartouch~/.config/scalar/config.yamlThe configuration file contents should be like the following:{"configurations":{"scriptwire":{"default":True,"homeserver":"https://matrix.example.pro:8448","username":"scriptwire","passcode":"qo3i4tbc35wgtt4gbwikgvtib3ctgt7bgi3rgw","room_alias":"!cgOnMzaBWCLjBnhGiB:matrix.example.org"}},"version_config":"2018-08-23T1930Z"}There can be multiple configurations, such as for separate accounts. One
configuration must be set as the default if a configuration is not
specified on setup. A room must be one to which the account has been
invited.clientA scalar terminal client can be launched in the following way:scalar_clientalertAn alert message can be sent on the terminal, in a way like the
following:scalar_alert--message="This is an alert message."An alert message can be send in Python, in a way like the following:importscalarscalar.alert(message="alert")megaparsexcan be used with
scalar to send data via messages, in ways like the following:importmegaparseximportscalarscalar.alert(message=megaparsex.report_IP())scalar.alert(message=megaparsex.report_system_status())scalar.alert(message=megaparsex.report_METAR("EGPF"))upload and send text, files, audio, images and videoimportscalarscalar.send_text("test")scalar.send_file("test.csv")scalar.send_audio("test.ogg")scalar.send_image("test.gif")scalar.send_video("test.mp4")
Package: scalation-kernel
OverviewTheScalation Kernelproject provides a lightweightScala+ScalaTionkernel forJupyternotebooks. More
information is available on theproject
page.GitHub Project Page:https://github.com/scalation/scalation_kernel/PyPI Release Page:https://pypi.python.org/pypi/scalation-kernel/InstallationPrerequisitesJava 8 (>= 8)Scala 2.12.8 (>= 2.12.8)Installation requires a recent ScalaTion distribution (>= 1.3) fromhere. Once you have
ScalaTion, make sure theSCALATION_JARSenvironment variable is set
appropriately before continuing. This can be done individually, as seen
here:It is important to note that this is the most important step, if the
environment variable is not correct, the program will not run properly.Steps (Terminal):Find where you downloaded your copy of ScalaTion.Usepwdcommand to get the path location.Copy the path to use in the next steps.Run the following commands with “/path/to/” replaced with the file path
from thepwdcommand:$ export SCALATION_JARS=/path/to/scalation_mathstat.jar
$ export SCALATION_JARS=/path/to/scalation_modeling.jar:$SCALATION_JARSExample:$ export SCALATION_JARS=/home/mepcotterell/Downloads/scalation_1.4/scalation_mathstat.jar
$ export SCALATION_JARS=/home/mepcotterell/Downloads/scalation_1.4/scalation_modeling.jar:$SCALATION_JARSIt can also be done with a single command if you know the path to thescalation_modelsdirectory:$ export SCALATION_JARS=$(find /path/to/scalation_models/lib | grep .jar | paste -sd ":" -)To installScalation Kernelfrom PyPI, you can use the following
commands:$ python3 -m pip install -U scalation_kernel
$ python3 -m scalation_kernel.installMore installation options are presented in theInstallation
Guide,
including deployment options for Python virtual environments and Docker
containers.Using ScalaTion KernelThe dropdown menu in Jupyter labeledNewshould show an option to
create a ScalaTion notebook using the installed kernel.AUser
Guideis currently under development. A complete draft is planned for the next
minor release. Until then, please see the collection ofexample
notebooksfor usage examples.ContributorsMichael E. Cotterellmepcott@uga.eduKevin Bonannokevin.bonanno25@uga.eduSujeet Kulkarnisujeet.kulkarni25@uga.eduDat Le-Phandatlephan@uga.eduLicenseCopyright © Michael E. Cotterell and the University of Georgia. This
software is free and open source under anMIT
License.
The content and opinions expressed on this Web page do not necessarily
reflect the views of nor are they endorsed by the University of Georgia
or the University System of Georgia.
Package: scalcbr
scalcbrDescription.
The package simple_calculator is used to:
- simple calc operation
- sum, subtract, multiply or divideInstallationUse the package managerpipto install package_namepipinstallscalcbrAuthorDaniel VictorLicenseMITFolder oldFirst package version - don't exist more, but if you execute file call_calculator.py
will have a iterative, interactive simple calculator
Package: scalecodec
Python SCALE CodecDescriptionSubstrateuses a lightweight and efficientencoding and decoding programto optimize how data is sent and received over the network. The program used to serialize and deserialize data is called the SCALE codec, with SCALE being an acronym forSimpleConcatenatedAggregateLittle-Endian.Documentationhttps://polkascan.github.io/py-scale-codec/InstallationpipinstallscalecodecExamples of different typesTypeDescriptionExample SCALE decoding valueSCALE encoded valueboolBoolean values are encoded using the least significant bit of a single byte.True0x01u16Basic integers are encoded using a fixed-width little-endian (LE) format.420x2a00CompactA "compact" or general integer encoding is sufficient for encoding large integers (up to 2**536) and is more efficient at encoding most values than the fixed-width version. (Though for single-byte values, the fixed-width integer is never worse.)00x0010x04420xa8690x15011000000000000000x0b00407a10f35aVecA collection of same-typed values is encoded, prefixed with a compact encoding of the number of items, followed by each item's encoding concatenated in turn.[4, 8, 15, 16, 23, 42]0x18040008000f00100017002a00BitVecA sequence of bools, represented in a more space efficient bit format0b00000010_011111010x287d02str,Bytes,StringStrings are Vectors of bytes (Vec<u8>) containing a valid UTF8 sequence."Test"0x1054657374b"Test"0x1054657374[84, 101, 115, 116]0x1054657374[u8; 4]Fixed sized array of in this case anu8b"babe"0x62616265"0x62616265"0x62616265[98, 97, 98, 101]0x62616265AccountIdAnSS58 formattedrepresentation of an account. See also theSS58 util functions"5GDyPHLVHcQYPTWfygtPY eogQjyZy7J9fsi4brPhgEFq4pcv"0xb80269ec500e458a630846b99105c397 ee574125823d6f4388e9c7572e115c05EnumExample:enum IntOrBool { Int(u8), Bool(bool),}A fixed number of variants, each mutually exclusive and potentially implying a further value or series of values. Encoded as the first byte identifying the index of the variant that the value is. Any further bytes are used to encode any data that the variant implies. Thus, no more than 256 variants are supported.{'Int': 8}0x002a{'Bool': True}0x0101StructExample:struct Motion { pub votes: Vec<AccountId>, pub id: u32 }For structures, the values are named, but that is irrelevant for the encoding (names are ignored - only order matters). All containers store elements consecutively. The order of the elements is not fixed, depends on the container, and cannot be relied on at decoding. This implicitly means that decoding some byte-array into a specified structure that enforces an order and then re-encoding it could result in a different byte array than the original that was decoded.{"votes": ["5GDyPHLVHcQYPTWfygtPYeo gQjyZy7J9fsi4brPhgEFq4pcv"], "id": 4}0x04b80269ec500e458a630846b99105c397ee57 4125823d6f4388e9c7572e115c0504000000Licensehttps://github.com/polkascan/py-scale-codec/blob/master/LICENSE
Package: scaled-preconditioners
Preconditioner Design via Bregman DivergencesThis package implements the preconditioners in [1]. A simple use case
is demonstrated below. Seeexamples/example_pcg.pyfor a demo of all the
preconditioners defined in this package.[1] TODOBuild StatusInstallationpip install scaled_preconditionersA simple exampleDefine some parametersdimension = 100
psd_rank = 50Construct S = A + BF = csc_matrix(np.random.rand(dimension, psd_rank))
B = F @ F.T
Q = csc_matrix(np.random.rand(dimension, dimension))
S = Q @ Q.T + BConstruct the preconditionerHere we use a randomised SVD, other options include truncated SVD, the
Nyström approximation. There is support for oversampling and power iteration
schemes.rank_approx = 15
pc = compute_preconditioner(
    Q,
    B,
    algorithm="randomized",
    rank_approx=rank_approx,
    n_oversamples=4,
    n_power_iter=0,
)Set up a right-hand siderhs = np.random.rand(dimension)
counter = ConjugateGradientCounter()SolveSx=bwith and without a preconditioner_, info = linalg.cg(S, rhs, callback=counter)
print("No preconditioner:")
print(f"\t Converged: {info == 0}")
print(f"\t Iterations: {counter.n_iter}\n")

counter.reset()
_, info = linalg.cg(S, rhs, M=rsvd_pc, callback=counter)
print("Randomised SVD preconditioner:")
print(f"\t Converged: {info == 0}")
print(f"\t Iterations: {counter.n_iter}\n")
Package: scalefree-target-s3-json
target-s3-jsonSingertarget that uploads loads data to S3 in JSON format
following theSinger spec.How to use itInstallFirst, make sure Python 3 is installed on your system or follow these
installation instructions forMacorUbuntu.It's recommended to use a virtualenv:python3-mvenvenv-target-s3-jsonInstall the package target-s3-json in the virtualenv:Either install it from github:sourceenv-target-s3-json/bin/activatepipinstallgit+https://github.com/ScalefreeCOM/scalefree-target-s3-jsondeactivateor from PyPI:sourceenv-target-s3-json/bin/activatepipinstallscalefree-target-s3-jsondeactivateTo runLike any other target that's following the singer specification:some-singer-tap--catalog[catalog.json]|~/environment/env-target-s3-json/bin/python3env-target-s3-json/lib/python3.7/site-packages/target_s3_json/__init__.py--config[config.json]Note: To avoid version conflicts runtapandtargetsin separate virtual environments.Configuration settingsRunning the target connector requires aconfig.jsonfile. An example with the minimal settings:{"aws_access_key_id":"ACCESS-KEY","aws_secret_access_key":"SECRET","s3_bucket":"BUCKET","s3_key_prefix":"SOME-PREFIX/","delimiter":","}LicenseApache License Version 2.0SeeLICENSEto see the full text.
Package: scale-generator
Scale GeneratorGetting startedTo make it easy for you to get started with GitLab, here's a list of recommended next steps.Already a pro? Just edit this README.md and make it your own. Want to make it easy?Use the template at the bottom!DescriptionLet people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.InstallationWithin a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.UsageUse examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.SupportTell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.ContributingState if you are open to contributions and what your requirements are for accepting them.For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.LicenseFor open source projects, say how it is licensed.
Package: scalegrid-cli
ScaleGrid CLI v1.1.0This tool lets you to leverage command line interface (CLI) functionality for
hosting your database as a service, on ScaleGrid. This ScaleGrid tool allows
you to perform the same actions you can through the browser-based ScaleGrid
Console.InstallationIf you have Python3 installed, you can install this tool via -pip installscalegrid-cliIf you do not have Python3 installed please download and install Python3
fromhttps://www.python.org/downloads/ScaleGrid CLI requires Python 3.6 or above.UsageTypesg-cli-hto open the help menuYou can also find detailed help for each of our supported databasesin our help pagesMongoDB         :https://help.scalegrid.io/docs/mongodb-cli-tool-installation-useRedis (TM)      :https://help.scalegrid.io/docs/redis-cli-tool-installation-useMySQL           :https://help.scalegrid.io/docs/mysql-cli-tool-installation-usePostgreSQL      :https://help.scalegrid.io/docs/postgres-cli-tool-installation-use
Package: scalehub
Usageimport time
from scalehub.hub import ScaleHub

config = {
  'workers': [
      {
          'id': 'worker01',
          'driver_class': ClassName,
          'driver_config': {
              'any_attribute': 'any_value'
          }
      },
  ],
}

hub = ScaleHub(config)
hub.go()

while not hub.is_test_completed():
  print hub.collect_results()
  time.sleep(1)Whereconfigmust containworkersarray. Each worker config must contain the next attributes:id- worker unique identifierdriver- worker driver class full pathIntodriver_configattribute you may put any configuration your worker need.Methodgo()just callsinit_workers()and thenstart_test(). You can call these methods manually.
Package: scale-launch
Launch Python Client██╗      █████╗ ██╗   ██╗███╗   ██╗ ██████╗██╗  ██╗
██║     ██╔══██╗██║   ██║████╗  ██║██╔════╝██║  ██║
██║     ███████║██║   ██║██╔██╗ ██║██║     ███████║
██║     ██╔══██║██║   ██║██║╚██╗██║██║     ██╔══██║
███████╗██║  ██║╚██████╔╝██║ ╚████║╚██████╗██║  ██║
╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝ ╚═════╝╚═╝  ╚═╝Moving an ML model from experiment to production requires significant engineering lift.
Scale Launch provides ML engineers a simple Python interface for turning a local code snippet into a production service.
A ML engineer needs to call a few functions from Scale's SDK, which quickly spins up a production-ready service.
The service efficiently utilizes compute resources and automatically scales according to traffic.Latest API/SDK reference can be foundhere.Deploying your model via Scale LaunchCentral to Scale Launch are the notions of aModelBundleand aModelEndpoint.
AModelBundleconsists of a trained model as well as the surrounding preprocessing and postprocessing code.
AModelEndpointis the compute layer that takes in aModelBundle, and is able to carry out inference requests
by using theModelBundleto carry out predictions. TheModelEndpointalso knows infrastructure-level details,
such as how many GPUs are needed, what type they are, how much memory, etc. TheModelEndpointautomatically handles
infrastructure level details such as autoscaling and task queueing.Steps to deploy your model via Scale Launch:First, you create and upload aModelBundle.Then, you create aModelEndpoint.Lastly, you make requests to theModelEndpoint.TODO: link some example colab notebookFor DevelopersClone from github and install as editablegit clone git@github.com:scaleapi/launch-python-client.git
cd launch-python-client
pip3 install poetry
poetry installPlease install the pre-commit hooks by running the following command:poetryrunpre-commitinstallThe tests can be run with:poetryrunpytestDocumentationUpdating documentation:We useSphinxto autogenerate our API Reference from docstrings.To test your local docstring changes, run the following commands from the repository's root directory:poetry shell
cd src_docs
sphinx-autobuild . ../docs --watch ../launchsphinx-autobuildwill spin up a server on localhost (port 8000 by default) that will watch for and automatically rebuild a version of the API reference based on your local docstring changes.
Package: scale-llm-engine
LLM EngineThe LLM Engine Python library provides a convenient way of interfacing with allmengineendpoint running onLLM Engineor on your own infrastructure.Get StartedInstallpipinstallscale-llm-engineUsageIf you are using LLM Engine, you can get your API key fromhttps://spellbook.scale.com/settings.
Set theSCALE_API_KEYenvironment variable to your API key.If you are using your own infrastructure, you can set theLLM_ENGINE_BASE_PATHenvironment variable to the base URL of your
self-hostedllmengineendpoint.fromllmengineimportCompletionresponse=Completion.create(model="llama-2-7b",prompt="Hello, my name is",max_new_tokens=10,temperature=0.2,)print(response.outputs[0].text)DocumentationDocumentation is available athttps://scaleapi.github.io/llm-engine/.