Saravanan666/pypi-org huggingface dataset:
Package: pyadb
Simple python module to interact with the ADB toolHow to install:Currently there is no Debian package available for PyADB. (Will be fixed soon…)#[+] Debian Package:
#
#$ sudo dpkg -i python-pyadb_0.1.0-1_all.deb
#Selecting previously unselected package python-pyadb.
#(Leyendo la base de datos … 322039 ficheros o directorios instalados actualmente.)
#Desempaquetando python-pyadb (de python-pyadb_0.1.0-1_all.deb) …
#Configurando python-pyadb (0.1.0-1) …
#$[+] easy_install$ sudo easy_install pyadb
Searching for pyadb
…
Processing dependencies for pyadb
Finished processing dependencies for pyadb
$[+] setup.py$ python setup.py build
running build
running build_py
creating build
creating build/lib.linux-i686-2.7
creating build/lib.linux-i686-2.7/pyadb
copying pyadb/adb.py -> build/lib.linux-i686-2.7/pyadb
copying pyadb/__init__.py -> build/lib.linux-i686-2.7/pyadb
$ sudo python setup.py install
running install
running build
running build_py
running install_lib
running install_egg_info
Removing /usr/local/lib/python2.7/dist-packages/pyadb-0.1.1.egg-info
Writing /usr/local/lib/python2.7/dist-packages/pyadb-0.1.1.egg-info
$More instructions:http://wiki.python.org/moin/CheeseShopTutorialUsage:$ python
Python 2.7.3 (default, Jun 15 2012, 18:14:05)
[GCC 4.7.0] on linux2
Type “help”, “copyright”, “credits” or “license” for more information.
>>> from pyadb import ADB
>>> adb = ADB(‘~/android/platform-tools/adb’)
>>> print adb.pyadb_version()
0.1.1
>>> quit()
$You can view a “complete” example in “examples/whatsapp.py”
Package: pyadbautomator
PyAdbAutomatorPyAdbAutomator is a Python library for automating some android tasks using ADB interfaceInstallationUse the package managerpipto install foobar.pipinstallpyadbautomatorUsagefrompyadbautomator_package.pyadbautomatorimportPyAdbAutomatorpy_adb_automator=PyAdbAutomator('com.android.chrome',5)py_adb_automator.open()url_bar=py_adb_automator.first('resource-id','com.android.chrome:id/url_bar')ifurl_bar:url_bar.text('https://github.com/guifabrin')py_adb_automator.enter()time.sleep(10)py_adb_automator.close()ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: pyaddepar
pyaddeparSome utility code for interacting with addepar. For more information on addepar please check outhttps://addepar.com/.Installing pyaddeparInstall with pippip install pyaddeparAddeparRequestAddeparRequest is a class hiding the management of your key(s), the pagination of requests and conversion of your results to standard pandas containers.import pandas as pd
from pyaddepar.addeparrequest import AddeparRequest

if __name__ == '__main__':
    r = AddeparRequest(key=..., secret=..., id=..., company=...)
    today = pd.Timestamp("today")

    for key, entity in r.options:
        expiry = pd.Timestamp(entity["expiration_date"])
        if expiry >= today:
            print(expiry)
            print(entity)
            print(entity["option_type"])
            print(entity["node_strike_price"])

            print((expiry-today).days/365.0)Settings.cfgWe recommend to define a configuration file(*.cfg)containingADDEPAR = {"key":"A",
"secret":"B",
"id":"maffay",
"company":"maffay"
}Flask-AddeparA Flask extension that provides integration with Addepar. In particular this flask extension provides
management of the your AddeparRequests. You can use configuration files such as settings.cfg to follow standard flask practices.
The configuration is easy, just fetch the extension:from flask import Flask

from pyaddepar.flask_addepar import addepar

if __name__ == '__main__':
    app = Flask(__name__)
    app.config.from_pyfile('config/settings.cfg')
    addepar.init_app(app)

    with app.app_context():
        for key, entity in addepar.request.entities():
            print(key)
            print(entity)
