Saravanan666/pypi-org huggingface dataset:
Package: atl-observe
Observe@observeis a decorator for Python methods, which allows Python developers to collect all basic metrics about the decorated method, generate unified logs and notifications on failure which are easy to trace.Installationpipinstallatl-observeUsageDecorating the process method and assigning a metic name and static_tags, all tags are added to all metrics generated, used to filter on your dashboards.fromatl_observeimportobserveclassEngine:@observe(metric="process",static_tags=["layer:process"])defprocess(self,message:dict):passDecorating the process method and assigning a metric and trace_id_from, the trace_id will now appear in all logs and notifications, used to search your logs.fromatl_observeimportobserveclassEngine:@observe(metric="process",trace_id_from={"message":"eventId"})defprocess(self,message:dict):passLogs, Metrics and NotificationsAll logs, metrics and notifications are divided into three categories:Default:no exceptions were raised.Expected:an expected Exception was raised.Unexpected Exceptions:an unexpected / unhandled Exception was raisedDefault# optional: debug logslogger.debug("... start.")logger.debug("... finished.")# incrementsstatsd.increment("%s.start"%metric,1,tags=all_tags)statsd.increment("%s.finished"%metric,1,tags=all_tags)# timingstatsd.timing("%s.time.finished"%metric,dt,tags=all_tags)ExpectedExpected exceptions are managed viaaccept_onanddecline_onlists. If the raised exception is part ofaccept_on, the decorator will return a Truthy value, if the exception is part ofdecline_ona Falsy value is returned.# warning logslogger.warning("... accepted.")logger.warning("... declined.")# incrementsstatsd.increment('%s.exception.accepted'%metric,tags=all_tags)statsd.increment('%s.exception.declined'%metric,tags=all_tags)# timingstatsd.timing("%s.time.accepted"%metric,dt,tags=all_tags)statsd.timing("%s.time.declined"%metric,dt,tags=all_tags)Unexpected# error logslogger.error("... raised.")# slackslack.error("... raised.")# incrementsstatsd.increment('%s.exception.raised'%metric,tags=all_tags)# timingstatsd.timing("%s.time.raised"%metric,dt,tags=all_tags)Documentationmake installwill install all required packagesmake formatwill auto format the projectmake lintwill run the lintermake testswill run all unit testsContributionsContributions to@observeare welcome! Please seeCONTRIBUTING.mdfor details.LicenseCopyright (c) [2020] Atlassian and others.
Apache 2.0 licensed, seeLICENSEfile.
Package: atman-requests
Requests: HTTP for Humans™If you're interested in financially supporting Kenneth Reitz open source, considervisiting this link. Your support helps tremendously with sustainability of motivation, as Open Source is no longer part of my day job.Requests is the onlyNon-GMOHTTP library for Python, safe for human
consumption.Behold, the power of Requests:>>> r = requests.get('https://api.github.com/user', auth=('user', 'pass'))
>>> r.status_code
200
>>> r.headers['content-type']
'application/json; charset=utf8'
>>> r.encoding
'utf-8'
>>> r.text
u'{"type":"User"...'
>>> r.json()
{u'disk_usage': 368627, u'private_gists': 484, ...}Seethe similar code, sans Requests.Requests allows you to sendorganic, grass-fedHTTP/1.1 requests,
without the need for manual labor. There's no need to manually add query
strings to your URLs, or to form-encode your POST data. Keep-alive and
HTTP connection pooling are 100% automatic, thanks tourllib3.Besides, all the cool kids are doing it. Requests is one of the most
downloaded Python packages of all time, pulling in over 11,000,000
downloads every month. You don't want to be left out!Feature SupportRequests is ready for today's web.International Domains and URLsKeep-Alive & Connection PoolingSessions with Cookie PersistenceBrowser-style SSL VerificationBasic/Digest AuthenticationElegant Key/Value CookiesAutomatic DecompressionAutomatic Content DecodingUnicode Response BodiesMultipart File UploadsHTTP(S) Proxy SupportConnection TimeoutsStreaming Downloads.netrcSupportChunked RequestsRequests officially supports Python 2.7 & 3.4–3.7, and runs great on
PyPy.InstallationTo install Requests, simply usepipenv(or pip, of
course):$ pipenv install requests
✨🍰✨Satisfaction guaranteed.DocumentationFantastic documentation is available athttp://docs.python-requests.org/, for a limited time only.How to ContributeCheck for open issues or open a fresh issue to start a discussion
around a feature idea or a bug. There is aContributor
Friendlytag for issues that should be ideal for people who are not very
familiar with the codebase yet.Forkthe repositoryon
GitHub to start making your changes to themasterbranch (or
branch off of it).Write a test which shows that the bug was fixed or that the feature
works as expected.Send a pull request and bug the maintainer until it gets merged and
published. :) Make sure to add yourself toAUTHORS.
Package: atmdb
Asynchronous API wrapper forTMDb.CompatibilityaTMDb usesasynciowith theasyncandawaitsyntax, so is only
compatible with Python versions 3.5 and above.Installationatmdbcan be installed fromPyPIusingpip:pip install atmdbTestingYou can run the tests withpython setup.py test. To include the integration
suite, ensure that the environment variableTMDB_API_TOKENis set to a valid
API token, and use--runslowif runningpy.testdirectly.UsageClientThe coreTMDbClientmust be instantiated with a valid API token (see theAPI FAQfor more information), either directly:from atmdb import TMDbClient

