Saravanan666/pypi-org huggingface dataset:
Package: pyaps3
PyAPS - Python based Atmospheric Phase Screen estimationThis python 3 module estimates differential phase delay maps due to the stratified atmosphere for correcting radar interferograms. It is rewritten in Python 3 language from PYAPS source code and adapted for ECMWF's ERA-5 corrections.WARNING: The current version does not work with NARR and MERRA datasets. Contributions are welcomed.This is research code provided to you "as is" with NO WARRANTIES OF CORRECTNESS. Use at your own risk.1. Installationa. Install the released version [recommended]pyaps3is available on theconda-forgechannel,PyPIand the main archive of theDebianGNU/Linux OS. The released version can be installed viacondaas:condainstall-cconda-forgepyaps3or viapipas:pipinstallpyaps3or viaapt(or other package managers) forDebian-derivative OSusers, includingUbuntu, as:aptinstallpython3-pyaps3b. Install the development versionThe development version can be installed viapipas:pipinstallgit+https://github.com/insarlab/PyAPS.gitor build from source manually as:gitclonehttps://github.com/insarlab/PyAPS.git
condainstall-cconda-forge--filePyAPS/requirements.txt
python-mpipinstall-ePyAPSTest the installation by running:pythonPyAPS/tests/test_calc.py2. Account setup forERA5ERA5 data set is redistributed over the Copernicus Climate Data Store (CDS). Registration is required for the data access and downloading.Create a new accounton the CDS website if you don't own a user account yet.Create local key file. Create a file named.cdsapircin your home directory and add the following two lines:url:https://cds.climate.copernicus.eu/api/v2
key:12345:abcdefghij-134-abcdefgadf-82391b9d3fwhere 12345 is your personal user ID (UID), the part behind the colon is your personal API key. More details can be foundhere.Make surethat you accept the data license in the Terms of use on ECMWF website.Test the account setup by running:gitclonehttps://github.com/insarlab/PyAPS.git--depth1pythonPyAPS/tests/test_dload.py3. Citing this workThe methodology and validation can be found in:Jolivet, R., R. Grandin, C. Lasserre, M.-P. Doin and G. Peltzer (2011), Systematic InSAR tropospheric phase delay corrections from global meteorological reanalysis data,Geophys. Res. Lett., 38,L17311, doi:10.1029/2011GL048757.
Package: pyaptly
Automates the creation and managment of aptly mirrors and snapshots based on yml
input files.[1]Read the Docs[1]Coverage enforced by tests (on travis)Example commandsInitialize a new aptly server.pyaptly-cmirrors.ymlmirrorcreatepyaptly-cmirrors.ymlmirrorupdatepyaptly-cmirrors.ymlsnapshotcreatepyaptly-cmirrors.ymlpublishcreateUpdate mirrors and snapshots and switch publish endpoints withautomatic-update:trueto the new snapshots.pyaptly-cmirrors.ymlmirrorupdatepyaptly-cmirrors.ymlsnapshotcreatepyaptly-cmirrors.ymlpublishcreatepyaptly-cmirrors.ymlpublishupdateManually trigger a switch to the new snapshots for the publish endpoint
ubuntu/stable.pyaptly -c mirrors.yml publish update ubuntu/stableInstall Debian/UbuntuSources:deb http://aptly.adfinis-sygroup.ch/adsy-public/debian wheezy main

deb http://aptly.adfinis-sygroup.ch/adsy-public/debian jessie main

deb http://aptly.adfinis-sygroup.ch/adsy-public/ubuntu trusty main

deb http://aptly.adfinis-sygroup.ch/adsy-public/ubuntu vivid main