Package: pyaddict
pyaddictDescriptionYet another python library to safely work with json data. It implements many useful features such as optional chaining, schema validation, type casting, safe indexing and default values.InstallationpipinstallpyaddictUsagefrompyaddictimportJDict,JListfrompyaddict.schemaimportObject,String,Integer,Arrayjdict=JDict({"name":"John","age":30,"cars":[{"model":"BMW 230","mpg":27.5},{"model":"Ford Edge","mpg":24.1}]})# dictsprint(jdict.ensure("name",str))# Johnprint(jdict.ensure("age",int))# 30print(jdict.ensure("age",str))# ""print(jdict.ensureCast("age",str))# "30"print(jdict.optionalGet("age",str))# Noneprint(jdict.optionalCast("age",str))# "30"print(jdict.optionalGet("gender",str))# Noneprint(jdict.optionalCast("gender",str))# Noneprint(jdict.ensure("gender",str))# ""# listscars=jdict.ensureCast("cars",JList)print(cars.assertGet(1,dict))# {'model': 'Ford Edge', 'mpg': 24.1}print(cars.assertGet(2,dict))# AssertionError# iteratorsforcarincars.iterator().ensureCast(JDict):print(car.ensureCast("model",str))# BMW 230, Ford Edge# chainingchain=jdict.chain()print(chain.ensureCast("cars[1].mpg",str))# "24.1"print(chain.ensureCast("cars[2].mpg",str))# ""# or via direct access (returns Optional[Any]!)print(chain["cars[2].mpg"])# IndexErrorprint(chain["cars[2]?.mpg"])# None# schema validationschema=Object({"name":String(),"age":String().coerce(),"dogs":Array(String()).min(1).optional()}).withAdditionalProperties()print(schema.error(dict))# NonebadSchema=Object({"name":String().min(5),"age":Float(),"cars":Object()})print(badSchema.error(dict))# ValidationError(expected 4 to be greater than or equal to 5, name: min)The library is fully typed and thus can be used with mypy & pylint. Check out thewikifor more information.When to useWhen working with json data, it is common to have to deal with missing keys, wrong types, etc. This library provides a simple way to deal with these issues. Additionally, it provides easy-to-use typing support for mypy and pylint and detailed documentation.
Starting with version 1.0.0, pyaddict includes a schema validation feature inspired byzod. It is especially useful when validating user input, e.g. in web applications.LicenseMITAuthordxstiny
Package: pyaddlicense
pyaddlicensepyaddlicense adds license headers to any source file it finds that does not have one. By default it respects.gitignoreand doesn't touch autogenerated files.It is inspired byaddlicense, but includes more features and can be used in environments that might not havegoordocker.Default Example:pyaddlicense -o 'Example Company'InstallationWe reccomend installingpyaddlicenseglobally viapipxso that it remains in an isolated environment:pipx install pyaddlicenseHowever,pipshould also work if you want to include it solely in your local venv:pip install pyaddlicenseUsage and flagsDefaultBy default, only the-o(or--owner) flag is required to say who the holder/owner of the license is:pyaddlicense -o 'Example Company'This will recursively search every file and every directory from the current one and add the default license to every file where a license is missing any the file isn't autogenerated. This will respect any .gitignore entries.The default license is:(c) Copyright {{ .HOLDER }} {{ .YEAR }}. All rights reserved.where both{{ .HOLDER }}and{{ .YEAR }}are macros that will be replaced by the string given as-oand the current year respectively.Check modeIf you just want to see what files are missing licenses, you can use the-c(or--check) flag:pyaddlicense -o 'Example Company' -cCustom IgnoreYou can additional files or folders to ignore with the-i(or--ignore) flag:pyaddlicense -o 'Example Company' -i .flake8 -i pyproject.tomlNOTE: This will beadditionalto.gitignore, if you want to disable.gitignorechecking and completely manage the ignore rules yourself, also set--ignore-gitignore=0.Custom licenseIf you want to use your own license, there are two options.Option 1:Use the-lflag to pass the license as a string (which can also include macros, as detailed in the Default section):pyaddlicense -o 'Example Company' -l '{{ .HOLDER }} {{ .YEAR }}. Absolutely no rights reserved and no warranty given.'Option 2:Use the-fflag to pass the license as a file (which can also include macros, as detailed in the Default section):pyaddlicense -o 'Example Company' -f ~/licenses/norightsreserved.tplSilent modeYou can disable console output via the-s(or--silent) flag. This is useful for integratingpyaddlicenseinto a linting/CI pipeline without warping the logs too much:pyaddlicense -o 'Example Company' -c -s(When running incheck mode(detailed above),pyaddlicensewill have anon-zero exit codeif files are found that need changes)DevelopmentNOTE:Local development requirespoetryto be installed.Clone this repo:git clone https://github.com/kixa/pyaddlicenseInstall our dependencies:poetry installTesting:Run the tests via:poetry run pytestLinting:Lint any changes with:poetry run black src/ tests/ && poetry run flake8 src/ tests/ && poetry run isort src/ tests/
Package: pyaddy
pyaddyA Python CLI to interact with addy.ioInstallingIn your python environment install the package - e.g. using poetrypoetry add pyaddyaddy --helpYou must first run theload-keycmd otherwise all other cmds will failNote requires 3.11+Basic Usage - see command section for example outputUsage: addy <command> <subcommand> [options & parameters]

  CLI tool to interact with addy.io api:

  Run load_key first to add api key:

  addy load_ley <key goes here>

