Saravanan666/pypi-org huggingface dataset:
Package: pydaoffice
# pydaoffice## Introduction### What is it pydao*pydaoffice* is a python interface for [DaOffice.ru](http://daoffice.ru/) API.### What is DaOffice.ru*DaOffice.ru* is a corporate social network (like yammer).### LicenseThis code is open sourced under MIT license, GNU GPL 2 or later and GNU LGPL 2 or later. Please see the *license.txt* file for details.### Authors* Alexey Grechishkin aka Alex Snet( [mail](mailto:me@alexsnet.ru), [blog](http://alexsnet.ru) )## Installation### Automatically with PIPpip install git+git@bitbucket.org:AlexSnet/pydao.git### Manualy* Download source archive from [downloads page](https://bitbucket.org/AlexSnet/pydao/downloads).* Extract archive (Example:  *tar -xzf master.tar.gz*)* Chande dir to *pydaoffice* source root* Execute *python setup.py install*## QuickstartFor ordinary use:from pydaoffice import DaOfficeoffice = DaOffice( PARAMETRS )resp = office.call('method.name')For use with sugar:from pydaoffice import DaOfficeSugaroffice = DaOfficeSugar( PARAMETRS )resp = office.method.name()## Advanced Usage
Package: pydap
pydappydapis an implementation of the
Opendap/DODS protocol, written from scratch in pure python.  You can
use pydap to access scientific data on the internet without having to
download it; instead, you work with special array and iterable objects
that download data on-the-fly as necessary, saving bandwidth and
time. The module also comes with a robust-but-lightweight Opendap
server, implemented as a WSGI application.QuickstartYou can install the latest version usingpip. Afterinstalling
pipyou can
install pydap with this command:$pipinstallpydapThis will install pydap together with all the required
dependencies. You can now open any remotely served dataset, and pydap
will download the accessed data on-the-fly as needed:>>>frompydap.clientimportopen_url>>>dataset=open_url('http://test.opendap.org/dap/data/nc/coads_climatology.nc')>>>var=dataset['SST']>>>var.shape(12,90,180)>>>var.dtypedtype('>f4')>>>data=var[0,10:14,10:14]# this will download data from the server>>>data<GridTypewitharray'SST'andmaps'TIME','COADSY','COADSX'>>>>print(data.data)[array([[[-1.26285708e+00,-9.99999979e+33,-9.99999979e+33,-9.99999979e+33],[-7.69166648e-01,-7.79999971e-01,-6.75454497e-01,-5.95714271e-01],[1.28333330e-01,-5.00000156e-02,-6.36363626e-02,-1.41666666e-01],[6.38000011e-01,8.95384610e-01,7.21666634e-01,8.10000002e-01]]],dtype=float32),array([366.]),array([-69.,-67.,-65.,-63.]),array([41.,43.,45.,47.])]For more information, please check the documentation onusing pydap
as a client. pydap also
comes with a simple server, implemented as aWSGIapplication. To use it, you first need to install the server and
optionally a data handler:$pipinstallpydap[server,handlers.netcdf]This will install support fornetCDFfiles; morehandlersfor
different formats are available, if necessary. Now create a directory
for your server data.To run the server just issue the command:$pydap--data./myserver/data/--port8001This will start a standalone server running onhttp://localhost:8001/,
serving netCDF files from./myserver/data/, similar to the test
server athttp://test.pydap.org/. Since the server uses theWSGIstandard, it can easily be run behind
Apache. Theserver
documentationhas
more information on how to better deploy pydap.DocumentationFor more information, seethe pydap
documentation.HelpIf you need any help with pydap, please feel free to send an email to
themailing list
Package: pyDAPAccess
pyDAPAccess is an Open Source python 2.7 library for communicating with
ARM Cortex-M microcontrollers throughCMSIS-DAPover USB. Currently Linux, OSX, and Windows are supported.For more information on CMSIS-DAP you can find the official standard:https://silver.arm.com/browse/CMSISDAPInstallationNo user installation of this library is necessary.  Tools which rely on pyDAPAccess
must specify it as a dependency.  This will cause pip to install it automatically
as soon as something depends on it.One case where pyDAPAccess will need to be installed manually is when
doing development.  Installation can be done with pip using the following
command:$pipinstallpydaplinkNote that you may run into permissions issues running this command.You have a few options here:Run withsudo-Hto install pyDAPAccess and dependencies globallySpecify the--useroption to install local to your userRun the command in avirtualenvlocal to a specific project working set.Development SetuppyDAPAccess developers are recommended to setup a working environment usingvirtualenv. After cloning
the code, you can setup a virtualenv and install the pyDAPAccess
dependencies for the current platform by doing the following:$virtualenvenv$sourceenv/bin/activate$pipinstall-rdev-requirements.txtOn Windows, the virtualenv would be activated by executingenv\Scripts\activate.ExamplesFor examples you can look into pyDAPAccess’s usage in pyOCD:https://github.com/mbedmicro/pyOCD
Package: pydapper
pydapperA pure python library inspired by the NuGet librarydapper.pydapperis built on top of thedbapi 2.0 specto provide more convenient methods for working with databases in python.HelpSee thedocumentationfor more details.InstallationIt is recommended to only install the database apis you need for your use case.  Example below is for psycopg2!pippip install pydapper[psycopg2]poetrypoetry add pydapper -E psycopg2Never write this again...frompsycopg2importconnect@dataclassclassTask:id:intdescription:strdue_date:datetime.datewithconnect("postgresql://pydapper:pydapper@localhost/pydapper")asconn:withconn.cursor()ascursor:cursor.execute("select id, description, due_date from task")headers=[i[0]foriincursor.description]data=cursor.fetchall()list_data=[Task(**dict(zip(headers,row)))forrowindata]Instead, write...fromdataclassesimportdataclassimportdatetimeimportpydapper@dataclassclassTask:id:intdescription:strdue_date:datetime.datewithpydapper.connect("postgresql+psycopg2://pydapper:pydapper@locahost/pydapper")ascommands:tasks=commands.query("select id, description, due_date from task;",model=Task)(This script is complete, it should run "as is")Buy me a coffeeIf you find this project useful, consider buying me a coffee!
Package: pydapt
PyDaptPyDapt coverts a dictionary into an object.
It is similar to theOpenStructof ruby.InstallationPython Version Required >= 3pip install pydaptUsageConverting a dictionary to Objectfrompydapt.modelsimportPyFlexdictionary={"test":1,"test1":{"test2":2}}pyflex=PyFlex(dictionary)print(pyflex.test)# 1print(pyflex.test1.test2)# 2Converting a dictionary to Object with kwargsfrompydapt.modelsimportPyFlexdictionary={"test":1,"test1":{"test2":2}}pyflex=PyFlex(dictionary,test3=3,test4=4)print(pyflex.test)# 1print(pyflex.test1.test2)# 2print(pyflex.test3)# 3print(pyflex.test4)# 4Deleting an attributefrompydapt.modelsimportPyFlexdictionary={"test":1,"test1":{"test2":2}}pyflex=PyFlex(dictionary)print(pyflex.test)# 1print(pyflex.test1.test2)# 2pyflex.drop('test3')# Nonepyflex.drop('test')# 1print(pyflex.test)# AttributeError: 'PyFlex' object has no attribute 'test'
Package: pydaqflex
IntroductionThe PyDAQFlex module is a pure Python implementation of Measurement Computing’s
DAQFlex command framework (http://www.mccdaq.com/daq-software/DAQFlex.aspx)
for USB data acquisition devices.
It uses PyUSB 1.0 as a backend for USB access and is therefore usable
on all operating systems supported by PyUSB.
PyUSB is currently tested on Windows and Linux,
but should also work on OS X and OpenBSD using libusbx.Disclaimer: PyDAQFlex is NOT in any way affiliated with Measurement Computing or the official
DAQFlex framework.StatusPyDAQFlex does not (yet) provide all the features of DAQFlex and was
only tested on the following devices:USB-204USB-1608GX-2AOInstallationThe easiest way of installation is through setuptools.
On GNU/Linux based systems:$ sudo easy_install pydaqflexor on Windows:easy_install pydaqflexIt will automatically install the required dependencies like PyUSB
and the latest release version of PyDAQFlex from PyPi.Alternatively, PyDAQFlex can be installed manually using the standard
distutils procedure:python setup.py installFor installation of PyUSB 1.0 seehttps://github.com/walac/pyusbThe latest version of libusb (recommended for PyUSB) can be found athttp://libusbx.org/
Package: pydaqtools
pydaqtoolspydaqtools provides an interface for pc-compatible data-acquisition hardware for Python. Control analog/digital output or acquire analog/digital input for immediate analysis with Python for scientific or engineering applications.Dependenciesnumpy
scipy(optional)
matplotlib(optional)Additional hardware drivers required:
nidaqmx(National Instruments)
nidaqmxbase(National Instruments)
pyAudioSupportURL:http://www.pydaqtools.org/Mailing List:pydaqtools-users@lists.sourceforge.net
Package: pydaraja
pydarajaDescriptionThis Python wrapper allows developers to seamlessly interact with the MPESA's Daraja API and manage payment requests within their Python applications.It streamlines and abstracts the complexity of integrating with the MPESA's Daraja API, providing developers with a convenient and efficient means of handling payment transactionsDaraja API services offered by pydaraja are:Lipa na M-PESA online API also known as M-PESA express (STK Push/NI push)STK push query API -> Used to check the status of Lipa na Mpesa online paymentTransaction status API -> Check the status of a transactionAccount balance API -> The Account Balance API is used to request the account balance of a short code. This can be used for both B2C, buy goods and pay bill accounts.More services will come soon.Installationpip install -U pydarajaUsageLipa na Mpesa Online API (STK push) and STK push query API.from pydaraja import config, payment


# setup configurations
config.CONSUMER_KEY = "YOUR_CONSUMER_KEY"
config.CONSUMER_SECRET = "YOUR_CONSUMER_SECRET"
config.BUSINESS_SHORTCODE = "YOUR_BUSINESS_SHORTCODE"
config.PASSKEY = "YOUR_PASSKEY"
config.CALLBACK_URL = "YOUR_CALLBACK_URL"

# optional
config.ACCOUNT_REFERENCE = "YOUR_ACCOUNT_REFERENCE" # default is "Pydaraja"
config.TRANSACTION_DESC = "YOUR_TRANSACTION_DESCRIPTION" # default is "Python wrapper for mpesa api"


response = payment.trigger_stk_push(phone_number="+254700000000", amount=1)
print(response.json())

# use checkout_request_id from the above stk push as parameter for the function below
stk_query = payment.query_stk_push(your_checkout_request_id)
print(stk_query.json())Transaction status API and Account Balance APIfrom pydaraja import config, payment


# setup configurations
config.CONSUMER_KEY = "YOUR_CONSUMER_KEY"
config.CONSUMER_SECRET = "YOUR_CONSUMER_SECRET"
config.SECURITY_CREDENTIAL = "YOUR SECURITY_CREDENTIAL"
config.PARTY_A = "YOUR_BUSINESS_SHORTCODE"
config.IDENTIFIER_TYPE = "YOUR_IDENTIFIER_TYPE"
config.RESULT_URL = "YOUR_RESULT_URL"
config.QUEUE_TIMEOUT_URL = "YOUR_QUEUE_TIMEOUT_URL"

# optional
config.INITIATOR = "INITIATOR" # default is "testapiuser"
config.REMARKS = "YOUR_REMARKS" # default is "OK"
config.OCCASSION = "YOUR_OCCASSION" # default is "OK"

# transaction status
response = payment.transaction_status(<your_transaction_id>)
print(response.json())

# account balance
response = payment.account_balance()
print(response.json())ContributingTo contribute to this project, we kindly request you to review theCONTRIBUTING.mdfile for detailed guidelines.LicenseThis python package is available as open source under the terms of theMIT License
Package: pydarg
pydargPydarg is a python simple utility package providing a way to handle
more deeply dictionary parameters of implemented functionREQUIREMENTRequire python 3.6+INSTALLATIONRun this command line to fetch the package on Pypi$pipinstallpydargUSAGEThis package provide a method "dct_arg" used as a decoratorBasic Usagewithout any parameter, dct_arg unpacks the dictionary
argument of function signature@dct_argdefexample(foo,bar):print(foo,bar)param={'foo':'1,'bar':'2','other':3}example(param)the main advantage of using dct_arg instead of **param
is that it avoid binding extra argument, making it really useful for
handling configuration dictionary having multiple of parameter.those functions call would also be validexample(foo='foo',bar='bar')example({'foo':'foo_1'},bar='bar)example({},'foo','bar')It is also possible to override dct_arg's name by using keyword argument.
making this line printing "foo_2" and "bar_2"example({'foo':'foo_1','bar:'bar_1},'foo_2,bar='bar_2)parametersdct_arg(_fct=None,*,is_positional=True,is_keyword=True,name='dct_arg',path="",fetch_args=None):Where :arg_type:define what is the type of the dct_argArgType.POSITIONALArgType.KEY_WORDArgType.BOTH,namerepresent the keyword name of the dct_argpathif the desired dct_arg is nested you you can specify the path
with "/"fetch_argsdictionary composed of key representing keyword parameter, and
the path with "/" to fetch them in the dct_argExamplesfetch the nested dictionary argument named config@dct_arg(name='config,path='child/subchild')defexample(e0,e1):print(e1,e0)example(config={'child':{'subchild':{'e1':1,'e0':0}}})example({'child':{'subchild':{'e1':1}}},e0=0)since by default a dct_arg is a positional keyword
both function call worksfetch the dct_arg itself as an argument@dct_arg(fetch_args={'config':""})defexample(config,e0):passexample(configuration={'e0':0})
Package: pydark
Python Package: pydarkDescription:pydark is a Python library with useful features.LinksGitHub:https://github.com/jmiante/pydarkPyPI (last version):https://pypi.org/project/pydarkInstallation:pip install pydarkPT-BRDescrição:pydark é uma biblioteca Python com funcionalidades úteis, sendo:ChartsApexChartsJSDataDiferença de DatasBusca de Dias ÚteisÚltimo dia/Data do MêsCálculosNormalização de MédiaTextoNúmero para Texto no Formato de MoedaInstalação:pip install pydarkChart:Pythonfrom pydark.chart.apexcharts import ChartDoação:Ajude o Projeto a continuar, qualquer doação é bem vindaCHAVE PIX:d51024a6-4320-4cb6-9241-b0a4d165dfd2PIX Copia e Cola:LinkQRCODE PIX:Nome:Jonathas Henrique Miante -Banco:PicPay
Package: pydarknetserver
pyDarknetServerPython Darknet ServerFree software: MIT licenseDocumentation:https://pydarknetserver.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-06-28)First release on PyPI.
Package: pydarm
pyDARMpyDARM is a python implementation of the LIGO DARM servo loop
model. It is used to calibrate the detector digital output into units
of differential arm length variations or spacetime strain.If you need assistance, please review INSTALL.md and CONTRIBUTING.md
for detailed installation instructions and contribution guidelines,
respectively.InstallationFor best results, please install fromconda-forge:condainstall-cconda-forgepydarmOn Unix systems, you can also install directly from PyPI:pipinstallpydarmBasic usageSee theweb-based documentationand/orexamplesdirectory
for examples of library usage. You can use pyDARM either frompython,ipython, or a
jupyter notebook, depending on your preferences.Command line interfacepyDARM will eventually include a command line interface to help guide through the
calibration process.  See the command help for more info:$python3-mpydarm--help
Package: pydarn
Python data visualization library for the Super Dual Auroral Radar Network (SuperDARN).ChangelogVersion 4.0 - Major Release!This major release includes:NEWIQ level data plottingNEWLatitude and longitude y-axis in RTPNEWBall and stick plotsNEWMap file variable time series plottingNEWTerminator plottingCoastlines available in magnetic coordinate spatial plots without CartopyMore flexibility in fan plots - single beams/ range gate range optionsTDiff correction for elevation data availableBoxcar filtering available for data before plottingCorrections to geolocation algorithmsStandardized plot return values across all plotsBug fixRadar position labels no longer overlapBug fixWarning use refactoredBug fixMultiple bug fixes for data handling and plotting in grid plotsBug fixMultiple bug fixes for the aesthetics of convection mapsDocumentationpyDARN's documentation can be foundhereGetting Startedpip install pydarnOr read theinstallation guide.If wish to get access to SuperDARN data please read theSuperDARN data access documentation.
Please make sure to also read the documentation onciting superDARN and pydarn.As a quick tutorial on using pydarn to read a non-compressed file:importmatplotlib.pyplotaspltimportpydarn# read a non-compressed filefitacf_file='20190831.C0.cly.fitacf'# pyDARN functions to read a fitacf filefitacf_data=pydarn.SuperDARNRead(fitacf_file).read_fitacf()pydarn.RTP.plot_summary(fitacf_data,beam_num=2)plt.show()summary plotFor more information and tutorials on pyDARN please see thetutorial section.We also have aJupyter notebookwith many examples to support our recentpublication.Getting involvedpyDARN is always looking for testers and developers keen on learning python, github, and/or SuperDARN data visualizations!
Here are some ways to get started:Testing Pull Request: to determine whichpull requestsneed to be tested right away, filter them by their milestones (v3.0 is currently highest priority).Getting involved in projects: if you are looking to help in a specific area, look at pyDARN'sprojects tab. The project you are interested in will give you information on what is needed to reach completion. This includes things currently in progress, and those awaiting reviews.Answer questions: if you want to try your hand at answering some pyDARN questions, or adding to the discussion, look at pyDARN'sissuesand filter by labels.Become a developer: if you want to practice those coding skills and add to the library, look at pyDARNissuesand filter by milestone's to see what needs to get done right away.Please readpyDARN teamon how to join the pyDARN team.
Package: pydarnio
Python data IO library for the Super Dual Auroral Radar Network (SuperDARN).ChangelogVersion 1.2.1 - Patch Release!This patch release includes a fix for the depreciation of a Numpy method.
Below is more information for the most recent minor release.The most recent minor release included:Handling of extra fields in fitacf files coming in the next RST release, including the name of the ACF fitting algorithm used (algorithm), the value of TDIFF used to calculate the elevation angles (tdiff), and more descriptive field names for the elevation angle fields in FitACF 3.0 (elv_error&elv_fitted)More flexibility around optional fields for all file typesUpdates and speed improvements for Borealis file ioDocumentationpyDARNio's documentation can foundhereGetting Startedpip install pydarnioOr read theinstallation guide.If wish to get access to SuperDARN data please read theSuperDARN data access documentation.
Please make sure to also read the documentation onciting SuperDARN and pydarn.As a quick tutorial on using pyDARNio to read a non-compressed file:importpydarnio# read a non-compressed filefitacf_file='20180220.C0.rkn.stream.fitacf'# pyDARNio functions to read a fitacf filereader=pydarnio.SDarnRead(fitacf_file)records=reader.read_fitacf()or to read a compressed file:importbz2importpydarnio# read in compressed filefitacf_file='20180220.C0.rkn.stream.fitacf.bz2'withbz2.open(fitacf_file)asfp:fitacf_stream=fp.read()# pyDARNio functions to read a fitacf file streamreader=pydarnio.SDarnRead(fitacf_stream,True)records=reader.read_fitacf()For more information and tutorials on pyDARNio please see thetutorial sectionGetting involvedpyDARNio is always looking for testers and developers keen on learning python, github, and/or SuperDARN data visualizations!
Here are some ways to get started:Testing Pull Request: to determine whichpull requestsneed to be tested right away, filter them by their milestones (v1.2.0 is currently highest priority).Getting involved in projects: if you are looking to help in a specific area, look at pyDARNio'sprojects tab. The project you are interested in will give you information on what is needed to reach completion. This includes things currently in progress, and those awaiting reviews.Answer questions: if you want to try your hand at answering some pyDARNio questions, or adding to the discussion, look at pyDARNio'sissuesand filter by labels.Become a developer: if you want to practice those coding skills and add to the library, look at pyDARNioissuesand filter by milestone's to see what needs to get done right away.Please contact the Data Visualization Working Group, if you would like to become a member of the team!
Package: pydash2hls
PyDash2HLSPyDash2HLS is a Python library for converting DASH (Dynamic Adaptive Streaming over HTTP) manifest files to HLS (HTTP
Live Streaming) format.FeaturesConvert MPD files to HLS format.Support for remote and local MPD files.Retrieve media URLs for a specific profile.Handle DRM (Digital Rights Management) information in MPD files.InstallationYou can install PyDash2HLS using pip:pipinstallpydash2hlsUsageConverter InitializationTo initialize the Converter class, you can use the following methods:Initialization from a Remote URLfrompydash2hlsimportConverter# Initialize Converter from a remote URLurl="http://example.com/manifest.mpd"converter=Converter.from_remote(url)Initialization from a Local Filefrompydash2hlsimportConverterfrompathlibimportPath# Initialize Converter from a local filefile_path=Path("path/to/manifest.mpd")converter=Converter.from_local(file_path)Building HLS ManifestTo build an HLS manifest for a specific profile, you can use thebuild_hls()method:# Build HLS manifest for a profileprofile_id="profile1"hls_manifest=converter.build_hls(profile_id)Getting Media URLsTo retrieve a list of media URLs for a specific profile, you can use themedia_urls()method:# Get media URLs for a profileprofile_id="profile1"media_urls=converter.media_urls(profile_id)ExceptionsThe following exceptions can be raised by PyDash2HLS:InvalidPath: Raised when the file path is invalid.InvalidFileContent: Raised when the contents of the file are not in DASH format or are incompatible.InvalidProfile: Raised when the selected profile is invalid.MissingRemoteUrl: Raised when a remote file URL is required but not provided.LicenseThis project is licensed under theGPL v3 License.
Package: pydast
#PyDaSt*Pydast is currently in planning and development stage
Multiple improvements and breaking changes can come until stable releaseShort for Python Data Structures, Pydast is a powerful python module providing a bunch of efficient and method-rich distribution of Data Structures not already pre-built into python.
Functionalities to retrieve abstract data are also provided in order to make this much more flexible for all purpose needs.
In some cases, abstraction is kept low in order to provide maximal Control##Available StructuresA list of Structures available (or planned to be made available) in the package is as under:StructuresInfosinglyA Singly Linked List Data StructuredoublyA Doubly Linked List Data StructuremaxHeapA Max HeapminHeapA Min HeapDisjoint_SetA Disjoint_SetTrieA TrieStackA StackQueueA QueueBinaryIndexedTreeA Binary Indexed TreeMore Info can be found atPydast.org#UsageAll the structures are defined as classes