Saravanan666/pypi-org huggingface dataset:
Package: pyopendnp3
pyopendnp3This project is a minor fork of the greatpydnp3library, which provides Python
bindings for OpenDNP3.Why fork? Because pydnp3 only provides pip-friendly wheels for Python 2
and Python 2.7 has reached end of life. This fork aims to provide pip-friendly
wheels for Python 3 available on PyPI.While the name of the project is pyopendnp3, module names are unchanged and
thus code that worked with pydnp3 should work with no changes.This project currently produces wheels for the following platforms:WindowsPython 3.5 x86-64Python 3.6 x86-64Python 3.7 x86-64Python 3.8 x86-64The remainder of this README is reproduced verbatim from pydnp3.Python bindings for theopendnp3library,  an open source
implementation of theDNP3protocol stack written in C++14.Note:  This is a work in progress.  SeeIssuesfor things we know about and feel free to add your own.Supported Platforms:Linux, MacOSDependenciesTo build the library from source, you must have:A toolchain with a C++14 compilerCMake >= 2.8.12 (https://cmake.org/download/)This repository includes two repositories as submodules (underdeps/):dnp3 (https://github.com/automatak/dnp3)pybind11 (https://github.com/Kisensum/pybind11) - This is a fork containing a minor patch
required to compile some of the pydnp3 wrapper code. It will be replaced with pybind11 proper
when the issue is resolved.Build & InstallAt the moment, this library must be built from source:$ clone --recursive http://github.com/Kisensum/pydnp3
    $ cd pydnp3
    $ python setup.py installDocumentationpydnp3 is a thin wrapper around most all of the opendnp3 classes.  Documentation for the opendnp3
classes is available atautomatak.Use python's help to discover the available wrapper classes and functions.  For example,> import pydnp3
> help (pydnp3.opendnp3)
Help on module pydnp3.opendnp3 in pydnp3:

NAME
    pydnp3.opendnp3 - Bindings for opendnp3 namespace

FILE
    (built-in)

CLASSES
    pybind11_builtins.pybind11_object(__builtin__.object)
        AnalogCommandEvent
        AnalogInfo
            AnalogSpec
...
Package: pyopendota
A python interface for <OPENDOTA/> APITheOpenDotaclass provided with the package serves as a python
interface for the original OpenDota API in the form of a thin wrapper.
The class assumes some familiarity with the OpenDota API.All method calls return serializable python objects, as return by the API,
in most cases a dict or a list. Response data is stored as JSON in a local
directory (Default:~/dota2), to prevent the load on OpenDota API.Free software: MIT licenseDocumentation:https://pyopendota.readthedocs.io.FeaturesTransparent wrapper for majority of the API callsAbility to authenticate using API keyIn-built and cusomizable limit to protect against frequent API callsLocal file-based storage for frequent requestsBasic CLI usingfireUsageUse <OPENDOTA/> API in a projectimportopendota# Initialize the API-connection objectclient=opendota.OpenDota()Get Common Entitiesclient.get_matches('match-id')client.get_player('player-id')client.get_team('team-id')Search Functionalityplayers=client.search_player('Dendi')teams=client.search_team('Alliance')heroes=client.search_hero('Crystal')leagues=client.search_league('International')PostgreSQL QueryOpenDota API supports arbitrary PostgreSQL query.Check Database Schema:client.get_schema()# Lists all tablesclient.get_schema('matches')# Lists schema for a specific tableArbitrary PostgreSQL Query:client.explorer("select * from matches where limit 1")Use <OPENDOTA/> API Command Line InterfaceInformation about OpenDota class initialization:opendota --helpInformation about OpenDota methods:opendota - --helpRun methodsopendota search_team Virtus
opendota get_match 4080778303Powered by :code:`fire`About OpenDota APIThe OpenDota API provides Dota 2 related data including advanced match data
extracted from match replays.OpenDota API Documentation:https://docs.opendota.com/CreditsThis package uses data provided byThe OpenDota API.History0.2.0 (2021-10-04)Improved DocumentationLeague specific functionsBasic CLI usingpython-fireFantasy score calculationBugfixes0.1.0 (2021-07-20)First release on PyPI.
Package: pyopenfec
PyOpenFecA Python wrapper for the OpenFEC API. Documentation for this API can be foundhereInstallationpip install pyopenfecExamplesCandidatesCandidateTheCandidateclass holds fields for each candidate in the OpenFEC API.A number of class and instance methods are available.countTheCandidate.count()method will return the number of Candidate objects available for a given query. Note: This method returns an integer representing the number of items available in the OpenFEC API. It does not return a list of objects.from pyopenfec import Candidate
candidate_count = Candidate.count(cycle=2016, office="P", candidate_status="C")fetchTheCandidate.fetch()method will return a list of Candidate objects available for a given query. This method will automatically page through the results and return all objects available in the OpenFEC API.from pyopenfec import Candidate
candidate_count = Candidate.count(cycle=2016, office="P", candidate_status="C")
candidates = Candidate.fetch(cycle=2016, office="P", candidate_status="C")
for candidate in candidates:
    print("{name}, {party}".format(name=candidate.name, party=candidate.party))CommitteestktkReportstktk
Package: pyopenfisheries
PyOpenFisheries makes it even easier to access theOpenFisheries APIin Python.A good usecase of this library is to gather data to plot in a Jupyter
Notebook, or to collect data to run time-series analysis on.Learn more aboutOpenFisheries.org.PyOpenFisheries(**kwargs)Bases:objectBase class for accessing the OpenFisheries API. Useful for gathering
data for plots or analysis.Returns:instance: base OpenFisheries API wrapperExamples:>>> open_fish_conn = PyOpenFisheries()
>>> skipjack_tuna = open_fish_conn.annual_landings(species="SKJ").filter_years(start_year=1970,end_year=1991)
>>> print(skipjack_tuna.landings)
[{'year': 1970, 'catch': 402166}...{'year': 1991, 'catch': 1575170}]
>>> print(skipjack_tuna.summarize())
Landings of SKJ globally from 1970 to 1991Attributes:landings: List of dictionaries containing the year and landing count.
species: if present - three-letter ASFIS species code (i.e. “SKJ” - Skipjack Tuna).
country: if present - ISO-3166 alpha 3 country code (i.e. “USA” - United States).
start_year: if present - start year of filtered landings data.
end_year : if present - end year of filtered landings data.annual_landings(species=None, country=None)Gathers annual fishery landings filtered by either species or country.
If neither fish nor country are specified, then this will return global
aggregate landings data.Args:species: three-letter ASFIS species code (i.e. “SKJ” - Skipjack Tuna)
country: ISO-3166 alpha 3 country code (i.e. “USA” - United States)Returns:instance: PyOpenFisheries instance with landings populatedfilter_years(start_year=1950, end_year=2018)Filters annual fishing data to within a time-frame.Args:start_year: 4 digit integer year (i.e. 1980)
end_year: 4 digit integer year (i.e. 2015)Returns:instance: PyOpenFisheries instance with years filtered.summarize()Summarizes what has been returned from OpenFisheries.label()Useful as a legend / for plots.
Package: py-open-fonts
py-open-fontsOpen Fontsin pip and conda.InstallNeeds python 3.6+condainstall-cdefaults-cconda-forgepy-open-fontsorpipinstallpy-open-fontsAPICLIUsage: open-fonts-css [OPTIONS] [FONTS]...

  Generates CSS source with @font-face definitions with absolute paths to
  fonts files as URL.

  Multiple FONTS like FontName can be provided. For example "FontName"
  argument means using $PYTHONPREFIX/fonts/open-fonts/css/FontName.css If
  none were provided then all fonts definitions from
  $PYTHONPREFIX/fonts/open-fonts/css/ would be used.

  Note that spaces would be removed from provided font names and CSS files
  do not contain spaces in their names.

Options:
  -p, --pref TEXT  Generated CSS would have TEXT as prefix in URL to fonts
                   files (instead of default absolute path as URL). Like:
                   ${PREFIX}FontName.ttf ("<...>" to "TEXT"replacement
                   actually)
  -o, --out TEXT   Save CSS to TEXT filepath. "-" means write to stdout
                   (default behaviour)
  --help           Show this message and exit.open_fonts_cssdefopen_fonts_css(*fonts:str,pref:str=None,out:str=None)->str:"""Generates CSS source with @font-face definitions with absolute pathsto fonts files as URL.Multiple ``fonts`` like ``"FontName"`` can be provided. For example ``"FontName"``argument means using ``$PYTHONPREFIX/fonts/open-fonts/css/FontName.css``If none were provided (``fonts`` is ``()``) then all fonts definitions from``$PYTHONPREFIX/fonts/open-fonts/css/`` would be used.Note that spaces would be removed from provided font names and CSS filesdo not contain spaces in their names.:param pref:Generated CSS would have ``pref`` as prefix in URL to fonts files (insteadof default absolute path as URL). Like: ``f"{pref}FontName.ttf"``("<...>" to ``pref`` replacement actually).:param out:Save CSS to ``out`` filepath. ``"-"`` or ``None`` mean do nothing.:return: CSS source code if out is None or '-' else returns ''"""
Package: pyopenfst
OpenFSTThis is a unofficial repository forOpenFstusing Python. This repo was created because the
OpenFST installation can be very painful!InstallationFrom pip:pipinstallpyopenfstFrom conda:condainstallpyopenfstFrom Source:pythonsetup.pyinstallOpenFST project homeThe OpenFst library is not develop here! SeeOpenFst project homeor the originalREADMEfor more information
Package: py-opengauss
This package is based on py-postgresql upgrades to work with openGauss.Repo:https://gitee.com/opengauss/openGauss-connector-python-pyogAdapted from:http://github.com/python-postgres/fev1.3.0WarningIn v1.3,py_opengauss.driver.dbapi20.connectwill now raiseClientCannotConnectErrordirectly.
Exception traps around connect should still function, but the__context__attribute
on the error instance will beNonein the usual failure case as it is no longer
incorrectly chained. TrappingClientCannotConnectErrorahead ofErrorshould
allow both cases to co-exist in the event that data is being extracted from
theClientCannotConnectError.py-opengauss is a set of Python modules providing interfaces to various parts
of openGauss. Primarily, it provides a pure-Python driver with some C optimizations for
querying a openGauss database.https://gitee.com/opengauss/openGauss-connector-python-pyogFeatures:Prepared Statement driven interfaces.Cluster tools for creating and controlling a cluster.Support for most PostgreSQL types: composites, arrays, numeric, lots more.COPY support.Multiple ip connect supportSample PG-API Code:>>> import py_opengauss
>>> db = py_opengauss.open('pq://user:password@host:port,host:port/database')
>>> db.execute("CREATE TABLE emp (emp_first_name text, emp_last_name text, emp_salary numeric)")
>>> make_emp = db.prepare("INSERT INTO emp VALUES ($1, $2, $3)")
>>> make_emp("John", "Doe", "75,322")
>>> with db.xact():
...  make_emp("Jane", "Doe", "75,322")
...  make_emp("Edward", "Johnson", "82,744")
...There is a DB-API 2.0 module as well:py_opengauss.driver.dbapi20However, PG-API is recommended as it provides greater utility.Once installed, try out thepg_pythonconsole script:$ python3 -m py_opengauss.bin.pg_python -h localhost -p port -U theuser -d database_nameIf a successful connection is made to the remote host, it will provide a Python
console with the database connection bound to thedbname.
Package: pyopengltk
pyopengltkTkinter - OpenGL Frame using ctypespyopengltk on Githubpyopengltk on PyPIAn opengl frame for pyopengl-tkinter based on ctypes (no togl compilation)Collected together by Jon Wright, Jan 2018.Basic ExampleThis example creates a window containing anOpenGLFramefilling the entire window. We configure it to animate
(constantly redraw) clearing the screen using a green color.
A simple framerate counter is included.
The context information is printed to the terminal.importtimeimporttkinterfromOpenGLimportGLfrompyopengltkimportOpenGLFrameclassAppOgl(OpenGLFrame):definitgl(self):"""Initalize gl states when the frame is created"""GL.glViewport(0,0,self.width,self.height)GL.glClearColor(0.0,1.0,0.0,0.0)self.start=time.time()self.nframes=0defredraw(self):"""Render a single frame"""GL.glClear(GL.GL_COLOR_BUFFER_BIT)tm=time.time()-self.startself.nframes+=1print("fps",self.nframes/tm,end="\r")if__name__=='__main__':root=tkinter.Tk()app=AppOgl(root,width=320,height=200)app.pack(fill=tkinter.BOTH,expand=tkinter.YES)app.animate=1app.after(100,app.printContext)app.mainloop()The repository on Github also contains more examples.InstallFrom PyPI:pip install pyopengltkFrom source:git clone https://github.com/jonwright/pyopengltk
cd pyopengltk
pip install .AttributionsBased on the work of others.C + Tcl/Tk example:Project URL :http://github.com/codeplea/opengl-tcltk/(zlib license)Article at :https://codeplea.com/opengl-with-c-and-tcl-tkPython + Tkinter (no pyopengl) example:Project URL :http://github.com/arcanosam/pytkogl/(The Code Project Open License)Article at:http://www.codeproject.com/Articles/1073475/OpenGL-in-Python-with-TKinterpyopenglLarge regions of code copied frompyopengl/Tk/__init__.py.
Package: pyopening_hours
Python module providing access to theopening_hours.jslibrary
which is written in JavaScript.This python library only implements thesimple
APIfrom
opening_hours.js at the moment (without optional parameters).InstallationInstallpyopening_hourssimply by using pip:pip install pyopening_hoursUsageimportpyopening_hourstry:oh=pyopening_hours.OpeningHours(u'Lun-')exceptpyopening_hours.ParseExceptionaserror:print(error.message)value=u'Mon,Tu,Th,Fr 12:00-18:00; Samstag 12:00-17:00 "I ❤ unicode"; Th[3] OFF; Th[-1] off'oh=pyopening_hours.OpeningHours(value)print(u"Parsing complex value:{}".format(value))print(u"Is{}week stable".format(''ifoh.isWeekStable()else' not'))print(u"Facility is{}".format(oh.getStateString()))print(u"Next change in UTC:{}".format(oh.getNextChange().strftime('%Y-%m-%d%H:%M:%S')))print(u"Warnings:")forlineinoh.getWarnings():print('  '+line)DevelopmentJust clone the repository withgitclonehttps://github.com/ypid/pyopening_hoursand install it’s dependencies (execute inside the repository):makedependencies-getUsed by other projectsThis library is used in the following projects:opening_hours_botOther modulesosm-opening-hours(pure python implementation)
Package: py-openjvs
OpenJVSWarningDevelopment by me has all but stalled. If you're interested in taking
over the repo, I'm sure something can be arranged.IntroductionThe OpenJVS project aims to reverse engineer the commonly used JVS-I/O
protocol for arcade cabinet input devices. It also aims to document
it and provide reference implementations of useful hard- and software.Currently we are finalizing our understanding of the protocol and
developing hard- and software to serve as bus master for a device.ContactThe principal maintainer of this project is Roy Smeding; reachable
through GitHub as roysmeding and e-mail asroy.smeding@gmail.com.SubdirectoriesSubdirectories are split up by subproject. Currently, the following
subdirectories are present:pythonThis subdirectory contains two programs, jvs-master and jvs-snoop,
written in the Python programming language. They interface to the bus
-- one as a bus master, the other as a listener via a splitter cable
for debugging.wikiInformation about the protocol can be found on our wiki, athttps://github.com/TheOnlyJoey/openjvs/wiki
Package: pyopenkeyval
OpenKeyval.orgis a service for easily
storing and retrieving key/value pairs via HTTP.pyopenkeyvalis a
Python interface to this service, presented as a dict-like object that
accesses data on OpenKeyval.Installing$ sudo python setup.py installExamplesNormal usagefrom pyopenkeyval import pyopenkeyval
okv = pyopenkeyval()
okv['example'] = 'Hello, online key/value storage!'
print okv['example']If you need the result from storing a value, use thestore()method
instead:result = okv.store('example', 'Hello, online key/value storage!')
print result['read_only_key']To check if a key has a value, use theinkeyword. Note that this
will also cache the value if caching is activated.if 'example' in okv:
     ...Deleting keysTo delete a key, either set its value to ‘’ or use thedelkeyword:del okv['example']CachingIf you want to cache retrieved values locally, set thecache_timeargument when constructing thepyopenkeyvalobject. This specifies
the number of seconds to cache individual values.okv = pyopenkeyval(cache_time=60)To clear the cache completely at any time, call theclear_cache()method.SSL supportOpenKeyval.org also supports SSL over HTTPS for more secure transfer of
data. To use SSL, set thesslargument to True.okv = pyopenkeyval(ssl=True)Note that the HTTP och HTTPS versions of OpenKeyval.org are completely
separate. Values set in one can’t be fetched from the other.Python 3pyopenkeyvalis since version 0.3 compatible with Python 3. It must,
however, either be installed usingsetup.py(as described above)
before use, or manually be converted using the2to3tool.Also note that values fetched will be returned asbytes. To use
these as strings, call the.decode()method on them first. When
setting values, eitherstrorbytescan be used.RequirementsPython 2.5 and lower requiresimplejsonto be installed.
Package: pyopenload
python wrapper forOpenload.coAPI.Install$pipinstallpyopenloadUsageAllAPIfeatures are implemented.Retrieve account infofromopenloadimportOpenLoadol=OpenLoad('login','key')account_info=ol.account_info()print(account_info)Upload filefromopenloadimportOpenLoadol=OpenLoad('login','key')uploaded_file_info=ol.upload_file('/home/username/file.txt')print(uploaded_file_info)Retrieve file infofromopenloadimportOpenLoadol=OpenLoad('login','key')# Random file id.file_id='YMTqhQAuzVX'file_info=ol.file_info(file_id)print(file_info)Documentationdocumentation is available athttps://pyopenload.readthedocs.io/.
Package: pyopenls9
open-ls9-controlOpen LS9 Control is a C++ library for controlling the Yamaha LS9 mixer.
There are also Python bindings included known as PyOpenLS9.It depends on theYamaha Network-MIDI driverand the port name is " Port 1" where  is the name from System Preferences.ParametersA parameter is defined by an element, index and channel, defined in C++ as an aggregate thus:struct Parameter {
  int element;
  int index;
  int channel;
};And in Python as a dataclass thus:@dataclass
class Parameter:
  "Some parameter of the desk"
  element : int
  index : int
  channel : intThe LS9 classIn C++ the LS9 class is constructed with the port name as a std::string_view and exposes the following methods:static auto portNames() -> std::vectorstd::stringvoid addGlobalCallback(std::function<void(Parameter, int32_t)> callback)void addParamCallback(Parameter param, std::function<void(Parameter, int32_t)> callback)auto get(Parameter param, std::chrono::milliseconds timeout) -> int32_tvoid set(Parameter param, int32_t value)void fade(Parameter param, int32_t value, std::chrono::milliseconds duration, std::chrono::milliseconds timeout)auto nextParamTouched() -> Parameterauto getChannelName(int ch, std::chrono::milliseconds timeout) -> std::stringThe Python class is much the same: any callable can be used where a std::function is expected and an integer number of milliseconds is used where a std::chrono::milliseconds is expected.
It also has the portNames static method which returns a list of strings.
Package: pyopenmensa
This small python library helps you to work withOpenMensaby:support writing canteen feeds:The feed modulemakes it very easy to generate a validOpenMensa Feed    V2. This is in production use for the majority of canteens inOpenMensa.python wrapper for OpenMensa data: Access data (canteens, meals) transparent fromopenmensa.(in development)More information aboutOpenMensa and all possibilities for developers.DocumentationDocumentation is hosted byReadTheDocs: for theFull documentation about PyOpenMensaThe documentation is created withSpinxand the documentation source code can be found in the doc/ directory.tldr: DocumentationYou needPython2.6, 2.7 or>=3.2.Install pyopenmensa:via pypipipinstallpyopenmensavia gitgitclonegit://github.com/mswart/pyopenmensa``Create Feed builder:# import LazyBuilder - the container for all mealsfrompyopenmensa.feedimportLazyBuildercanteen=LazyBuilder()# canteen containerAdd feed data (PyOpenMensa can do basic parsing and converting):fromdatetimeimportdatecanteen.addMeal(date(2013,3,4),'Hauptgericht','Gulasch',notes=['Mit Süßstoff','Schwein'],prices={'student':203,'other':'3,05 €'})canteen.setDayClosed('5.3.2013')Receive XML Feed:print(canteen.toXMLFeed())And you have a validOpenMensa V2 Feed:<?xml version="1.0" encoding="UTF-8"?><openmensaversion="2.0"xmlns="http://openmensa.org/open-mensa-v2"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"si:schemaLocation="http://openmensa.org/open-mensa-v2 http://openmensa.org/open-mensa-v2.xsd"><canteen><daydate="2013-03-04"><categoryname="Hauptgericht"><meal><name>Gulasch</name><note>MitSüßstoff</note><note>Schwein</note><pricerole="other">3.05</price><pricerole="student">2.03</price></meal></category></day><daydate="2013-03-05"><closed/></day></canteen></openmensa>ContributingFork it.Create a branch (git checkout-bmy_markup)Commit your changes (git commit-am"Added Snarkdown")Push to the branch (git push origin my_markup)Open aPull RequestEnjoy a refreshing Diet Coke and waitLicenseLGPL LicenseCopyright (c) 2012-2015 Malte Swart. LGPL license, see LICENSE for more
details.
Package: pyopenms
This package contains Python bindings for a large part of the OpenMS library
for mass spectrometry based proteomics.  It thus provides providing facile
access to a feature-rich, open-source algorithm library for mass-spectrometry
based proteomics analysis. These Python bindings allow raw access to the
data-structures and algorithms implemented in OpenMS, specifically those for
file access (mzXML, mzML, TraML, mzIdentML among others), basic signal
processing (smoothing, filtering, de-isotoping and peak-picking) and complex
data analysis (including label-free, SILAC, iTRAQ and SWATH analysis tools).You can install pyopenms using:pip install pyopenmsPlease seehttps://pyopenms.readthedocs.io/en/latest/index.htmlfor more information.
Package: pyopenms-extra-Fabian-Yannik-Laura
pyOpenMS ExtrapyOpenMS are the Python bindings to the OpenMS open-source C++ library for
LC-MS data management and analyses. The Python bindings cover a large part of
the OpenMS API to enable rapid algorithm development and workflow development.
pyOpenMS supports the Proteomics Standard Initiative (PSI) formats for MS data.These utils contain documentation, installation instructions and example code
that show the different functions of pyOpenMS.InstallationInstallation is best done throughPyPI(the Python package index) where binary packages are provided for the release
versions of OpenMS, covering Linux/Mac/Windows.DocumentationThe pyOpenMS documentation is also contained in this repository, seedocs/README.md
Package: pyopenms-nightly
This package contains Python bindings for a large part of the OpenMS library
for mass spectrometry based proteomics.  It thus provides providing facile
access to a feature-rich, open-source algorithm library for mass-spectrometry
based proteomics analysis. These Python bindings allow raw access to the
data-structures and algorithms implemented in OpenMS, specifically those for
file access (mzXML, mzML, TraML, mzIdentML among others), basic signal
processing (smoothing, filtering, de-isotoping and peak-picking) and complex
data analysis (including label-free, SILAC, iTRAQ and SWATH analysis tools).You can install pyopenms using:pip install pyopenmsPlease seehttps://github.com/OpenMS/OpenMS/wiki/pyOpenMSfor more information.
Package: pyopenpgparse
# Python OpenPGP Packet parser and assemblerThis module has for puropse to parse and create openPGP packets, following the
[RFC 4880](https://tools.ietf.org/html/rfc4880) specifications.It convert a nested S-Expression describing the packets to be converted in a
stream of packets which can then be turned into a RADIX64 file.It can also take a RADIX64 file as an input and generate a nested S-Expression
representing all the packets given in input.