client = TMDbClient(api_token='<insert your token here>')or as theTMDB_API_TOKENenvironment variable:client = TMDbClient.from_env()You can then access the API by calling asynchronous helper methods on theclientinstance:movie = await client.get_movie(550)
assert movie.title == 'Fight Club'Any API endpoints not currently exposed via the helper methods can be accessed
by using theurl_builderandget_datamethods directly, for example:url = client.url_builder('company/{company_id}', dict(company_id=508))
                       # ^ endpoint            # ^ parameters to insert
company = await client.get_data(url)
assert company.get('name') == 'Regency Enterprises'Note that, if you aren’t using a helper method, the result is just a vanilla
dictionary.UtilitiesaTMDb also exposes utilities for working with the API and models at a higher
level of abstraction, for example:from aTMDb import TMDbClient
from aTMDb.utils import find_overlapping_actors

actors = await find_overlapping_actors(
    ['monty python holy grail', 'meaning of life'],
    TMDbClient(api_token='<insert your token here>'),
)
assert any(person.name == 'Eric Idle' for person in overlap)DocumentationAdditional documentation is available onPythonHosted.
Package: atmega
ATMEGA APIProvides an API for ATMEGA microcontroller through an FTDI USB device.Installation:pip install atmegaNote:On linux the user should be in the groupdialoutanduucpLocal installationRequirementsInstall dependencieswith pip:pip install -r requirements.txtInstall the librarywith pip:pip install .Run tests:python setup.py testUsageimportloggingfromatmega.ramimportRAM# Set global logging levellogging.basicConfig(level=logging.INFO)# Create device ram objectdev=RAM()# Reset ram to 0x11dev.reset(0x11)# Set high baudratedev.change_baudrate(1000000)# Dump ram into filedev.dump_to_file("dump.txt")# Close devicedev.close()
Package: atml
atmlatml tries to address the following problem:Given a new data set, is there any toolkit that could help me quickly and conveniently come up with a good baseline model?try it outInstall from PyPipipinstallatmlLoad the data set or use your own oneimportpandasaspddf=pd.read_csv("./test/data/binary_data.csv")X=df.drop('Survived',axis=1)label_columns=['Survived']y=df[label_columns]Instantiate and run with AtmlController with defaultfromatmlimportAtmlControlleratml_c=AtmlController(with_default=True)atml_c.run(X,y)Register a new Model and Hyper parameter space for tuningfromatmlimportAtmlOrchestratoratml_o=AtmlOrchestrator(with_default=True)fromsklearn.svmimportSVCsp=[{"property":"kernel","type":"choice","value":["linear","rbf"]},{"property":"gamma","type":"choice","value":["scale","auto"]}]atml_o.auto_learning_socket.register(SVC(),sp)atml_o.run(X,y)'''
Package: atmo
# atmo
Guadeloupe (French West Indies) ATMO pollution indicator (from 1 to 10).This module grabs ATMO pollution indicator from gwadair.com website and show
a digest of these data.This module was created to work in Guadeloupe but should be usable in other
areas with observatory monitoring pollution using ISEO module as well.It can be used as command line tool or as python module.## Indice AtmoThe indice ATMO is the pollution indicator from 1 (very good) to 10 (very bad).
It’s used to show simply the global air quality in a city.Seehttp://www.airparif.asso.fr/reglementation/indice-qualite-air-francais#Actually, this tools works only for Guadeloupe and parse some json files
generated by a module called “ISEO”. Thus this tool should work with data using
the same format. Just put your values in the atmo.cfg file.# install## using pippip install atmo## from sourcegit clonehttps://github.com/Alert-Box/atmocd atmo
python setup.py install# Usage example## Command Line$ atmo## Python Module>>> from atmo.atmo import Atmo
>>> ia = Atmo()
>>> print ia.info()
['ATMO Friday 15 July 2016', "Aujourd'hui : Bon (VERT [4])", 'Demain : Moyen (ORANGE [5])']# LicenceAtmo is a Free Software and is licensed under the GNU General Public License (GPL) Version 3 or later.##      GNU General Public License (GPL) Version 3 or later[![GNU GPL v3.0](http://www.gnu.org/graphics/gplv3-127x51.png)](http://www.gnu.org/licenses/gpl.html)View official GNU site <http://www.gnu.org/licenses/gpl.html>.[![OSI](http://opensource.org/trademarks/opensource/OSI-Approved-License-100x137.png)](http://opensource.org/licenses/mit-license.php)[View the Open Source Initiative site.](http://opensource.org/licenses/mit-license.php)
Package: atmodel
@modelCreate models with less code.Free software: MIT licenseDocumentation:https://atmodel.readthedocs.io.Getting startedInstall @model from pip:pip install atmodelUsing @model is as simple as:from atmodel import model

@model('a', optional=['b'])
class Model:
    passThen use the class as:m = Model(a=1)
if m.a() > 0:
    n = Model(a=1, b=2)CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-10-01)First release on PyPI.
Package: atmopy
AboutModelling the atmosphere is a complicated task since many variables play
a role on the different thermodynamic conditions: solar-fluxes, latitude
and longitude position, diffusion of the different gasses...Since the early days of aviation and astronautics, scientists have tried
to develop different models which take into account all the previous
parameters in order to get the most accurate results. In particular, we
care about density since it is directly related to drag force and
therefore with orbital decay among time.This package is not only a collection of atmospheric routines but also a
tribute to all those people who developed them during the early days of
astronautics.Installation for developersThis Python package makes use of a tool called
[Flit](https://flit.readthedocs.io/en/latest/index.html). In order
to install the package in development mode, please run the following
commands:Execute pip flit installMove inside the atmopy repository folder and run
flit install --symlinkRun nox for checking that atmopy was installed as expected.
Package: atmosphere-cli
The Atmosphere CLI is a command-line client written in Python (based on OpenStack’scliffframework) forAtmosphere. Atmosphere is an integrative, private, self-service cloud computing
platform designed to provide easy access to preconfigured, frequently used analysis routines, relevant algorithms,
and data sets in an available-on-demand environment designed to accommodate computationally and data-intensive
bioinformatics tasks. It is currently in use on theCyVerseandJetstreamprojects.Package Installation (PyPI)DocumentationBugs/IssuesGetting StartedThe Atmosphere CLI can be installed from PyPI using pip:$pipinstallatmosphere-cliThere are a few ways to get help. A listing of supported commands and global options can be shown with--help:$atmo--helpThere is also ahelpcommand that can be used to get help for specific commands:$atmohelpimagelist(Optional) Install bash command line completion to get command hints by tabbing:$atmocomplete>>~/.bash_aliases$.~/.bash_aliases# add to ~/.bashrc or ~/.bash_profile to always load (Ubuntu distro's already load it)$atmo<tab>allocationgroupidentityinstanceprojectsizevolumecompletehelpimagemaintenanceproviderversionConfigurationThe Atmosphere CLI can be configured with environment variables or command-line options. The two required variables
areATMO_BASE_URL, the URL to the corresponding instance of Atmosphere, andATMO_AUTH_TOKEN, the token needed
for authorization. An authorization token can be created by logging into the web client and going to the user menu
(upper right corner) and selectingSettings -> Advanced -> Personal Access Tokens. For instance:exportATMO_BASE_URL="https://atmo.cyverse.org"exportATMO_AUTH_TOKEN="xxxxxxxxxxxxxxxxxxxx"A sample.envfile is provided in the repo. The corresponding command-line options can also be used:--atmo-base-url<URL>--atmo-auth-token<TOKEN>ContributingTo contribute to development and run the included tests:# grab the repo$gitclonehttps://github.com/eriksf/atmosphere-cli$cdatmosphere-cli# install pipenv$pipinstallpipenv# install atmosphere-cli$pipenvinstall--dev# if multiple python versions installed, select with --python option# setup environment$cp.env.sample.env# edit ATMO_BASE_URL and ATMO_AUTH_URL as in Configuration section above# load virtual environment$pipenvshell# this also loads variables in .env to environmentLicenseSee LICENSE.txt for license information.AuthorsErik Ferlanti <eferlanti@tacc.utexas.edu>
Package: atmos-rng
Atmos-rng is a randomness generator based off of atmospheric noise instead of math to generate numbers, make choices, and shuffle lists. It does what you'd think it does, and can be used as an alternative to "random" and Maaayyybee "secrets" if you want something abit more special.Special credits torandom.org.Updates09/05/23choice()can now work with strings.shuffle()now has the ability to shuffle strings.Installation[Directly from here/this repo.][therealOri~]$pipinstallgit+https://github.com/therealOri/atmos-rngor[From Pypi.][therealOri~]$pipinstallatmos-rngUssage and Infoimportatmosif__name__=='__main__':atmos.clear()# clears terminal/cmd window.number=atmos.randint(0,10,1)print(number)stuff=[69,True,False,420,'Apples','Bananas','Cats','Dogs']choice=atmos.choice(stuff)print(choice)scrambled=atmos.shuffle(stuff)print(scrambled)random_bytes=atmos.gen_bytes(32)print(f"{random_bytes}\n{len(random_bytes)}")random_bits=atmos.gen_bits(25)print(random_bits)urlsafe_bytes=atmos.bytes_urlsafe(20)print(urlsafe_bytes)You can find more information here:Documentation.Support  |  Buy me a coffee <3Donate to me here:Don't have Cashapp?Sign Up
Package: atmoswing-vigicrues
atmoswing-vigicruesModule Python pour l'intégration d'AtmoSwing dans le réseau Vigicrues.Documentation API:http://atmoswing.org/atmoswing-vigicruesObjectifLe module a pour but la gestion du flux de la prévision par AtmoSwing. Il permet :de télécharger les fichiers de sortie de modèles météo (p. ex. GFS),de transformer de tels fichiers en un format netCDF générique,d'exécuter les prévisions par AtmoSwing,d'extraire les résultats en d'autres formats (p.ex. json),et de diffuser ces fichiers par SFTP.InstallationPour utiliser le module atmoswing-vigicrues, il faut installer :Python >= 3.7AtmoSwing Forecaster (de préférence la version serveur)Le module atmoswing-vigicrues (pip install atmoswing-vigicruesou l'image dockerdocker pull atmoswing/atmoswing-vigicrues)UtilisationLe paquet est constitué de plusieurs modules qui peuvent être activés et configurés dans un fichier de configuration. Plusieurs flux de prévision peuvent être configurés sur un serveur / PC par la création de différents fichiers de configuration. Il n’y a pas de paramètres codés en dur dans le code. L’exécution d’un flux de prévision est effectuée par la commande :python -m atmoswing_vigicrues --config-file="chemin/vers/fichier/config.yamlLe fichier de configuration définit :Les propriétés de la prévision par AtmoSwingLes pré-actions : les actions à effectuer préalablement à la prévision par AtmoSwingLes post-actions : les actions à effectuer après la prévision par AtmoSwingLes disséminations : les actions de transfert des résultatsLe flux de la prévision est le suivant :pré-actionsprévision par AtmoSwingpost-actionsdiffusionDocumentation API:http://atmoswing.org/atmoswing-vigicrues
Package: atmst
atmstA Python library for wrangling atproto-flavoured Merkle Search TreesCurrent status: prototypeInstallationgit clone https://github.com/DavidBuchanan314/atmst
cd atmst
python3 -m pip install .dev install:python3 -m pip install -e .build the docs:cd docs/
sphinx-apidoc -o source/ ../src/atmst
make html
# open _build/html/index.html
Package: atn
atnBased on the A/T/N/ classification scheme for Alzheimer's disease biomarkersJack et al., 2016,
what this Python module does is basically applying predefined thresholds to a
givenDataFrame(containing biomarker data such
as cerebrospinal fluid (CSF) levels ofABeta42,ptau,ttau) and building
multiple lists of subjects with distinct profiles according to
their CSF biomarkers.Example (with random data):import random
n = 10

abeta42 = [random.randrange(600e3, 1800e3)/1e3 for e in range(0, n)]
ptau = [random.randrange(4e3, 80e3)/1e3 for e in range(0, n)]
ttau = [random.randrange(97e3, 500e3)/1e3 for e in range(0, n)]
data = pd.DataFrame(data=[abeta42, ptau, ttau], index=['abeta42', 'ptau', 'ttau']).transpose()
dataabeta42ptauttau01142.32776.636375.4481833.48477.321181.752951.6016.981309.21531623.79765.063232.3034920.70662.899310.15704.21558.526160.82661687.35753.335422.24971701.99768.676173.3381774.04637.214255.6389939.94621.128164.803import atn
staging = atn.stage(data, thresholds = {'abeta42':1100, 'ptau':19.2, 'ttau':242})
stagingATNID0FALSETRUETRUE1TRUETRUEFALSE2TRUEFALSETRUE3FALSETRUEFALSE4TRUETRUETRUE5TRUETRUEFALSE6FALSETRUETRUE7FALSETRUEFALSE8FALSETRUETRUE9TRUETRUEFALSEprint(atn.staging_summary(staging))CSF amyloid (A) positive/negative: 5/5
CSF ptau (T) positive/negative: 9/1
CSF ttau (N) positive/negative: 5/5A+T+: 4
A+T-: 1
A-T-: 0
A-T+ (SNAPs): 5A+T+N+: 1
A+T+N-: 3
A-T+N+: 3
A-T+N-: 2
A-T-N-: 0
A-T-N+: 0
Total subjects: 10So yes, it is simple, stupid. But this allows one to quickly select groups of
subjects as follows:groups = atn.groups(staging)
data.loc[groups['A+'].index]abeta42ptauttauID1833.48477.321181.752951.6016.981309.2154920.70662.899310.15704.21558.526160.8269939.94621.128164.803DependenciesPython >= 3.5Pandas >= 0.24.1InstallFirst make sure you have installed all the dependencies listed above. Then you can installatnby running the following command in a command prompt:pip install atn
Package: atnlp
atnlpA tool for natural language processing in python based on scipy and sklearn.Current focus is topic labelling.Read the docsfor more information.Technologiesatnlp uses the following technologies:conda- datascience platformscipy- datascience toolssphinx- documentaionbumpversion- semantic versioninggithub- software development platformtravis- continuous integrationQuick startMore details inquickstart docsPrerequisitesconda(anaconda / miniconda) - follow theinstallation instructionsfor your platform and select python 3 version.After installing updatecondafrom theconda-forgerepo:conda update conda -c conda-forgeInstall (production)Install atnlp (with pip) and its dependencies (with conda):wgethttps://raw.githubusercontent.com/wedavey/atnlp/master/envprod.yml
condaenvcreate-fenvprod.yml-natnlp
condaactivateatnlpInstall (development)Forkwedave/atnlpthen install
from github:gitclonegit@github.com:<your-user-name>/atnlp.git
condaenvcreate-fatnlp/envdev.yml-natnlp-dev
condaactivateatnlp-devcdatnlp;pythonsetup.pydevelopRunning testsTODO...DeploymentStarttraining topic modelsstraight away using scripts, or open a notebook and start hacking.VersioningWe useSemVerfor versioning, implemented through bumpversion.
For the versions available, see thetags on this repository.AuthorsWill Davey- main developerLicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for details
Package: atoi
Usage# Build the virtualenv and install required modules,
# including this one in editable mode
0/make_venv.sh. Venv/bin/activate# Build the module
0/build.sh# Register the built module with PyPI
0/register.sh# Upload a new build to PyPI
0/upload.sh# Delete all built files
0/clean.shDevelopmentRun0/make_venv.shfirst. venv/bin/activate
# This IPython config will set autoreload
ipython –config=0/ipython_config.py
Package: atol-client
Web Client Lib forATOL POSterminalA small library - client for ATOL APIImplemented functionsbuybuyCorrectionbuyReturncashIncashOutchangeRegistrationParameterscloseArchivecloseShiftcontinuePrintfnChangegetDeviceInfogetDeviceStatusgetFnInfogetRegistrationInfogetShiftStatusnonFiscalofdExchangeStatusopenShiftregistrationreportOfdExchangeStatusreportXsellsellCorrectionsellReturnInstallpipinstallatol-clientTestspipinstall-rrequirements.txt
flake8.--show-source--statistics&&python-mpytest.UsagefromatolimportWebClientif__name__=='__main__':atol=WebClient("http://atol-host")print(atol.get_shift_status())
Package: atom
Atom is a framework for creating memory efficient Python objects with enhanced
features such as dynamic initialization, validation, and change notification for
object attributes. It provides the default model binding behavior for theEnamlUI framework.Examples:fromatom.apiimportAtom,Str,Range,Bool,observeclassPerson(Atom):""" A simple class representing a person object.

    """last_name=Str()first_name=Str()age=Range(low=0)debug=Bool(False)@observe('age')defdebug_print(self,change):""" Prints out a debug message whenever the person's age changes.

        """ifself.debug:templ="{first}{last}is{age}years old."s=templ.format(first=self.first_name,last=self.last_name,age=self.age,)print(s)def_default_first_name(self):return'John'john=Person(last_name='Doe',age=42)john.debug=Truejohn.age=43# prints messagejohn.age='forty three'# raises TypeErrorStarting with atom 0.8.0 atom object can also be defined using type annotations.fromatom.apiimportAtom,observeclassInventoryItem(Atom):"""Class for keeping track of an item in inventory."""name:strunit_price:floatquantity_on_hand:int=0deftotal_cost(self)->float:returnself.unit_price*self.quantity_on_hand@observe("unit_price")defcheck_for_price_reduction(self,change):savings=change.get("oldvalue",0)-change.get("value")ifsavings>0:print(f"Save ${savings}now on{self.name}s!")>>>w=InventoryItem(name="widget",unit_price=1.99,quantity_on_hand=10)>>>w.unit_price=1.00Save$0.99nowonwidgets!For version information, seethe Revision History.
Package: atom2vec
Atom2VecA python implement of Atom2Vec: a simple way to describe atoms for machine learning(Updated 06/21/2021: We refactored the code withpymatgen, you can find old version in branchold_version. Now the code is fully typed and tested.)BackgroundAtom2Vec is first proposed onZhou Q, Tang P, Liu S, et al. Learning atoms for materials discovery[J]. Proceedings of the National Academy of Sciences, 2018, 115(28): E6411-E6417.DemoInstallationpipinstallatom2vecUsageGenerating atom vectors and atom similarity matrixWe usepymatgen.core.Structureto store all the structures.fromatom2vecimportAtomSimilarityfrompymatgen.coreimportStructurefromtypingimportListstructures:List[Structure]atom_similarity=AtomSimilarity.from_structures(structures,k_dim=100,max_elements=3)Query atom vectorsfromatom2vecimportAtomSimilarityfrompymatgen.coreimportElementfromtypingimportListatom_similarity:AtomSimilarityatom_vector:List[float]atom_vector=atom_similarity.get_atom_vector(1)# atomic indexatom_vector=atom_similarity.get_atom_vector("H")# atom's nameatom_vector=atom_similarity.get_atom_vector(Element("H"))# pymatgen Element EnumQuery atom similarityfromatom2vecimportAtomSimilarityfrompymatgen.coreimportElementatom_similarity:AtomSimilaritysimilarity:floatsimilarity=atom_similarity["Ca","Sr"]