Saravanan666/pypi-org huggingface dataset:
Package: pyeqs
# PyEQS [![Build Status](https://travis-ci.org/Yipit/pyeqs.svg?branch=master)](https://travis-ci.org/Yipit/pyeqs) [![Coverage Status](https://coveralls.io/repos/Yipit/pyeqs/badge.png)](https://coveralls.io/r/Yipit/pyeqs)#### Python Elasticsearch QuerySetsA python library to simplify building complex Elasticsearch JSON queries.  Based on the Django QuerySet API, backed by the [official python elasticsearch library](https://github.com/elasticsearch/elasticsearch-py).  Supports Elasticsearch1.0+.This is an attempt to provide an interface familiar to users of Django Querysets.  Due to the differences in the backends it was impossible to mirror the Queryset API and maintain full search functionality.  Be aware when using this library that the interfaces may not have the same trade-offs and caveats.#### Current Development StatusCurrently prev1.0, so the API is not locked in.  This project aims to follow [semantic versioning](http://semver.org/) once it reaches a stable API.  Issues may arise as the backendelasticsearch-pylibrary locks its versions toElasticsearchreleases.## Installation`bash pip install pyeqs `## UsageCheck out the [API Reference](https://github.com/Yipit/pyeqs/blob/master/API_REFERENCE.md) for examples.## Alternatives#### Python
* [ElasticUtils](http://elasticutils.readthedocs.org/en/latest/): A library by Mozilla uses a syntax leveraging built-in &, | and ~ to construct queries.
* [Elasticsearch-dsl-py](https://github.com/elasticsearch/elasticsearch-dsl-py): A library by Elasticsearch that is similar and compatible with ElasticUtils.
* [Django-Haystack](https://github.com/toastdriven/django-haystack): A library that wraps multiple search backends and presents them in the same interface as Django models.  In my experience a very all-in-one solution that makes it hard to manipulate Elasticsearch directly, but wonderful when you need the feature set.#### Ruby
* [Plunk](https://github.com/elbii/plunk): A ruby library to allow you to write strings to queries that have more power than simple ‘query string’ requests#### Haskell
* [Bloodhound](https://github.com/bitemyapp/bloodhound/): A basic Elasticsearch Client that also has the ability to leverage the language’s built-in operators to construct queries.#### Perl
* [ElasticSearch::SearchBuilder](https://metacpan.org/pod/ElasticSearch::SearchBuilder): An Elasticsearch Client to help with constructing complex queries and filters.
Package: pyequalizer
pyequalizerThis repo is a python equalizer which is implemented by scipy.
And, the following function is the main one you will use in this package.import pyequalizer.Filter as Filter
type_f = "parabola"
input_file="data/bass.wav"
y, sr = librosa.load(input_file, sr=44100)
y = Filter.equalizer(y, sr, start_iv=200, end_iv=8000, num_iv=100, peak_scale=20, peak_iv = 20, type=type_f)wherestart_iv, end_ivis the frequencys equalizer starts to work and ends;num_ivis the number how many interval will be in. Generally, it means how smooth the equalize curve is.peak_scaleis how much will the signal be enhanced.peak_ivis the interval where the peak of equalizing curve istypemeans the equalizing curve shape. We currently provide "parabola" and "linear".LicenseThis is free and unencumbered software released into the public domain.Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any means.
Package: pyequihash
pyequihashThis is the python bindings for libequihash.installationyou'll needhttps://github.com/stef/equihash/which depends on libsodium.
a simplepip install pyequihashshould suffice to install the bindings.usageimportequihash# input parametersn=102k=5seed="some initial seed"# try to solve the challengesol=equihash.solve(n,k,seed)# verify the solutionprint(equihash.verify(n,k,seed,sol))LicenseGPLv3.0+
Package: pyerail
All rights reserved.Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.Description: |block| PyeRail : eRail python wrapper=============================================.. |block| image:: http://api.erail.in/images/eRail196x196.png:width: 20px:height: 20px**What is it?******************PyeRail is a Python wrapper for the eRail web API.It allows quick and easy comsumption of eRail API from your Python applicatuon.PyeRail reqires Python 3.**Install*************You can install pyerail using:.. code ::$ pip3 install pyerailBuild from source.. code ::$ git clone https://github.com/aksbuzz/PyeRail.git$ cd PyeRail$ make**Usage************API Key*^^^^^^^^^For access to the eRail API you would need a API Key.You can get the API Key from here http://api.erail.in/*Using the module*^^^^^^^^^^^^^^^^^^Creating an instance object of class.. code :: python>>> from pyerail import Erail>>> eRail = Erail(api_key)Getting details of given PNR number.. code :: python>>> eRail.pnr(your_pnr_number)In any case the object returns"status" and "result"**Examples**************You can find example usage in the examples folder.**Contribution******************Contributions are welcome!.**Documentation*******************Documentation at http://api.erail.in/**Todo**********- Add Python 2 support- Add detailed documentationPlatform: UNKNOWN
Package: pyerarchy
Pyerarchy is a Python package for easy file system surfing and manipulation. It enables to interact with the file system
directly as Python objects without making implicit calls toospackage. Finally it makes the code much more readable
and nice.Basic UsageThe central point of Pyerarchy is the Node. The basic usage starts by initializing an entry point Node and manipulating
it further:node = Node('entry/point/path')  # Initialize a new node

children = node.ls()  # List all child entities of the node
node.mkdir('newdir').mkdir('anotherdir')  # Create a new directory under node, and another one under the new one :)

# Now access the newly created directories
anotherdir = node/'newdir'/'anotherdir'  # This is the most common way to access nodes
children = node.newdir.anotherdir.ls()  # This method can be used to invoke an operation on the result node

# What about files?
myfile = node.myfile

# And even...
myfile = node.myfile.open('w')

# Or...
contents = node.myfile.read()  # ...which handles everything

# What if the filename contains a dot, dash, etc?
# Well...
myfile_node = node/'filename.with.dots-and-dashes'

# And then do your stuff on myfile_node
with myfile_node.open('r') as f:
    ...

# Or again...
contents = myfile_node.read()Another useful feature of Pyerarchy is very handy in Python modules to interact with static files included in the module:static_data_node = ThisModuleNode()/'path/to/the/static/data/relative/to/module'

some_file_node = static_data_node/'some/static/text/file'

contents = some_file_node.read()
Package: pyerconf
Sample config:# a value is set with: key : value
# values are typed. allowed types are:
#  - string (simple or double quotes)
#  - boolean (True or False. is case sensitive)
#  - integer

strval : 'this is a string'
boolval: True
intval : 142

# you can define hierarchies with dictionaries
# ! no comma to se
orgchart : {
    boss : 'Mr Goldmine'

    head_office : {
        VP  : 'Miz dho'
        CTO : 'John Bugs'
    }
}Loaded from python:>>> import pyerconf
>>> cfg = pyerconf.Config('./sample.cfg')
>>> print cfg.strval
this is a string
>>> print cfg.orgchart.boss
Mr Goldmine
>>> print cfg.orgchart.head_office
{'VP': 'Miz dho', 'CTO': 'John Bugs'}

>>> print cfg.foobar
AttributeError
Package: pyerf
A Pure-Python Error Function and Inverse Error Function Packagepyerfis a pure-Python implementation of the error function and
inverse error function using the same functions thatSciPyuses (namely
parts of the Cephes math library,cprob/ndtr.candcprob/ndtri.c).This is a useful package for when you need to calculate some error fuctions
but you don’t want to install all of theSciPy/NumPystuff.UsageYou can import the module:frompyerfimportpyerfpyerf.erfinv(0.5)# 0.476936...pyerf.erf(0.5)# 0.5204998...pyerf.erfc(0.5)# 0.4795001...or the package:importpyerfpyerf.erfinv(0.5)# 0.476936...pyerf.erf(0.5)# 0.5204998...pyerf.erfc(0.5)# 0.4795001...or only a specific function:frompyerfimporterfinvasinverse_error_functioninverse_error_function(0.5)# 0.476936...and lastly, you can even useimport *(but that’s no longer considered
very Pythonic as it pollutes the namespace):frompyerfimport*erfinv(0.5)# 0.476936...erf(0.5)# 0.5204998...erfc(0.5)# 0.4795001...ChangelogSeeCHANGELOG.md.
Package: pyerfa
PyERFA is thePythonwrapper for theERFAlibrary (Essential Routines for
Fundamental Astronomy), a C library containing key algorithms for astronomy,
which is based on the SOFA library published by the International Astronomical
Union (IAU).  All C routines are wrapped asNumpyuniversal functions, so that they can be
called with scalar or array inputs.The project is a split ofastropy._erfamodule, developed in the
context ofAstropyproject, into a standalone package.  It contains
theERFAC source code as a git submodule.  The wrapping is done
with help of theJinja2template engine.If you use this package in your research, please cita it via DOI10.5281/zenodo.3940699.Installation instructionsThe package can be installed from the package directory using a simple:$ pip install .and similarly awheelcan be created with:$ pip wheel .NoteIf you already have the C libraryliberfaon your
system, you can use that by setting environment variablePYERFA_USE_SYSTEM_LIBERFA=1.The package can be obtained fromPyPIor directly from the git repository:$ git clone --recursive https://github.com/liberfa/pyerfa/TestingFor testing, one can install the packages together with its testing
dependencies and then test it with:$ pip install .[test]
$ pytestAlternatively, one can usetox, which will set up a separate testing
environment for you, with:$ tox -e testUsageThe package can be imported aserfawhich has allERFAufuncs wrapped with
python code that tallies errors and warnings.  Also exposed are the constants
defined byERFAinerfam.h, as well
asnumpy.dtypecorresponding to structures used byERFA.  Examples:>>> import erfa
>>> erfa.jd2cal(2460000., [0, 1, 2, 3])
(array([2023, 2023, 2023, 2023], dtype=int32),
 array([2, 2, 2, 2], dtype=int32),
 array([24, 25, 26, 27], dtype=int32),
 array([0.5, 0.5, 0.5, 0.5]))
>>> erfa.plan94(2460000., [0, 1, 2, 3], 1)
array([([ 0.09083713, -0.39041392, -0.21797389], [0.02192341, 0.00705449, 0.00149618]),
       ([ 0.11260694, -0.38275202, -0.21613731], [0.02160375, 0.00826891, 0.00217806]),
       ([ 0.13401992, -0.37387798, -0.21361622], [0.0212094 , 0.00947838, 0.00286503]),
       ([ 0.15500031, -0.36379788, -0.21040601], [0.02073822, 0.01068061, 0.0035561 ])],
      dtype={'names': ['p', 'v'], 'formats': [('<f8', (3,)), ('<f8', (3,))], 'offsets': [0, 24], 'itemsize': 48, 'aligned': True})
>>> erfa.dt_pv
dtype([('p', '<f8', (3,)), ('v', '<f8', (3,))], align=True)
>>> erfa.dt_eraLDBODY
dtype([('bm', '<f8'), ('dl', '<f8'), ('pv', [('p', '<f8', (3,)), ('v', '<f8', (3,))])], align=True)
>>> erfa.DAYSEC
86400.0It is also possible to use the ufuncs directly, though then one has to
deal with the warning and error states explicitly.  For instance, compare:>>> erfa.jd2cal(-600000., [0, 1, 2, 3])
Traceback (most recent call last):
...
ErfaError: ERFA function "jd2cal" yielded 4 of "unacceptable date (Note 1)"
>>> erfa.ufunc.jd2cal(-600000., [0, 1, 2, 3])
(array([-1, -1, -1, -1], dtype=int32),
 ...,
 array([-1, -1, -1, -1], dtype=int32))LicensePyERFA is licensed under a 3-clause BSD style license - see theLICENSE.rstfile.
Package: pyerg
PyergPyerg is a C++ library with a Python wrapper for reading the ERG files produced by IPG CarMaker program.
The library implements the specifications of the ERG file format described in the IPG CarMaker reference manual.Henesis s.r.l. is not affiliated with IPG, the developer of CarMaker program.RequisitesPython libraryLinux, Windows (tested within Anaconda)Python >=3.7Numpy >= 1.14GCC >= 4.7C++ libraryCMakeGoogle test library (optional, for building the C++ library)Install Python extensionRunpython setup.py installto install thepyergmodule.Build C++ libraryCreate abuilddirectory in the current folder and from that directory run:cmake ..And thenmakeThe default behavior is to build a static (erg_s) and a shared (erg) version of the Erg parser library.CMake options:BUILD_PYTHON_MODULEenable the building of thepyergPython module.
When building the Python module using CMake, please check that theNUMPY_INCLUDE_DIRin thepyerg/CMakeLists.txtcontains the right path to the Numpy headers.BUILD_TESTSenable the building test program for the C++ library. Data for testing is not included.Use:cmake .. -DBUILD_PYTHON_MODULE=ON -DBUILD_TESTS=ONTo build the C++ library, the Pythonpyergmodule and the C++ tests.Examples of useC++#include <erg.h>

...

erg::Reader parser;

// Read all erg format
parser.open("my_file.erg");

// Allocate the destination memory using vector<byte> as container
std::vector<std::vector<uint8_t>> data(parser.numQuanities());
for(int i=0; i<data.size(); ++i)
    data[i].assign(parser.quantitySize(i), 0);

// Create a vector of pointer to the allocated memory to
// store the data
std::vector<uint8_t*> dataPtrList;
std::vector<size_t> dataPtrListSize;
for(std::vector<uint8_t>& v: data)
{
    dataPtrList.push_back(v.data());
    dataPtrListSize.push_back(v.size());
}

size_t numRows = parser.readAll(dataPtrList, dataWrapperSize);

// data is a vector of vector<byte> with all the quantities from
// the erg file.Pythonimport pyerg

parser = pyerg.Reader()
parser.open("my_file.erg")
data = parser.readAll()

# data is a dict of numpy.ndarray with all the quantities from
# the erg file.See the test applications for more usage examples.
Package: pyergast
pyErgastPython pandas wrapper for the Ergast F1 APIInstallation$pipinstall-ihttps://test.pypi.org/simple/pyergastFeaturesTODODependenciesTODOUsageTODODocumentationThe official documentation is hosted on Read the Docs:https://pyergast.readthedocs.io/en/latest/ContributorsWe welcome and recognize all contributions. You can see a list of current contributors in thecontributors tab.CreditsThis package was created with Cookiecutter and the UBC-MDS/cookiecutter-ubc-mds project template, modified from thepyOpenSci/cookiecutter-pyopensciproject template and theaudreyr/cookiecutter-pypackage.
Package: pyerk
Overview: pyerkPyerk is the python implementation of theemergentrepresentation ofknowledgeframework.Designed to formally represent knowledge (including meta levels)Implementation-status: "early alpha"Inspired by OWL, but much more expressive... at the cost of guarantied computabilityInspired by Wikidata, but much simplerInspired by SUO-KIF, but with less bracketsRepresented directly in python: → imperative instaead of declarative knowledge representationPyerk originated and is currently (2022) mainly developed with focus on representing knowledge from the domain ofcontrol theoryas part of theAutomatic Control Knowledge Repository (ACKREP). However, in principle, it aims to be applicable wo a wide range of domains.Assumed Directory Structure<erk-root>/
├── pyerk/                          ← repo with the code of the core package
│  ├── .git/
│  ├── README.md                    ← the currently displayed file (README.md)
│  ├── setup.py                     ← deployment script
│  ├── src/pyerk/auxiliary.py       ← module containing function get_erk_root_dir()
│  └── ...
│
├── django-erk-gui/                 ← repo with the code for the django gui (project and! app)
│  │                                  (this package is optional)
│  ├── .git/
│  ├── manage.py
│  └── ...
│
├── erk-data/                       ← directory that contains erk-knowledge packages (for actual usage)
│  ├── ocse/                        ← a knowledge package (ontology of control systems engineering)
│  │  ├── .git/
│  │  ├── README.md
│  │  ├── ocse.py                   ← a knowledge module
│  │  │                             (this one is currently used for unit testing)
│  │  └── ...
│  ├── xyz123/                      ← another knowledge package
│  │  └── ...
│  └── ...
├── erk-data-for-unittests/         ← directory that contains erk-knowledge packages
│  └── ...                            (unittest version, probably older and different from
│                                      production data.)
└──...DocumentationRudimentary documentation is available athttps://pyerk-core.readthedocs.io(generated from the/docsdirectory). To get an overview of the most importent features you might also want to have a look at the source code, especially at the filesbuiltin_entities.pyand thetest_core.py.Coding styleWe useblack -l 120 ./to ensure coding style consistency.
Package: pyermassi
Table of ContentsIntroductionLimitationsInstallation InstructionsUsageRelease ChangesIntroductionThis project aims to be a a python wrapper for theErma SSI1417 card. This
card is a synchronous serial interface (SSI) card sold byErma Electronic GmbH, Germany. Together with this card Erma provides a DLL
(ERMA_SSI.DLL) to access the interface from within your own programs through a
simple API. This package usesSWIGto wrap the API to python.The version number of this package equals the version number of the target DLL.
Currently this is version 1.0.0.8 of the ERMA_SSI.DLL.LimitationsThe driver is currently only provided for Windows. Hence, this python package
works only on windows too.Installation InstructionsWindowsYou can download thesource code packageto compile everything yourself or
you can use easy_install to install the precompiled package (py2.6, win32).
To compile the package please follow the instructions provided in the README
file.Installing with easy_install is done by calling from the windows command
prompt (C:>):C:> easy_install pyermassiUsagePlease see theproject homepagefor usage examples. Also refer to the
example.py provided in the package.Release Changes1.0.0.8.post1, Released 2010-06-19Added version tagUpdated installation instructionsRemoved numpy dependencyAdded option to raise error exceptions instead of returning error codes1.0.0.8, Released 2010-05-20First public releaseCovers full 1.0.0.8 API
Package: pyermc
pyermc is a memcache client library with support for “pluggable”
driver backends.Current backends include a text protocol driver (default), a binary
protocol driver, and a wrapped ultramemcached driver.While pyermc is somewhat compatible with python-memcached, full
compatibility is not a design goal.pyermc supports connecting to a single memcached instance (or server
that speaks the memcached protocol). If you require multiple servers,
consistent hashing, etc, then it is recommended to use twemproxy or
similar.pyermc exposes connectivity faults, via exceptions, to the calling
code. This is in contrast to python-memcached, which simply enters an
‘ignore backend’ state. Exposing underlying faults is often needed when
working with queueing servers that support the memcache driver (such as
kestrel and darner), as well as translation proxies like couchbase’s
moxie. If the old behavior is desired, there is an optional error_as_miss
parameter that may be set as part of client creation.
Package: pyErmine
pyErmineEstimate Reaction-rates by Markov-based Investigation of Nanoscopy Experiments (ermine) using Python.AuthorSebastian MalkuschData Science | Clinical PharmacologyInstitute for clinical pharmacologyGoethe-University-HospitalFrankfurt am MainGermanyAbstarctThe python package pyErmine analyzes the mobility of laterally diffusing molecules, such as membrane receptors, using hidden Markov models. It maps the movements of individual receptors to discrete diffusion states, all of which are Brownian in nature. The model is trained with single-particle tracking data.Requirementshmmlearn >= 0.2.4numpy >= 1.19.2pandas >= 1.1.5scikit-learn >= 0.23.2ReferencePublication in progress.TutorialA tutorial including a test data set can be found on Github at the following repository:https://github.com/SMLMS/ermine-tutorial
Package: pyernluefter
Pyernluefter - a very basic python Bayernluefter bridgeA package that connects to the Bayernluefter WiFi-Module.
It controls the module via the simple web-based access provided by the Bayernluft software.
Any templates module should be supported as the tool first fetches the uploaded template and then parses
the exported data based on the template.This package is looking for a maintainer. I don't own a Bayernluefter anymore and can't test any changes. If you are interested in maintaining this package, please contact me.UsageimportasyncioimportaiohttpfrompyernluefterimportBayernluefterIP_Bayernluft='192.168.0.25'asyncdefmain():asyncwithaiohttp.ClientSession()assession:luefter=Bayernluefter(IP_Bayernluft,session)awaitluefter.update()# Show the luefter statusprint("Bayernluft status:",luefter.raw_converted())# turn onawaitluefter.power_on()# set fan speedawaitluefter.set_speed(5)loop=asyncio.get_event_loop()loop.run_until_complete(main())
Package: pyerp
scab-pythonpython library for Event-Related Potentials (ERPs) analysisInstructioneeg_files=list()eeg_files.append(["NAME_OF_FILE_WITHOUT_EXTENTION","TASK_NAME"])marker=list()marker.append([101,"nontarget","word1"])marker.append([102,"nontarget","word2"])marker.append([103,"nontarget","word3"])marker.append([104,"nontarget","word4"])marker.append([105,"nontarget","word5"])marker.append([106,"nontarget","word6"])marker.append([111,"target","word1"])marker.append([112,"target","word2"])marker.append([113,"target","word3"])marker.append([114,"target","word4"])marker.append([115,"target","word5"])marker.append([116,"target","word6"])marker.append([210,"new-trial"])Requirmentsmne version should be greater than 1.2
Package: py-error
es6-errorAn easily-extendable error class for use with python classesWhy?I made this because I wanted to be able to extend Error for inheritance and type
checking .UsageclassmyClass(ExtendableError):#     // __init__ is optional; you should omit it if you just want a custom error#   // type for inheritance and type checkingdef__init__(self,message='OOps!'):super(message)Todotests