Options:
  --version  Show the version and exit.
  --help     Show this message and exit.

Commands:
  load-key  Load api key.
  api       Invoke details about the provided api key
  alias     Invoke alias commands: --help for details
  bulk      Invoke bulk alias commands: --help for detailsCommandsload-keyaddy load-key addy_io_key 

Key savedapiUsage: addy api [OPTIONS] COMMAND [ARGS]...

  Invoke details about the provided api key

Options:
  --help  Show this message and exit.

Commands:
  account-details  Get all account details associated with api key
  api-details      Check the details of the api keyaliasUsage: addy alias [OPTIONS] COMMAND [ARGS]...

  Invoke alias commands: --help for details

  addy alias <subcommand>

Options:
  --help  Show this message and exit.

Commands:
  activate    Activate alias ID
  deactivate  Deactivate alias ID
  delete      Delete alias ID
  forget      Forget alias ID
  get         Get ID details
  get-all     Get details about all ACTIVE aliases SORTED by CREATED_AT.
              OPTION: --only-ids
  new         Create a new alias. --help for all options
  restore     Restore alias ID
  update      Update alias "descprition" and "from_namebulkUsage: addy bulk [OPTIONS] COMMAND [ARGS]...

  Invoke bulk alias commands: --help for details

  addy bulk <subcommand>

Options:
  --help  Show this message and exit.

Commands:
  activate     Bulk activate list of aliases. Supply a comma-seperated list of
               alias IDs -e.g. ID1,ID2. --help for more info
  deactivate   Bulk deactivate list of aliases. Supply a comma-seperated list
               of alias IDs -e.g. ID1,ID2. --help for more info
  delete       Bulk delete list of aliases. Supply a comma-seperated list of
               alias IDs -e.g. ID1,ID2. --help for more info
  get-aliases  Get detailed info on aliases. Supply a comma-seperated list of
               alias IDs -e.g. ID1,ID2. --help for more info
  restore      Bulk restore list of aliases. Supply a comma-seperated list of
               alias IDs -e.g. ID1,ID2. --help for more infoTestingFrom source run:pytest tests/DevelopmentFeel free to open a pr or file an issue. I'm working on adding new features and plan regular releases!
