Saravanan666/pypi-org huggingface dataset:
Package: pynab-client
pynab-clientPython API module for interfacing with You Need a Budget's (YNAB) v1 APIOnly runs on python >3.6 .....#sorrynotsorryinstallationEasy waypipinstallpynab-clientLess easy waygitclonehttps://github.com/irunasroot/pynab-client.gitcdpynab-client
pythonsetup.pyinstallUsagefrompynabapiimportYnabClientclient=YnabClient("my-api-token")my_budgets=client.get_budget()APIYnabClient.get_budget()The mother load. By default you'll get a summary list of all Budgets you have on your account. If you're looking
for a single budget you can specify the budget_id or by default it will pull data for the last opened budget.

:param summary: Set summary to False if you want an entire payload of a single budget
    :default: True
:param budget_id: The budget id of the budget you want to view data from.
    :default: last-used which is your last opened budget.
:return: Returns Budgets object as a list of Budget objects or a single Budget objectYnabClient.get_account():param account_id: Provide account_id to retrieve a single known account.  
    :default: None
:param budget_id: The budget id of the budget you want to view data from.  
    :default: last-used which is your last opened budget.  
:return: Returns Accounts object as a list of Account objects or a single Account objectYnabClient.get_budgetmonth()Get budget month or months. If specifying the month then a list of categories are also provided.

:param month: Provide month to retrieve a single known month.
    :default: None
:param budget_id: The budget id of the budget you want to view data from.
    :default: last-used which is your last opened budget.
:return: Returns BudgetMonths object as a list of BudgetMonth objects or a single BudgetMonth objectYnabClient.get_category()Get budget category or categories. If specifying the month then you also need to specify a category_id

:param category_id: The category ID of the specific category you want to retrieve
    :default: None
:param month: The month of the category you want to retrieve format: yyyy-MM-dd
    :default: None
:param budget_id: The budget id of the budget you want to view data from.
    :default: last-used which is your last opened budget.
:return: Returns BudgetCategories object as a list of BudgetCategory objects or a single BudgetCategory objectYnabClient.get_payee()Get budget payee or payees.

:param payee_id: Provide payee_id to retrieve a single known payee.
:param budget_id: The budget id of the budget you want to view data from.
    :default: last-used which is your last opened budget.
:return: Returns Payees object as a list of Payee objects or a single Payee objectYnabClient.get_transaction()Get budget transaction or transactions.

:param transaction_id: Provide transaction_id to retrieve a single known transaction.
    :default: None
:param budget_id: The budget id of the budget you want to view data from.
    :default: last-used which is your last opened budget.
:return: Returns Transactions object as a list of Transaction objects or a single Transaction object
Package: pyNacha
NACHA CCD+ ACH file generator module for python.This has been tested with “CCD” batches with addenda records.Forked from carta-ach by Carta, Inc. and modified to include special charater support for Company, Bank and Supplier's Name.Example:from pyNacha.builder import AchFile

settings = {
    'immediate_dest': '123456789', # Your bank's routing number
    'immediate_org': '1098765432', # Bank assigned routing number
    'immediate_dest_name': "BANKNAME",
    'immediate_org_name': 'COMPANYNAMR',
    'company_id': '1098765432',
    'company_name': 'COMPANYNAME',
    'trace_num': '00000000'
}

ach_file = AchFile('A', settings) #file Id mod

entries = [
    {
        'type'           : '22', # type of
        'routing_number' : '12345678',
        'account_number' : '11232132',
        'amount'         : '10.00',
        'id_number': '901398852',
        'name'           : 'Alice&Wanderdust',
        'addenda' : [
            {
                'payment_related_info': 'Here is some additional information',
            }
        ],
    },
    {
        'type'           : '22',
        'routing_number' : '12345678',
        'account_number' : '234234234',
        'amount'         : '150.00',
        'id_number': '901398853',
        'name'           : 'Billy Holiday',
        'addenda' : [
            {
                'payment_related_info': 'Here is some additional information2',
            },
        ],
    },
    {
        'type'           : '22',
        'routing_number' : '12323231',
        'account_number' : '123123123',
        'amount'         : '12.13',
        'id_number': '901398853',
        'name'           : 'Rachel Welch',
    },
]

ach_file.add_batch('CCD', entries, credits=True, debits=True)

