Saravanan666/pypi-org huggingface dataset:
Package: scoop
SCOOP (Scalable COncurrent Operations in Python) is a distributed task
module allowing concurrent parallel programming on various environments,
from heterogeneous grids to supercomputers. Its documentation is available onhttp://scoop.readthedocs.org/.PhilosophySCOOP was designed from the following ideas:Thefutureis parallel;Simple is beautiful;Parallelism should be simpler.These tenets are translated concretely in aminimum number of functionsallowingmaximum parallel efficiencywhile keeping atminimum the
inner knowledge requiredto use them. It is implemented with Python 3 in mind
while being compatible with Python 2.6+ to allow fast prototyping without sacrificing
efficiency and speed.Some comments we received on SCOOP:"I must say that that was by far the easiest upgrade I have probably ever done.  I still need to build and test it on the cluster, but on my development machine it took about 10 minutes to upgrade and test." [deap mailing list](https://groups.google.com/d/msg/deap-users/chQY-2HHZWM/4qZRkQuvbbIJEBo)FeaturesSCOOP features and advantages overfutures,multiprocessingand similar modules are as follows:Harness the power ofmultiple computersover network;Ability to spawn multiple tasks inside a task;API compatible withPEP-3148;Parallelizing serial code with only minor modifications;Efficient load-balancing.Anatomy of a SCOOPed programSCOOP can handle multiple diversified multi-layered tasks. With it, you can submit your different functions and data simultaneously and effortlessly while the framework executes them locally or remotely. Contrarily to most multiprocessing frameworks, it allows to launch subtasks within tasks.Through SCOOP, you can execute simultaneously tasks that are different by
nature, shown by the task color, or different by complexity, shown by the task radius. The module will handle the physical considerations of parallelization, such as task distribution over your resources (load balancing), communications, etc.ApplicationsThe common applications of SCOOP consist but is not limited to:Evolutionary AlgorithmsMonte Carlo simulationsData miningData processingGraph traversalCiting SCOOPAuthors of scientific papers including results generated using SCOOP are encouraged to cite the following paper.{{{
@inproceedings{SCOOP_XSEDE2014,
title={Once you SCOOP, no need to fork},
author={Hold-Geoffroy, Yannick and Gagnon, Olivier and Parizeau, Marc},
booktitle={Proceedings of the 2014 Annual Conference on Extreme Science and Engineering Discovery Environment},
pages={60},
year={2014},
organization={ACM}
}
}}}Useful linksYou candownload the latest stable version, check theproject  documentation, post to themailing listorsubmit an issueif you've found one.
Package: scoop-template-engine
The purpose of the SCOOP template engine (ste) is to facilitate the preparation of manuscripts inLaTeXfor publication in scientific journals.
It allows the user to concentrate on the content, rather than the layout.
The layout, which depends on the journal, will be automatically generated.
An effort is made to achieve compatibility of a range of standard LaTeX packages with each supported journal.
In addition, a consistent set of theorem-like environments is provided across journals.InstallationThe SCOOP template engine requires Python 3.9 or newer.
To install the SCOOP template engine and initialize the journal resources, saypip3installscoop-template-enginesteinitGetting StartedTo create the files for a sample document in the current folder, saystestartTo render this manuscript in a preprint layout, saysteprepare-tamspreprintThen compile the sample documentmanuscript-amspreprint.tex.
To see the list of supported journals, sayste list.
Please refer to the "Quick Start" section in the documentation (ste doc) for more.
Package: scoords
scoordsThescoordslibrary defines anastropycustom coordinate frame. This allows to specify coordinates relative to the local spacecraft coordinates and transform them to any other system usingastropy's machinery.SkyCoordobjects are instantiated by passing a location with specified units and a coordinate frame. UseSpacecraftFrameto specify a coordinate in the reference system attached to the spacecraft:importastropy.unitsasufromastropy.coordinatesimportSkyCoordfromscoordsimportSpacecraftFramec=SkyCoord(lon=45*u.deg,lat=10*u.deg,frame=SpacecraftFrame())This allows you to know the reference frame of the coordinate, e.g.c.frame<SpacecraftFrame Coordinate (attitude=None, obstime=None, location=None): (lon, lat) in deg
    (45., 10.)>However, in order to transform it into other coordinate system you need to specify the orientation of the spacecraft with respect to an inertial reference frame --i.e. the attitudefromscoordsimportAttitudeattitude=Attitude.from_rotvec(45*u.deg*[0,0,1],frame='icrs')c=SkyCoord(lon=0*u.deg,lat=0*u.deg,frame=SpacecraftFrame(attitude=attitude))There are class methods to specify the orientation in any of the following formats:A rotation matrxA vector co-directional to the axis of rotationA quaternionAscipy'sRotationobjectThe direction the spacecraft coordinates axes point toOnce the attitude is specified, we can transform from/to any other frame supported by astropyc.transform_to('icrs')<SkyCoord (ICRS): (ra, dec) in deg
    (45., 0.)>c.transform_to('galactic')<SkyCoord (Galactic): (l, b) in deg
    (176.96129126, -48.90264434)>Although it does not play a role in this particular coordinates transformation, the observation time and location can also be specified in case it is needed by any other algorithm:fromastropy.timeimportTimefromastropy.coordinatesimportEarthLocationframe=SpacecraftFrame(attitude=attitude,obstime=Time('2026-01-01T00:00:00'),location=EarthLocation(lon=10*u.deg,lat=46*u.deg,height=400*u.km))c=SkyCoord(lon=45*u.deg,lat=10*u.deg,frame=frame)c.frame.obstime<Time object: scale='utc' format='isot' value=2026-01-01T00:00:00.000>c.frame.location.geodeticGeodeticLocation(lon=<Longitude 10. deg>, lat=<Latitude 46. deg>, height=<Quantity 400. km>)
Package: scooter-rental
Rent electro scooterThis is a regular CLI application for renting electro-scooters.It usesSQLAlchemyAPI as a database core with ORM (Object Relational Mapper) support.Toolspython 3.6 | 3.7 | 3.8sqlalchemydatabasealembicdatabase migrationcode analysispytestblackpylintflake8UsageInstallationPlease run following script to obtain latest package from PYPI:pipinstallscooter-rentalThen please launch following tool from your environment:scooter-rentalSource codeTo be able to run source code please execute command below:git@github.com:vyahello/rent-electro-scooter.git
python-mscooterDevelopment notesCIProject has Travis CI integration using.travis.ymlfile thus code analysis (black,pylint,flake8) and unittests (pytest) will be run automatically
after every made change to the repository.To be able to run code analysis, please execute command below:./analyse-code.shRelease notesPlease checkchangelogfile to get more details about actual versions and it's release notes.MetaAuthor –Volodymyr YahelloDistributed under theMITlicense. SeeLICENSEfor more information.You can reach out me at:vyahello@gmail.comhttps://github.com/vyahellohttps://www.linkedin.com/in/volodymyr-yahello-821746127Contributingclone the repositoryconfigure Git for the first time after cloning with yournameandemailpip install -r requirements.txtto install all project dependenciespip install -r requirements-dev.txtto install all development project dependencies
Package: scooze
scoozeA flexible data layer for applications working with Magic: the Gathering cards, decks, and tournaments.In this README 👇FeaturesUsageInitial setupContributingDeveloper setupFeatures🎛️ CLI to manage a local database ofScryfalldata📊 Robust data models for representing Magic: the Gathering cards, decks, and tournamentsCards - follows the Scryfall standardDecks - main deck/sideboard/command zone, format legality, average words, and moreTournaments - coming soon!🐍 Python and REST APIs for interacting with the scooze databaseNote: v1 is local onlyUsageInitial setupDownload and install this package fromPyPi.pip install scoozeSet up the databaseUsing Docker:Make sureDocker Desktopis running.scooze setup dockerThis will pull the latest MongoDB issued image for your machine's distribution, and spin up the container with port 27017 bound to the host's port 27017.After this, you can continue to (3) below.Running MongoDB locally:Scooze depends on MongoDB to run your local database.
Download and installMongoDB.You can use scooze without MongoDB if you don't intend to use any of its database-related features.Your local database can be stored wherever you want, but make sure you create the directory first. This is commonly stored at/data/dbRun the MongoDB server withmongod --dbpath path/to/db/Run the scooze CLI tool (installed with pip install) to add some data to your local database.scooze -h
scooze load-cards oracle
scooze runUse scooze in your application code!from scooze.api import ScoozeApi
from scooze.catalogs import Color

with ScoozeApi() as s:
  # get 10 arbitrary green cards
  green_cards = s.get_cards_by("colors", [Color.GREEN], paginated=True, page_size=10)
  # get _all_ green cards
  green_cards = s.get_cards_by("colors", [Color.GREEN])

  # get all cards from a particular set
  woe_cards = s.get_cards_by_set("woe")

  # get a specific card
  black_lotus = s.get_card_by_name("Black Lotus")
  print(black_lotus.total_words())

  # and more!ContributingIf you find a bug 🐛, please open abug report. If you have an idea for an improvement or new feature 🚀, please open afeature request.If you find a security vulnerability, please follow the instructionshere.Developer setupInstall PoetryIntroduction to PoetryMake sure it workedpoetry --versionForkand clone the scooze GitHub repoRead more about forkinghere.git clone https://www.github.com/link/to/fork
cd ./scooze
poetry installYou're ready to develop!When you have changes you'd like the team to review, please submit a pull request!
Package: scopeagent
scope-python-agentPython agent forScopeInstallpip install scopeagentUsagePlease refer to the documentation athttps://docs.scope.dev/docs/python-installationDevelopmentAutomated TestingThe following environment variables are used for database tests:POSTGRES_DBURLTo run the tests:toxPublishingTo publish a new version ofscopeagenttopypi:make publishYou will need validpypicredentials with access to thescopeagentpackage.
Package: scope-cleaner
Scope cleanerAn IPython cell magic to remove temporary variables.
I wrote this package because I didn't like by global scope to be cluttered with variables I used in 1 cell only during EDA (Exploratory Data Analysis).InstallationVia pip:pip install scope-cleanerUsageFirstly, one needs to import the package:import scope_cleaner.
Then a new magic becomes available:%%cleanup_temporary_vars <optional_prefix>.
Optional prefix is a parameter which helps to filter out the temporary variables introduced in current cell.
If it's not set, the prefix defaults to_.Example:
Consider the following IPython cells:Cell 2%%cleanup_temporary_varstmpa=10b=15tmp_1=123tmp_2=234print("tmp",tmp_1,tmp_2)# Out: tmp 123 234tmp_1+tmp_2# Out: 357So all the variables from current cell work correctly.Cell 3a+b# Out: 25tmp_1# Error: no such variableAs we can see, the temporary variable was automatically deleted by%%cleanup_temporary_varsin the end of previous cell (because its name starts withtmp).
Package: scope-coupler
SCOPE: A Script Based Coupler for Simulations of the Earth Systemscopeis a offline, script-based coupler for various simulations of the
Earth System. It is written in Python and configured with YAML files.Free software: GNU General Public License v3Documentation:https://scope-coupler.readthedocs.io.FeaturesAutomatic remapping between various grids via theSCRIPlibraryAbility to run other programs before and after each stepConfiguration via yaml filesNo modification of model source code necessaryCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.4 (2019-12-12)Includes examples directory and a testscope_config.yamlFixes a small logging error in the command line interfaceUpdates documentation of main moduleAdds pre and post hooks functionalityChanges maximum line length in flake8 to 160 characters, black code style for
120 characters.0.1.3 (2019-12-4)Automatically builds documentation from docstringsMost ofscope sendworks0.1.0 (2019-11-13)First release on PyPI.
Package: scopedlog
scopedlogA library for scoped logging on top ofstructlog(or similar sinks), inspired by the idea of an apparently defunctlithoxyl. Note that I (kshpytsya) have deliberatly not looked into actual lithoxyl's implementation to keep a fresh mind.Here is an example:importcontextlibimportstructlogimportstructlog.stdlibimportstructlog.devimportstructlog.processorsimportscopedlogimportscopedlog.sink_structlogimportscopedlog.idgen_seqstructlog.configure(processors=[structlog.stdlib.add_log_level,structlog.processors.ExceptionPrettyPrinter(),structlog.dev.ConsoleRenderer()])slog=scopedlog.ScopedLog(sink=scopedlog.sink_structlog.StructlogSink(structlog.get_logger()),id_gen=scopedlog.idgen_seq.GlobalSeqScopeIdGenenerator())withcontextlib.suppress(RuntimeError):withslog.info("scope1",k1=1)assl:sl.debug("state1",k2=2,k3=3)sl.info("state1",k4=4)sl.warn("state1",k5=5)raiseRuntimeError("bad one")withcontextlib.suppress(RuntimeError):withslog.debug("scope2",k1=1)assl:sl.debug("state1",k2=2,k3=3)sl.info("state1",k4=4)sl.warn("state1",k5=5)raiseRuntimeError("bad too ;)")withslog.debug("scope3")assl:sl.fail()withslog.debug("scope4")assl:sl.exit_kw["k1"]=1And expected output:Seetestsfor more examples.
Package: scoped-mapping
When mapping input strings from column/fieldXin some datasource to terms from OBO foundry ontologies, use the values in column/fieldYto determine which ontology to map to.Note that GitHub uses a hyphen and PyPI uses an underscoreCurrently tested on a 32GB MacBook Pro running Catalina. Requires the riot library from Apache Jena.make alluses homebrew for installing Jena, but does not install homebrew. This will probably run on other ‘nix systems but will require a system dependent installation of Jena.Installationpython3.9 -m venv sm_venv
source sm_venv/bin/activate
pip install -r requirements.txt
pip install -i https://test.pypi.org/simple/ scoped-mappingSample codeSee Jupyter NotebooksScoping mappings based on subsets of NCBItaxonFirst downloadsemantic-sqland some of its dependencies. Build an SQLite database with the NCBItaxon content. Building requires lots of disk space, RAM and patience. Well worth it when it comes to query time:make allIf a dataset has taxon values, one can use them to subset or scope how other values in the dataset should be mapped. For example, the NCBI Biosample metadata collection has MIxS triads (broad, narrow and medium) that could me mapped to ENVO terms in many cases. But ENVO might not be appropriate for cultured samples or samples that were taken from a multicellular organism. One way to check for those cases is looking for transitive subclasses in NCBItaxon. There are numerous ways to do that, but they are all generally computationally expensive.Here, we use rdftab and relation-graph (via semantic-sql) to infer those transitive subClassOf relationships and load them into an SQLite database. Building this database requires lots of RAM and roughly 10 GB of disk space, but after that the querying is fast and convenient.BuildingOnce:pip install build twineEvery time:git add ...
git commit -m ...
git push
git tag ...
pip install --use-feature=in-tree-build .Ready to deploy?:python -m build --sdist --wheel .
ls -l dist/remove all artifacts from all builds indist/except for the latesttwine upload --repository pypitest dist/*
Package: scoped-singleton
scoped-singletonEasier sharing data between objectsInstallationpip3installscoped-singletonHow to use itfromdataclassesimportdataclassfromscoped_singletonimportcontext_scoped_singleton@context_scoped_singleton@dataclassclassAccount:uuid:struse it with cached_property to stop repeated requestsfromdataclassesimportdataclassfromcached_propertyimportcached_propertyfromscoped_singletonimportcontext_scoped_singleton@context_scoped_singleton@dataclassclassAccount:uuid:str@cached_propertydefcredit_limit(self):returnrpc(self.uuid)["credit_limit"]@dataclassclassTransaction:id:intaccount_uuid:str@propertydefaccount(self):returnAccount(uuid=self.account_uuid)txn1=Transaction(id=1,account_uuid="123")txn2=Transaction(id=2,account_uuid="123")txn3=Transaction(id=3,account_uuid="124")asserttxn1.accountistxn2.accountasserttxn1.accountisnottxn3.account
Package: scope-injected-contextmanager
Scope Injected ContextManagerA decorator/context manager that injects scope vars into a functionA context manager decorator forPython 3Lets you specify variables to extract from the innner-scope (the managed scope)
and will inject them into the@scope_injected_contextmanagerdecorated functionacts like a defaulted function(think functools.partial)allows you to pass in kwargs at runtime as wellUsageFor an extensive collection of examples seetestsFunctions decorated with@scope_injected_contextmanagerbecomes context managers that can be invoked in two different ways:As an instancefromscope_injected_contextmanagerimportscope_injected_contextmanager@scope_injected_contextmanagerdefdecorated_function():passwithdecorated_function:something=100Or as a functionfromscope_injected_contextmanagerimportscope_injected_contextmanager@scope_injected_contextmanagerdefdecorated_function():passwithdecorated_function():something=100Simple examplefromscope_injected_contextmanagerimportscope_injected_contextmanagerfetch=lambdarequest:("ok",200)@scope_injected_contextmanagerdeflog_request(request,response):print(f"request:{request}response:{response}")withlog_request:request={"query_args":{'foo':10}}response=fetch(request)# prints# request: {'query_args': {'foo': 10}} response: ('ok', 200)Advanced examplefromscope_injected_contextmanagerimportscope_injected_contextmanagerfetch=lambdarequest:("ok",200)@scope_injected_contextmanagerdeflog_request(request,response,some_explicit_variable=None):print(f"request:{request}response:{response}some_explicit_variable:{some_explicit_variable}")withlog_request(some_explicit_variable="foo):request={"query_args":{'foo':10}}response=fetch(request)# prints# request: {'query_args': {'foo': 10}} response: ('ok', 200) some_explicit_variable: foowhy?I needed a low-on-syntax context-manager that would log request_args and response.
When looking at implementing it i ran into this issue, and asked for help:"Spooky action observed in Python context manager"I was let down by the fact that you apparently can't give a context manager access to your variables.Thats why i hacked this together ;-)Testingseetestsrunmake setup-all toxon a (linux or osx) withpyenvinstalled.
Package: scope-ml
SCoPe: ZTF Source Classification Projectscope-mluses machine learning to classify light curves from the Zwicky Transient Facility (ZTF). The documentation is hosted athttps://zwickytransientfacility.github.io/scope-docs/. To generate HTML files of the documentation locally, clone the repository and runscope-docafter installing.FundingWe gratefully acknowledge previous and current support from the U.S. National Science Foundation (NSF) Harnessing the Data Revolution (HDR) Institute forAccelerated AI Algorithms for Data-Driven Discovery (A3D3)under Cooperative Agreement No.PHY-2117997.
Package: scope-plot
ScopePlotPlot Google Benchmark resultsGetting Started with ScopePlotScopePlot is available onPyPIcan be installed withpip$ python -m pip install scope_plotTo install the latest development version fromGithub$ python -m pip install git+git://github.com/c3sr/scope_plot.gitIf your current Python installation doesn't have pip available, tryget-pip.pyAfter installing ScopePlot you can use it like any other Python module.
Here's a very simple example:$python-mscope_plotbardata.jsonThere are multiple subcommands available$ python -m scope_plot --help

Usage: __main__.py [OPTIONS] COMMAND [ARGS]...

Options:
  --debug / --no-debug  print debug messages to stderr.
  --include DIRECTORY   Search location for input_file in spec.
  --help                Show this message and exit.

Commands:
  bar   Create a bar graph from BENCHMARK and write...
  deps  Create a Makefile dependence
  spec  Create a figure from a spec fileMore information about the subcommands can be accessed withpython -m scope_plot COMMAND --help, and also in the documentation:bar,spec,deps.API Referencecoming soon...Support / Report IssuesAll support requests and issue reports should befiled on Github as an issue.
Make sure to follow the template so your request may be as handled as quickly as possible.
Please respect contributors by not using personal contacts for support requests.ContributingWe happily welcome contributions, please seeour guide for Contributorsfor the best places to start and help.Licensescope_plot is made available under the Apache 2.0 License. For more details, seeLICENSE.txt.ChangelogRelease 0.2.3 (Development)Useaggmatplotlib backend if tkinter cannot be importedallow subplots to have error barshide error bar labels by defaultadd linestyle spec to matplotlib errorbarsdon't resolve path for scope_plot deps since makefiles probably expect target names to be relativeprint error when an input file is not foundRelease 0.2.2 (Development)Add NOTICE and Apache 2.0 LICENSEFixed a bug where ScopePlot would not run without DISPLAY environment setUse TkAgg backend on macOS to support running from a virtualenvAllow non-numeric x data in bar plotsAdd support for theoutputfield in spec filesRelease 0.2.1 (Development)Fix bugs in handling labels, color, regex for matplotlib and regex backendsRelease 0.2.0 (Development)Refactor some underlying data structuresbreak matplotlib backendRelease 0.1.5 (Development)Enable strict checking of spec files by defaultSort benchmark dataOmit invalid benchmark dataRelease 0.1.3 (Development)Change documentation to docsifyFix a bug with unexpected "strict" argumentRelease 0.1.2 (Development)rename toscope_plotInitial support forspecandbarsubcommands.