deb http://aptly.adfinis-sygroup.ch/adsy-public/ubuntu xenial mainInstall:wget-O-http://aptly.adfinis-sygroup.ch/aptly.asc|apt-keyadd-apt-getupdateapt-getinstallpython-pyaptlyTestingAutomaticgitsubmoduleupdate--init--recursivemaketest-localManual. There is a safety check in tests. They won’t work if you don’t set
$HOME.gitsubmoduleupdate--init--recursivesourcetestenvpy.test-xorgitsubmoduleupdate--init--recursiveexportHOME="$(pwd)"exportPATH="$HOME/aptly_0.9.6_linux_amd64/:$PATH"py.test-xVagrant BoxThe box provisions aptly, nginx and two repos which can be used for tests:aptly mirror create mirro-fakerepo01 http://localhost/fakerepo01 main
aptly mirror create mirro-fakerepo02 http://localhost/fakerepo02 main
Package: pyaqi
pyaqiMódulo para cálculo do IQAr - Índice de Qualidade do Ar (AQI - Air Quality Index).InstallpipinstallpyapiUsageA atual versão comporta somente o algoritmo brasileiro. Para saber mais
sobre a metodologia brasileira,consulte
aqui.Com o pacote você pode converter a concentração média de um único poluente
para o seu índice intermediário de qualidade (IQAI):importaqimyaqi=aqi()myaqi.get_iaqi(210,"pm10_24h",algo=myaqi.aqi_brazil)# out: 168Ou obter o índice de qualidade do ar dadas as concentrações de múltiplos
poluentes. Abaixo utilizamos o exemplo do capítulo 9 da metodologia brasileira:importaqimyaqi=aqi()# Calculando cada um dos poluentesmyaqi.get_iaqi(210,"pm10_24h",algo=myaqi.aqi_brazil)myaqi.get_iaqi(135,"o3_8h",algo=myaqi.aqi_brazil)myaqi.get_iaqi(220,"no2_1h",algo=myaqi.aqi_brazil)myaqi.get_aqi()# por padrão usa o algo brasileiro# out: 168# Ou passando todas as concentracoes num unico dicionariomyaqi.get_aqi({"pm10_24h":210},{"o3_8h":135},{"no2_1h":220},algo=myaqi.aqi_brazil)# out: 168
Package: pyaqua
pyaqua: Simple CLI for Aqualink APIAqualink is a philanthropic engineering organization working on building ocean conservation technology. Read more about theirinspiration, smart buoy, and web application. This tool is designed to help interact programmatically with theAqualink.org mapand is not based on any official API so expect features to break once in a while. This tool is designed for only only those sites associated with a spotter or a hobo sensor.Disclaimer: This is an unofficial tool. Is not licensed or endorsed by Aqualink org. It is created and maintained by Samapriya Roy.CitationSamapriya Roy. (2022). samapriya/pyaqua: Simple CLI for Aqualink Org (0.1.0).
Zenodo. https://doi.org/10.5281/zenodo.7123727Readme Docsavailable online
Package: pyaqueduct
PyAqueduct: Aqueduct Python Client LibraryAqueduct is a versatile experiment management system designed to streamline and simplify quantum system administration. Automation, data management and a multi-user platform come together to facilitate demanding experimental activities, through an intuitive, consistent, open interface. With robust security features including role-based access control and authentication, Aqueduct ensures data integrity and accessibility throughout the experiment pipeline.Aqueduct is an extensible platform, with a full API allowing connectivity with external systems, and a plugin SDK allowing extensions to expand core Aqueduct functionality in a flexible and secure way. This first version of Aqueduct contains data management tools that augment a lab’s existing data storage systems by tracking critical settings, raw data and processed data from experiments, keeping them organised and readily accessible. Through convenient features such as tagging, favouriting, archiving, and annotation of experimental data, we facilitate a smoother data workflow for all labs. Aqueduct’s software APIs make it possible to retrofit existing experiment scripts so that all the lab’s data, not just the data produced by Deltaflow.Control, can be saved and accessed in a single, centralized location.This functionality is faciliated through 2 components:aqueductcoreis  the server software that hosts the main application, web interface, and handles data storage.pyaqueductis our python client which allows easy creation of experiments and upload of data and metadata for them.InstallationYou can install PyAqueduct releases from PyPi:pipinstallpyaqueductContributingAqueduct is an open-source project, and we greatly value all contributions. Contributions are not limited to coding; you can also help by filing issues to report bugs, enhancing our documentation, or requesting new features. We strongly recommend using the templates provided for each of these tasks. If you’re interested in contributing, please refer to ourcontribution guidefor more information. We really appreciate your consideration for contributing to Aqueduct.LicenseThis project is licensed under the MIT License - see theMITfile for details
Package: pyaramex
pyaramexA lightweight, unifying Python wrapper around Aramex web services.Supports the Tracking, Location, Shipping and Rates API'sLazy-loading of WSDL filesRequirementsClient Info, which must be obtained from Aramex directlyAll requests must be made via HTTPS - for more information, visit the Aramex Web Developer documentationInstallation$ pip install pyaramexGetting startedInitialising the clientClientInfo can either be provided to the client using environment variables or by initialising them directly when you initialise the Aramex object.frompyarameximportAramexaramex=Aramex()Making requestsAll Aramex services are named as they appear in the respective Web Services albeit using Python underscore syntax."""The rates client and Rates WSDL are loaded only when called, thereafter they're cached for the duration of the session"""rate_response=aramex.rates.get_rate()
Package: pyArango
pyArango aims to be an easy to use driver for ArangoDB with built in validation. Collections are treated as types that apply to the documents within. You can be 100% permissive or enforce schemas and validate fields on set, on save or on both.pyArango supports graphs, indexes and probably everything thatarangodbcan do.pyArango is developed byTariq Daouda, the full source code is available fromgithub.For the latest news about pyArango, you can follow me on twitter@tariqdaouda.
If you have any issues with it, please file a github issue.
Package: pyARB
pyARBA localization library for python utilizing the ARB format for Flutter.ChangelogUsagepyARB takes a primary .arb file and generates a python code equivalent.pyarb l10ns [-h] [-e USE_EXISTING] arb_location [target_directory]

positional arguments:
  arb_location          The directory containing the arb files.
  target_directory      Location of the generated py file. Defaults to the directory above arb_location.

optional arguments:
  -h, --help            show this help message and exit
  -e USE_EXISTING, --use-existing USE_EXISTING
                        Use existing arb files as locale list. You must specify the primary arb herepyarb l10ns path/to/directorywill prompt the user for a list of locales. The first in the list will be considered the primary locale and it will also be set as the fallback in case there is a problem with another locale. The primary.arbfile must be present. If other locales are missing it will create the missing.arbfile with the contents of the primary file. If a locale is already present then it will be left as it is to preserve translations already present in that file.pyarb l10ns path/to/directory -e en_USwill use the existing arb files as the list of allowed locales. It will use the specified locale as the primary locale, in this case: 'en_US'.ExampleBoth of the above examples will create thegenerated_components.pyfile atpath/towhich you can then use in your code.frompath.to.generated_componentsimportTranslator,Langt=Translator(Lang.en_US)print(t.followers_count(999950))print(t.many_items("Bob",10))# Also supports static referencesprint(Translator.followers_count_static(Lang.es_ES,6851651))print(Translator.many_items_static(Lang.es_ES,"Juan",3))Docstrings are also provided to show what variables are needed for the translation key so your IDE can show you exactly what each localization is, what it needs, and what it will do.A word on arb filesIf you are not sure on how arb files are formatted read through the documentation found onlocalizelyDoes not yet supportDateTime and Object types in the .arb specification.ThecompactLongformat for number types.
Package: pyarbtools
Current version: 2023.10.1Frustrated after looking through hundreds of pages of user manuals to find out how to download a waveform to a signal generator?Need to test your amplifier or filter with a complex signal but don’t want to crack open your digital signal processing books from college?Tired of troubleshooting VISA connections, conflicts, and incompatibilities?Can’t get a Matlab license or the correct toolbox(es) for your work?Try PyArbTools: a fast, free, and flexible way to create waveforms and control Keysight signal generators.PyArbTools is a collection of Python classes and functions that provide basic signal creation, instrument configuration, and waveform download capabilities for Keysight signal sources.It islooselybased on Keysight’sIQ Tools, a Matlab-based toolkit that accomplishes similar things.
PyArbTools was built to satisfy the needs of signal generator users who can’t/don’t want to use Matlab and to improve code readability and documentation.FeaturesNew in 2023.06.1:Choose between direct socket communication and PyVISA for all instruments.Supports M8190A, M8195A, and M8196A arbitrary waveform generators, N5182B MXG/N5172B EXG/E8267D PSG vector signal generators, and the M9384B VXG vector signal generator.Connect to and configure instruments, download waveforms, and control playback, all using easy-to-use functions rather than a list of SCPI commands.Create sequences on the M8190A.Calibrate waveforms using Keysight’s 89600 VSA software.For custom applications, communicate with instruments using SCPI commands.DOCUMENTATIONTake a look atpyarbtools/examples.pyfor sample code.PyArbTools was written for Python and is not currently compatible with legacy Python 2.xLicense: GPL 3
Package: pyarc
pyARCpyARC is an implementation of CBA (Classification Based on Assocation) algorithm introduced inLiu, B. Hsu, W. and Ma, Y (1998). Integrating Classification and Association Rule Mining. Proceedings KDD-98, New York, 27-31 August. AAAI. pp 80-86.In addition, pyARC contains the implementation of QCBA (Quantitative CBA) algorithm introduced inKLIEGR, Tomas. Quantitative CBA: Small and Comprehensible Association Rule Classification Models. arXiv preprint arXiv:1711.10166, 2017.The use ofQCBAalgorithm is demonstrated inthis jupyter notebook.Thefimpackage is used for the rule generation step.If you find this package useful in your research, please cite (EasyChair link):@techreport{filip2018classification,
  title={Classification based on Associations (CBA)-a performance analysis},
  author={Filip, Ji{\v{r}}{\'\i} and Kliegr, Tom{\'a}{\v{s}}},
  year={2018},
  institution={EasyChair}
}Installationpip install pyarcFor using pyARC, thefimpackage needs to be installed (refer tohttp://www.borgelt.net/pyfim.htmlfor installation guide).Testingpython -m unittest discover -s pyarc/test  -p '*test_*.py'ExamplesSimplest examplefrompyarcimportCBA,TransactionDBimportpandasaspddata_train=pd.read_csv("iris.csv")data_test=pd.read_csv("iris.csv")txns_train=TransactionDB.from_DataFrame(data_train)txns_test=TransactionDB.from_DataFrame(data_test)cba=CBA(support=0.20,confidence=0.5,algorithm="m1")cba.fit(txns_train)accuracy=cba.rule_model_accuracy(txns_test)Using top_rules function to mine the best rules possiblefrompyarcimportTransactionDBfrompyarc.algorithmsimport(top_rules,createCARs,M1Algorithm,M2Algorithm)importpandasaspddata_train=pd.read_csv("iris.csv")data_test=pd.read_csv("iris.csv")txns_train=TransactionDB.from_DataFrame(data_train)txns_test=TransactionDB.from_DataFrame(data_test)# get the best association rulesrules=top_rules(txns_train.string_representation)# convert them to class association rulescars=createCARs(rules)classifier=M1Algorithm(cars,txns_train).build()# classifier = M2Algorithm(cars, txns_train).build()accuracy=classifier.test_transactions(txns_test)
Package: pyarc2
Python bindings for libarc2IntroductionThis library presents a python interface to the low-levellibarc2library
used to interface with ArC TWO™. Most of the user-facing facilities oflibarc2are present in this library. That being said,pyarc2itself is
still relatively low-level and a general understanding of the internals of
ArC TWO is required.Usepyarc2maps most of the functionality oflibarc2so the API translates
fairly transparent. Most of the interaction with ArC TWO will be through theInstrumentclass that encapsulates the implemented functionality oflibarc2. The library will keep being updated as new functionality is added.
For instance to read the current between two channels you can writefrompyarc2importInstrument,find_ids# low voltage channel (typically grounded)LOWV=7# high voltage channelHIGHV=33# read-out voltageVREAD=0.2# Get the ID of the first available ArC TWOarc2id=find_ids()[0]# firmware; shipped with your boardfw='arc2fw.bin'# connect to the boardarc=Instrument(arc2id,fw)current=arc.read_one(LOWV,HIGHV,VREAD)print('I =%gA'%current)Additional functionalitypyarc2can also be used to implement new plugins based onlibarc2.  Access
to the lower level object is done viaInstrument::inner()andInstrument::inner_mut(). These plugins can fully leveragelibarc2functionality but require some familiarity with Rust and thelibarc2API.
Package: pyarcanist
pyarcanistA simple cli tool for Phabricator. Aims at being some sort of arcanist on
steroids.InstallationPreferably in a venv:(venv) user@host:~/src/project$ pip install pyarcanistUsageThe main cli entry point is thepyarccommand:(venv) user@host:~/src/project$ pyarc --help
Usage: pyarc [OPTIONS] COMMAND [ARGS]...

  Entry point

Options:
  -v, --verbose / --no-verbose
  -h, --host TEXT
  -t, --token TEXT
  --help                        Show this message and exit.

Commands:
  diff          List Diffs
  send-message  Send a harbormaster message
  whoami        Gives informations on the current userBy default, it will use your~/.arcrcfile to get your Phabricator connection
credentials, but you can also pass the--hostor--tokenoptions.DiffThis commands allows to query currently open Phabricator Diff objects (not only
your Diff).(venv) user@host:~/src/project$ pyarc diff --help
Usage: pyarc diff [OPTIONS]

  List Diffs

Options:
  -u, --mine / --all-users
  -A, --all-repos / --current-repo
  -s, --summary / --default
  --help                          Show this message and exit.If it is executed from a directory which is a git repo corresponding to a
Phabricator repository (a Diffusion oject), then the default behavior of thediffcommand is to display Diff objects for the current repo only
(ie.--current-repo).If it is executed in a directory that does not match any project in
Phabricator, then all (open) Diff are returned by default (ie.--all-repos).Note that the matching between the local git repository and the Phabricator
Diffusion object if made on tracked remote repositories (git remote): it looks
for a configured tracked repositories of the local git which URL corresponds to
a public URI of one of the Phabricator Diffusion object.Examples:(venv) user@host:~/src/project$ pyarc diff -As
Changes Planned  D617: Always output valid JSON-LD.
Accepted         D619: Translate authors from package.json

(venv) user@host:~/src/project$ pyarc diff -A
Needs Review     D617
Repo: swh-indexer (DCIDX)
Author: vlorentz
Created: 7 days ago
Modified: 38 minutes ago
Summary:
  Always output valid JSON-LD.

  Our metadata extraction used to export a nested dict structure
  loosely based on JSON-LD with schema.org/CodeMeta.

  This diff makes it output proper JSON-LD data.

  Note that because of some issues (eg.
  https://github.com/codemeta/codemeta/issues/198 and the impossibility to
  represent a software entity without a specific version), I removed
  `softwareRequirements` and `softwareSuggestions` from the output

  As a side-effect, it resolves T1289

  PS: Morane, don't review this diff today, it can wait until tomorrow :)

Needs Review     D619
Repo: swh-indexer (DCIDX)
Author: vlorentz
Created: 6 days ago
Modified: 33 minutes ago
Summary:
  Translate authors from package.json

  This is an example of hardcoded translation that's impossible
  to do directly from the crosswalk table
Package: pyarchappl
PyArchApplPython client forArchiver Appliance.Installationpip install pyarchappl [--upgrade]User GuideCommand line toolpyarchappl-getis the best tool that could be used for
data retrieval, read the usage help message by-hoption.Development[Optional] Set up Archiver Appliance testing environmentData Retrieval Clientfromarchappl.clientimportArchiverDataClientimportmatplotlib.pyplotaspltplt.style.use('ggplot')client=ArchiverDataClient()client.url='http://127.0.0.1:17665'# default url, optional.pv='TST:gaussianNoise'data=client.get_data(pv)data.plot()plt.show()Data (PV) Management Clientfromarchappl.clientimportArchiverMgmtClientclient=ArchiverMgmtClient()client.url='http://127.0.0.1:17665'all_pvs=client.get_all_pvs()print(all_pvs)# [u'TST:fakeGaussianNoise', u'TST:gaussianNoise', u'TST:uniformNoise']
Package: pyarcher
RSA Archer Client LibraryPython client library for interfacing with RSA Archer.Free software: MIT licenseDocumentation:https://pyarcher.readthedocs.io.FeaturesTODOInstallArcherDB requires pyodbc for connecting to mssql so you may need to install
additional packages.Ubuntu:Required packages are unixodbc-dev g++ freetds-dev freetds-bin
tdsodbcCentos:Required packages are gcc-c++ python-devel unixODBC-devel freetdsNote:In the future we will have pyarcher.ArcherDB separated from
pyarcher.Archer.You may also need to configure your ODBC ini. For example in /etc/odbcinst.ini
you may need the following configure[FreeTDS]Description=FreeTDS DriverDriver=/usr/lib/x86_64-linux-gnu/odbc/libtdsodbc.soSetup=/usr/lib/x86_64-linux-gnu/odbc/libtdsS.sotds_version=8.0FreeTDS python examplefrompyarcherimportArcherDBarcher=ArcherDB("user","password","host","database",query={"driver":"FreeTDS","TDS_VERSION":"8.0"})table=archer.get_table("tblAsyncJobQueue")select=table.select()data=archer.engine.execute(select)HistoryComing Soon…
Package: pyArchery
Archery is an opensource vulnerability assessment and management tool which helps developers and pentesters to perform scans and manage vulnerabilities. Archery uses popular opensource tools to perform comprehensive scanning for web application and network. It also performs web application dynamic authenticated scanning and covers the whole applications by using selenium. The developers can also utilize the tool for implementation of their DevOps CI/CD environment.For More detailsRequirementsArchery toolPython 2.7Quick StartSeveral quick start options are available:Install with pip:pip install PyArcheryBuild locally:python setup.py buildDownload the latest releaseExample# Import the package
from archery import api

# Set Archery url
host = 'http://127.0.0.1:8008'

# Setup archery connection
archery = api.ArcheryAPI(host)

# Provide Archery Credentials for authentication.
authenticate = archery.archery_auth('admin', 'admin@123A')

# Collect Token after authentication
token = authenticate.data
for key, value in token.viewitems():
    token = value

# List all Projects
project = archery.list_project(auth=token)

# Printing in Json Format
print project.data_json()Bugs and Feature RequestsIf you Found bug or have a feature request? Please open a new issue