print(ach_file.render_to_string())===============================================================================================This returns the following NACHA file:101 123456780 1234567801409020123A094101YOUR BANK              YOUR COMPANY
5200YOUR COMPANY                        1234567890CCDPAYMENT         140903   1123456780000001
62212345678011232132         0000001000               ALICE WANDERDUST        1123456780000001
705HERE IS SOME ADDITIONAL INFORMATION                                             00000000001
627123456780234234234        0000015000               BILLY HOLIDAY           0123456780000002
622123232318123123123        0000001213               RACHEL WELCH            0123456780000003
820000000400370145870000000150000000000022131234567890                         123456780000001
9000001000001000000040037014587000000015000000000002213
9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
Package: py-nacha
nachaNACHAis a fixed sized
record format used to represent financial transactions composed like this:FileHeader
    CompanyBatchHeader
        EntryDetail
            EntryDetailAddendum
            ...
        ...
    CompanyBatchControl
    ...
FileControlwhich we express usingbryl. Writing is
done like this:withopen('sample.nacha','w')asfo:writer=nacha.Writer(fo)withwriter.begin_file(...):withwriter.begin_company_batch(...):writer.entry(...):......Reading is done by iterating records like this:withopen('sample.nacha','r')asfo:reader=Reader(fo,include_terminal=True)forrecord,terminalinreader:...Or structured like this:withopen('sample.nacha','r')asfo:reader=Reader(fo)reader.file_header()forcompany_batch_headerinreader.company_batches():forentry_detail,entry_addendainreader.entries():...reader.company_batch_control()reader.file_control()use$pipinstallpy-nachadev$gitclonegit@github.com:DisruptiveLabs/nacha.git$cdnacha$mkvirtualenvnacha(nacha)$pipinstall-e.[tests](nacha)$py.testtests.py--cov=nacha--cov-reportterm-missingreleaseNow that all tests are passing:Updatenacha.__version__to new{version}.Commit thatgit commit-am"Release v{version}"Tag itgit tag-av{version}-vv{version}Push itgit push origin--tagsandtraviswill take it from there.
Package: pyna-chaos
pynaPython package dedicated for research onDYNAmic system.pipinstallpyna-chaosimportpynaPlan to support:One dimensional Map / FlowTwo dimensional Map / FlowEigenvalue/vectorAsymptotic Behaviour AnalysisTopology Entropy (How bending are the curves after long-term evolution?)Lyapunov Exponent SpectrumBifurcation diagram / Bifurcation curveStable/Unstable manifold drawingThree dimensional Flow Visualization
Package: pynacl-cellar
Salt Cellar Encryption ToolSalt Cellar is a Python program that protects your files and folders using hard encryption. Thepynacl-cellarpackage provides the command line toolcellarto encrypt and decrypt your files/folders using a secret key and protect them from prying eyes. Files are quickly encrypted/decrypted fully asynchronously using asyncio/aiofiles.EncryptionThe hard encryption is accomplished using thePyNaClpackage and thelibsodiumlibrary. The underlying encryption algorithm isSalsa20which is fast and increases the file size very minimally. By default,cellarencrypts the files in place, overwriting the original files with the encrypted version.:warning:DO NOT FORGET YOUR KEY!This program will encrypt your files and make them unusable until you decrypt them. If you lose/forget the secret key then the files will not be recoverable. Use at your own riskKeysA secret key for use with the tool should be 32 bytes long. It can be stored as a file, environment variable or entered in the command line. If the key is too short it will be truncated and if it's too long it will be padded with null bytes.InstallInstalllibsodiumRecommend usingpipxfor installing the CLI toolpipx install pynacl-cellarThen run the command with pipxpipx run cellar ...UsageThe CLI command iscellarand you can callencryptordecrypton a set of paths. Paths can be files, folders or-for stdinUsage: cellar [OPTIONS] COMMAND [ARGS]...

Options:
  --version                Show the version and exit.
  -v, --verbosity          Output level WARN/INFO/DEBUG
  -l, --log-file FILENAME  File path to write logs to
  -k, --key-file FILENAME  File path to use for secret key or CELLAR_KEYFILE env var
  -p, --key-phrase TEXT    Text to use as secret key. Use "-" to read from stdin. Do NOT type your key via command line! It will show in your shell history
  -P, --key-prompt         Prompt for the secret key (default)
  --help                   Show this message and exit.