Package: pyadic
pyAdicThepyadiclibrary is Python 3 package that provides number types for finite fields $\mathbb{F}_p$ (ModP) and $p$-adic numbers $\mathbb{Q}_p$ (PAdic). The goal is mimic the flexible behavior of built-in types, such asint,floatandcomplex. Thus, one can mix-and-match the different number types, as long as the operations are consistent. In particular,ModPandPAdicare compatible withfractions.Fraction.In addition to arithmetic operations, the pyadic library also provides the following functions:rationaliseto perform rationalization ($\mathbb{F}_p\rightarrow \mathbb{Q}$ and $\mathbb{Q}_p \rightarrow \mathbb{Q}$);finite_field_sqrtandpadic_sqrtto compute square roots (which may involveFieldExtension);padic_logto compute the $p$-adic logarithm.InstallationThe package is available on thePython Package Indexpip install pyadicAlternativelty, it can be installed by cloning the repogit clone https://github.com/GDeLaurentis/pyadic.git path/to/repopip install -e path/to/repoRequirementspipwill automatically install the required packages, which arenumpy, sympyAdditionally,pytestis needed for testing.TestingExtensive tests are implemented withpytestpytest --cov pyadic/ --cov-report html tests/ --verboseQuick StartIn[1]:frompyadicimportPAdic,ModPIn[2]:fromfractionsimportFractionasQ# 7/13 as a 12-digit 2147483647-adic numberIn[3]:PAdic(Q(7,13),2147483647,12)Out[3]:1817101548+825955248*2147483647+1156337348*2147483647^2+330382099*2147483647^3+1321528398*2147483647^4+991146298*2147483647^5+1817101547*2147483647^6+825955248*2147483647^7+1156337348*2147483647^8+330382099*2147483647^9+1321528398*2147483647^10+991146298*2147483647^11+O(2147483647^12)# 7/13 in F_2147483647In[4]:ModP(Q(7,13),2147483647)Out[4]:1817101548%2147483647# Mapping back to rational numbersIn[5]:frompyadic.finite_fieldimportrationaliseIn[6]:rationalise(ModP(Q(7,13),2147483647))Out[6]:Fraction(7,13)In[7]:rationalise(PAdic(Q(7,13),2147483647,12))Out[7]:Fraction(7,13)CitationIf you found this library useful, please consider citing it@inproceedings{DeLaurentis:2023qhd,author="De Laurentis, Giuseppe",title="{Lips: $p$-adic and singular phase space}",booktitle="{21th International Workshop on Advanced Computing and Analysis Techniques in Physics Research}: {AI meets Reality}",eprint="2305.14075",archivePrefix="arXiv",primaryClass="hep-th",reportNumber="PSI-PR-23-14",month="5",year="2023"}
Package: pyADiff
pyADiff: A simple, pure python algorithmic differentiation packagepyADiffis a (yet) very basic algorithmic differentiation package, which implements forward and adjoint/reverse mode differentiation. If you are looking for a fully-featured and faster library, have a look atgoogle/jax,autogradordco/c++(or many more),  but if you are interested in a package where you are able to quickly "look under the hood", you may be right here.MotivationMy motivation to start this project arose from curiosity while listening to the lecture"Computational Differentiation"by Prof. Naumann atRWTH Aachen University. So basically I tried to understand the concepts from the lecture by implementing them by myself. In the end I was (positively) surprised with the outcome and decided to bundle it in a python package. Additionaly this gave me the chance to learn about python packaging, distributing, documentation, ...Basic UsageSuppose we want to compute the gradient of the functionf(x₀, x₁) = 2 x₀ x₁².This is a rather trivial task, because by simple calculus, the gradient is:∇f(x₀, x₁) = (2 x₁², 4 x₀ x₁)Nevertheless we use this example illustrate the use ofpyADiff.importpyADiffasad# define the function fdeff(x):return2.*x[0]*x[1]**2.# call the gradient function of pyADiffdf=ad.gradient(f)x=[0.5,2.0]# Call the function f and the gradient function dfy=f(x)dy=df(x)print("f({}) ={}".format(x,y))# prints f([0.5, 2.0]) = 4.0print("f'({}) ={}".format(x,dy))# prints f'([0.5, 2.0]) = [8. 4.]Which corresponds to the evaluation of the analytic gradient.∇f(0.5, 2) = (2*2², 4*0.5*2) = (8, 4)For more sophisticated examples see theDocumentationor have a look at the.ipynb notebooksInstallationInstallation using pipTODOInstallation from sourceThis will clone the repository and install thepyADiffpackage using thesetup.pyscript.>gitclonehttps://github.com/tam724/pyADiff
>pythonpyADiff/setup.pyinstallDocumentationAvailiable onreadthedocs.orgReferencesAlgorithmic Differentiation:Uwe Naumann,Lecture Computational Differentiation, RWTH Aachen
Package: pyadigraph
Pyadigraph turns your networkx into Adigraph latex package.The Latex generated with this package requiresAdigraph (1.7.0+)and thesubfigurespackage.InstallationAfter having installed Adigraph, you can run:pipinstalledpyadigraphExamplefrompyadigraphimportAdigraphimportnetworkxasnxA=Adigraph(vertices_color_fallback="gray!90",edges_color_fallback="gray!90",sub_caption="My adigraph number{i}of{n}",sub_label="adigraph_{i}_{n}",row_size=1,caption="A graph generated with python and latex.",label="pyadigraph_example")A.add_graph(nx.bipartite.random_graph(4,4,1),vertices_color={0:'red!90',1:'red!90',4:'cyan!90',7:'cyan!90'})A.save("test/result.tex",document=True)Which when generated results in:\documentclass{report}\usepackage{adigraph}\usepackage{subcaption}\begin{document}\begin{figure}\begin{subfigure}{1.0\textwidth}\NewAdigraph{myAdigraph}{0,red!90,:-0.4386601404141742\textwidth,0.2091077552922947\textwidth:;
            1,red!90,:-0.15708496776680972\textwidth,0.09630690244229406\textwidth:;
            2,gray!90,:0.43887677279554366\textwidth,-0.2079924280020609\textwidth:;
            3,gray!90,:0.15678823839504888\textwidth,-0.09746320565948384\textwidth:;
            4,cyan!90,:-0.3736460590634439\textwidth,-0.327631363498189\textwidth:;
            5,gray!90,:0.3735687548614322\textwidth,0.3275275669374224\textwidth:;
            6,gray!90,:-0.042735184609099336\textwidth,-0.4998552275122768\textwidth:;
            7,cyan!90,:0.0428925858015027\textwidth,0.5\textwidth:;}{0,4,gray!90,::;
            0,5,gray!90,::;
            0,6,gray!90,::;
            0,7,gray!90,::;
            1,4,gray!90,::;
            1,5,gray!90,::;
            1,6,gray!90,::;
            1,7,gray!90,::;
            2,4,gray!90,::;
            2,5,gray!90,::;
            2,6,gray!90,::;
            2,7,gray!90,::;
            3,4,gray!90,::;
            3,5,gray!90,::;
            3,6,gray!90,::;
            3,7,gray!90,::;}[]\myAdigraph{}\caption{My adigraph number 1 of 1}\label{adigraph_1_1}\end{subfigure}\caption{A graph generated with python and latex.}\label{pyadigraph_example}\end{figure}\end{document}And when you compile this in your document you get:
Package: pyadi-iio
pyadi-iio: Analog Devices python interfaces for hardware with Industrial I/O driverspyadi-iio is a python abstraction module for ADI hardware with IIO drivers to make them easier to use. The libIIO interface although extremely flexible can be cumbersome to use due to the amount of boilerplate code required for even simple examples, especially when interfacing with buffers. This module has custom interfaces classes for specific parts and development systems which can generally make them easier to understand and use. To get up and running with a device can be as simple as a few lines of code:importadi# Create device from specific uri addresssdr=adi.ad9361(uri="ip:192.168.2.1")# Get data from transceiverdata=sdr.rx()Currently supported hardwareSupported parts and boardsDependencieslibiio with python bindingsnumpyInstalling from sourcetcollins@jeeves:~$ git clone https://github.com/analogdevicesinc/pyadi-iio.git
tcollins@jeeves:~$ cd pyadi-iio
tcollins@jeeves:~$ (sudo) pip install .Installing from piptcollins@jeeves:~$ (sudo) pip install pyadi-iioTo get optional dependency for JESD debuggingtcollins@jeeves:~$ (sudo) pip install pyadi-iio[jesd]Building docInstall necessary toolstcollins@jeeves:~$ (sudo) pip install -r requirements_doc.txtBuild actual doc with sphinxtcollins@jeeves:~$ cd doc
tcollins@jeeves:~$ make htmlDevelopingInstall necessary toolstcollins@jeeves:~$ (sudo) pip install -r requirements_dev.txtRunning pre-commit checkstcollins@jeeves:~$ pre-commit run --all-files
Package: pyadjoint
PyadjointMisfit measurement and adjoint source generationPyadjoint is a small misfit measurement package that calculates misfit and adjoint sources on time seriesDocumentationfor Pyadjoint can be found on GitHubCan be used standlone, but is also wrapped inPyatoa(alongsidePyflex)Pyadjoint is part of theadjTomo ecosystemof tools for
adjoint tomography and full waveform inversion
Package: pyadjoint-ad
The algorithmic differentation tool pyadjointThe full documentation is availablehereCircle CI status:ContributingWe love pull requests from everyone.Fork, then clone the repository athttps://github.com/dolfin-adjoint/pyadjointMake sure the tests pass:py.test tests/pyadjointMake your change. Add tests for your change. Make the tests pass:py.test tests/pyadjointPush to your fork andsubmit a pull request.At this point you're waiting on us. We may suggest
some changes or improvements or alternatives.Some things that will increase the chance that your pull request is accepted:Write tests.Add Python docstrings that follow theGoogle Style.Write good commit and pull request message.LicenceThis software is licensed under theGNU LGPL v3.
Package: pyadldap
Python framework to managing Microsoft Active Directory from LDAPDescriptionThe essential purpose of this framework is to work with LDAP objects as objects python.The object attributes in LDAP are processed as attributes of objects in python and manipulation objects (such as enable, disable, change password, etc.) using the methods of the object in python.RequiresPython 2.7python-ldapMore info:https://github.com/Wengex/PyADLdap
Package: py-admetric
py-admetricWhat is py-admetric?Provide calculation methods often used in digital advertising industryWhat does py-admetric provide?CPI (Cost Per Impression)CPM (Cost Per Thousand Impressions (Cost Per Mille))CPC (Cost Per Click)CPA (Cost Per Action (Cost Per Acquisition))CPV (Cost Per View)CTR (Click Through Rate)VTR (View Through Rate)CVR (Conversion Rate)Installation$pipinstallpy-admetricUsage and ExampleExample: CPMfrompy_admetricimportpy_admetriccpm=py_admetric.cpm(50000,1000)
Package: pyadm-toolkit
pyadm - Swiss Army Knife for Engineers and Administratorspyadmis a versatile command-line tool designed as a Swiss Army Knife for engineers and administrators.It provides modular functionality to perform various tasks efficiently.Currently, the only available module isldap, which enables LDAP-related operations.InstallationTo installpyadm, use the following command (soon!):pipinstallpyadm-toolkitUsageThe general command structure for pyadm is as follows:pyadmMODULESUBCOMMAND[OPTIONS]To use the LDAP module, execute the pyadm ldap command followed by the desired subcommand to perform specific LDAP operations.LDAP ModuleThe LDAP module within pyadm allows you to interact with LDAP servers and perform common operations, such as retrieving user information, showing group associations, and displaying group members.ExamplesRetrieve information for a user in the LDAP directory:pyadmldapuserUSERNAMEShow groups associated with a user in the LDAP directory:pyadmldapgroupsUSERNAMEShow members of a group in the LDAP directory:pyadmldapmembersGROUP_CNFor more information on each subcommand, you can use the --help option, as shown in the examples below:pyadmldapuser--help
pyadmldapgroups--help
pyadmldapmembers--helConfigurationThe pyadm tool allows you to customize its behavior through a configuration file. By default, the configuration file is located at~/.config/pyadm/pyadm.conf.To use a custom configuration file, create a file in the following format:[LDAP]server=ldaps://dc.example.orgbase_dn=dc=example,dc=orgbind_username=administrator@example.orgbind_password=s3cr3t-p455w0rd!Specify the desired values for the LDAP server, base DN, bind username, and bind password in the configuration file.ContributingContributions are welcome! If you encounter any issues, have suggestions, or would like to add new features, please submit an issue or a pull request.LicenseThis project is licensed under theMIT License.Feel free to copy and use this markdown source as needed for yourREADME.mdfile.