Commands:
  decrypt  Decrypts given paths.
  encrypt  Encrypts given paths.Env VarsCELLAR_KEYFILEA file that contains the content of your private key (32 bytes)CELLAR_KEYPHRASEA string that contains the content of your private key (32 bytes)CELLAR_LOGFILEA filename to use for loggingExample# Encrypt a given directory$cellar-vvencrypttest-dir/
Secretkey:WARNINGcellar__init__:Keytooshort,paddingtoto32characters
INFOcellarencrypt_file:Encryptedfiletest-dir/mypic.jpg
INFOcellarencrypt_dir:Encrypteddirectorytest-dir# Encrypt stdin$echofoobarbaz|cellarencrypt-
9T�䳵�B���S��*�����S��# Decrypt it using pipes$echofoobarbaz|cellarencrypt-|cellardecrypt-
foobarbaz
Package: pynaco
# pynaco [![Build Status](https://travis-ci.org/unt-libraries/pynaco.svg?branch=master)](https://travis-ci.org/unt-libraries/pynaco) [![PyPI Version](https://img.shields.io/pypi/v/pynaco.svg)](https://pypi.python.org/pypi/pynaco)
Python Implementation of NACO Normalization Rules# Installation`sh $ pip install pynaco `# Background
This repository is a fork of the sample code found on the OCLC Research Website.http://www.oclc.org/research/themes/data-science/naco.htmlThe goal of this fork is to bring this package into pep8 compliance, add a suite of
tests and to make it easier to deploy in a variety of settings.We thank OCLC research for making this available under an Open-Source License.
Package: pynacos-sdk
pynacos-sdkInstallpip install pynacos-sdkTutorialfromnacosimportNacosfromnacos.errorsimportRequestError,ParamErrorfromnacos.paramsimportServiceRegisterParam,ServiceListParamNACOS_HOST="127.0.0.1"NACOS_PORT=8848NAMESPACE_ID="e26e7439-e161-4709-8778-ab5ecef5fec5"nacos=Nacos(NACOS_HOST,NACOS_PORT,NAMESPACE_ID)try:param=ServiceRegisterParam("hello")status=nacos.service_register(param)print("register status = ",status)exceptParamErrorase:print("param error")print(e)exceptRequestErrorase:print("nacos error")print(e)try:param=ServiceListParam()services=nacos.service_list(param)print(services.json())exceptParamErrorase:print("param error")print(e)exceptRequestErrorase:print("nacos error")print(e)
Package: pynad
An application to download, sync, organize and prepare the microdata and metadata of the Brazilian National Household Survey,Pesquisa Nacional por Amostra de Domicílios Contínua-Pnadc- fielded by the Instituto Brasileiro de Geografia e Estatística,IBGE.ThePNADCis a rotating panel survey. The residential dwellings sampled for a panel are visited five times, quarterly. Every quarter a new panel starts, thus there are five active panels in visits 1 to 5. However, IBGE only disseminates Pnadc microdata as cross-section datasets, aggregating records from distinct panels. Thetrimestraland theanual-trimestredatasets are aggregates of the distinct visits of the five panels surveyed in a quarter; theanual-visitadatasets are annual aggregates of first or fifth visit interviews, comprised by four panels visited for the first or fifth time in a year.What pynad does?IBGE periodically releases new PNADC datasets and documents. Eventually, previously released datasets and documents are patched. Currently, there are more than a hundred files to download and monitor for updates.Pynad ascertains one always have the latest versions of data and documents, and helps to keep track of the versions used in an application. It clones theMicrodadosfolder of the Pnadc distributions at IBGE’sFTP servercopying all its files to a local folder, syncing it at user demand.PNADC datasets are disseminated as text files with fixed width records. The position of each variable in the record must be declared to load them. The full metadata (names and columns of variables, categories etc.) are in binary xls Excel files.Pynad converts the original microdata to standardcsvtext files and/orparquetbinary files; conveniently organizes copies of the originaldicionários de variáveis; and generates machine and human readablejsontext files containing all metadata. The new files are stored in the archive containing the local copy of the PNADC, in distinct folders.When the local copy is synced, pynad updates the metadata andcsvand/orparquetfiles on a need basis.PNADC datasets are organized for use as a quarterly or annual cross-section survey, mixing records from 4 or 5 distinct panels. One panel has variables scattered in different datasets. Though dwellings are identified, households and individuals are not. Population weights are not available for the panelsPynad creates another archive for panel files. It separates the panels retrieving their records from the cross-sectional datasets, then pynad identifies the households and individuals in each dwelling and generates and generates aparquetand/or acsvmicrodata file for each panel.
Original variables have up to five instances in the identified individual records. E.g. for literacy, v3001, the identified individual record has v3001_1, v3001_2 v3001_3, v3001_4, v3001_5.Pynad updates the panel files on a need basis.InstallWindowsusers should add Python to the PATH environment variable.Usepipto install pynad.Typepynadin a terminal to run it.RequirementsTwo additional packages will be installed:pyarrow,xlrd.At least 200GB free storage if generating uncompressedcsvfiles.
Package: pynada
PyNADAA Python client for NADA APISetupYou can installl PyNADA using pip:pipinstall-UpynadaExamplesJupyter Notebooks under examples folder show some use cases utilizing PyNADA. The examples are grouped into three categories:Search & Browse: codes for finding specific datasets and resourcesCreate & Import: codes for adding datasets to the catalogManage & Update: codes for managing existing datasets and resources
Package: pynadc
pynadcThe pynadc package contains the following tools and Python modules:Access to Sciamachy data-productsFast read access to Sciamachy (ENVISAT) level 0
The software attempt to read all data and offers convenient access to the
parameter through structured numpy arrays.
The scriptscia_lv0.pyoffers a guideline of how to use the modulepynadc.scia.lv0. Products compressed by gzip can be read directly.Fast read access to Sciamachy (ENVISAT) level 1b
The software attempt to read all data and offers convenient access to the
parameter through structured numpy arrays.
Both Science and calibration datasets can be read into memory, however,
currently calibration of the science data is not included.
The scriptscia_lv1.pyoffers a guideline of how to use the modulepynadc.scia.lv1.  Products compressed by gzip can be read directly.Build a database with Sciamachy instrument settings
The scriptcollect_scia_states.pycan be used to build a database with all
instrument configurations used during the mission of Sciamachy. This requires
that the complete Sciamachy level 1b archive is available.
Definitions of OCR states are not included in the level 1b products, and are
therefore hard-coded in the software. These could be obtained from level 0
products, but this is not yet implemented.The Sciamachy level 0 and level 1 (up to versions 8) are in a special ENVISAT
format which require dedicated reading S/W tools. The ENVISAT format is a
simple byte stream with a header containing byte offsets that allows the
extraction of specific datasets. While this type of data format is very space
efficient (all data bytes are just written one after the other with a small
ASCII header), it is not future proof (dedicated S/W is needed) nor self
descriptive. The latest level 1 products (from version 9 and up) are provided
in netCDF4 format. This format is self-descriptive and can be read by widely
available standard reading tools that are provided in all major programming
languages.Access to GOSAT and Sciamachy (local) archivesDatabases of files in your archives, can be very handy when you want to query on
presence, completeness, date of archiving, double entries, etc. Specially, when
you are collecting data during a satellite mission. The package pynadc contains
software to create SQLite databases of archives with GOSAT FTS level 1, GOSAT
CAI level 2 and Sciamachy level 0, 1b and 2 (PDS/ESA format). And tools to query
these databases.InstallationInstallation instructions are provided in the INSTALL file.We installed the software succesfully on Linux and MacOS.WebsitesSource code:http://github.com/rmvanhees/pynadcSRON Netherlands Institute for Space Research:https://www.sron.nl/Sciamachy:https://earth.esa.int/web/guest/missions/esa-operational-eo-missions/envisat/instruments/sciamachyGOSAT:http://global.jaxa.jp/projects/sat/gosatDisclaimerThe software is developed for SRON internal usage, but generously shared without
any warranty.Reporing bugsIssues and bugs should be reported to <r.m.van.hees[at]sron.nl>
Package: pynads
What is this?The packackepynadsbindsnads, a C++ implementation that computes the number of almosts-d-simplices in a digraph, to python.almost-d-simplicesIn a nutshell:Assume you have directed unweighted graph G=(V,E). Then a d-clique are d vertices, where each vertex is directly
connected (in one direction or another) to all others.
A d-simplex is then a (d+1)-clique without any loops.An almost-d-simplex is then a collection of vertices and edges which miss exactly one edge in order to form a d-simplex.It is formally described as a triplet (s,s',e), where s,s' are two different (d-1)-simplices which share a common (d-2)-simplex,
together with an edge e that indicates the missing edge necessary to form a d-simplex.An example:
Three vertices V={0,1,2} have the edges E={(0,1),(0,2)}. Then this is not enough to form a 2-simplex: Either an edge
e=(1,2) or e=(2,1) is missing. Thus, with s=[0,1] and s'=[0,2] we have the two almost-2-simplices (s,s',e) and
(s,s',e').Furthermore: Any d-simplex gives rise to (d^2+d)/2 almost-d-simplices. That is exactly the number of edges in a
d-simplex.Some people (e.g. me) find the number of almost-d-simplices in a big graph interesting.PerformanceThis package allows one to calculate this numbers on sparse graphs in a highly efficient manner, thanks to the substantially optimised underlying C++
implementation.As an example: The connectome of the "The Neocortical Microcircuit Collaboration Portal"https://bbp.epfl.ch/nmc-portal/welcomeconsists of ~30k vertices and 8M edges, connected in a nonrandom manner.pynadscomputes the number of almost-di-simplices for all dimensions in less than three minutes on a desktop CPU.This is notably faster than my previous native-python implementation, which would have computed for a month at least.TODO: Write paper/doku in LaTex.Installationpip install pynadsshould be enough.Compiling C++ code with-march=nativefor higher performance:Advanced users my generate their ownnads_bind.$PYTHON_VERSION.sowhich is probably faster on their own CPU, compared
to the non-optimised module automatically compiled during installation. On my setup this results in ~15% faster code.g++ -march=native -O3 -Wall -Werror --shared -std=c++14 -fPIC `python3 -m pybind11 --includes` src/nads_bindings.cpp -o nads_bind`python3-config --extension-suffix`and push the resultingnads_bind.$PYTHON_VERSION.sotoINSTALL_DIR/site-packages/pynads/UsageWithgbeing a (directed) graph without self-loops, run:from pynads import nads
res = nads(g)This results in a list of Integersres: Each entryres[i]corresponds to the number of almost-(i+2)-simplices found
in the graphg.ToDo:-[ ] Automate build process for architecture optimized library as described above.-[ ] Write a paper about the algorithm and link it in the documentation-[ ] Write a few tests or something
Package: pynaf
pynafPynaf providesa simple API for creating or reading NAF documents.The NAF (Natural language Annotation Format) isan XML markup language that contains several layers of linguistic annotation. It is used inNatural Language Processing toolslike [IXA Pipes] (http://ixa2.si.ehu.es/ixa-pipes/) orCorefgraph.More informationabout NAF in the  followinglink.Install from Pip(Recommended)Install pinaf directly from Pypi repositoriesPip install pynafInstall from repositoryInstall pynaf using this command (no need to clone the repository):pip install --upgrade --user git+https://github.com/josubg/pynaf.git
Package: pynagios
PyNagios is a simple Python library meant to make writingNagiosplugins much easier. Nagios
plugins havequite a few guidelinesto adhere to, and PyNagios provides helpers to make this
easy.InstallTo install, simply usepiporeasy_install:pip install pynagiosDocumentationDocumentation for the latest version can always be found athttp://kiip.github.com/pynagios/latest.FeaturesThe core features supported by PyNagios:Parsing command line arguments such that the standard expected
arguments (such as-H,-w,-c) are accepted.Returning proper POSIX exit code based on status.Parsing Nagios range formats (such as “@10:20”, “~:50”, “10”, etc.)Outputting status and message.Outputting performance data.ExampleWhat all these features result in is a concise, simple, and
guidelines-compliant Python-based Nagios plugin:from pynagios import Plugin

class UserCheck(Plugin):
    """
    Nagios plugin to check how many users are logged into this
    machine.
    """

    def check(self):
        # Get the number of logged in users, for now we hardcode
        users = 27

        # Build a response and exit. This `response_for_value` automatically
        # creates a response with the proper status given the value and the
        # warning/critical ranges passed in via the command line.
        response = self.response_for_value(users, "%d users" % users)
        response.set_perf_data("users", users)
        response.set_perf_data("another metric", 27, "MB")
        return response

if __name__ == 'main':
    # Build the plugin instance and run it. This will also parse
    # command line arguments by default.
    UserCheck().check().exit()While the above example subclassesPlugin, you’re of course welcome
to simply callPlugin`s methods directly and build a ``Response`yourself.