Saravanan666/pypi-org huggingface dataset:
Package: equals
A mock equality tool for testingtl;dr Equals is a stricter version ofMock.Any.Equals allows you to assert certain equality constraints between python
objects during testing. There are times where we don’t want to assert
absolute equality, e.g. we need to ensure two lists have the same
elements, but don’t care about order.  This was designed specifically for
usage withMockanddobles.APIFull Documentation is available at http://equals.readthedocs.org/en/latest/.strings:from equals import any_string

any_string.containing('abc') == '123 abc 456'
any_string.starting_with('abc') == 'abcdef'
any_string.ending_with('abc') == '123abc'
any_string.matching('^abc$') == 'abc'numbers:from equals import any_number

any_number.less_than(5) == 4
any_number.less_than_or_equal_to(5) == 5
any_number.greater_than(4) == 5
any_number.greater_than_or_equal_to(5) == 5
any_number.between(1, 3) == 2dictionaries:from equals import any_dict

any_dict.containing(1, 2) == {1: 2, 2:3, 4:5}
any_dict.containing(foo='bar') == {
    'foo': 'bar',
    'bob': 'barker'
}
any_dict.not_containing(1, foo=5) == {'foo':3, 4:5}iterators:from equals import any_iterable

any_iterable.containing(1, 2, 3) == [1, 2, 3, 4, 5]
any_iterable.containing_only(1, 2, 3) == [2, 3, 1]
any_iterable.not_containing(1, 2) == [3, 4]
any_iterable.with_length(2) == [3, 4]objects:from equals import anything

anything == None
anything == True
anything == {1: 1}
anything_true == 'dd'
anything_false == ''

instance_of(dict) == {}
anything.with_attrs(foo='bar', bob='barker') == Dummy('bar', 'barker')
instance_of(Dummy).with_attrs(foo='bar', bob='barker') == Dummy('bar', 'barker')With Mock:from mock import Mock
from equals import any_dict

test_object = Mock()
test_object.method({'bob': 'barker'})
test_object.method.assert_called_with(any_dict)dobles:from dobles import expect
from equals import any_string


class TestClass(object):
    def method(self, arg):
        return arg


test_object = TestClass()
expect(test_object).method.with_args(any_string.containing('bob'))

test_object.method('bob barker')Installation:>> pip install equalsDevelopmentSource code is available athttps://github.com/smartfastlabs/equals.To install the dependencies on a fresh clone of the repository, runmake bootstrap.To run the test suite, runmake test.To build the documentation locally, runmake docs.LicenseMIT:http://opensource.org/licenses/MIT
Package: equation-painter-wsm
Equation Painter (WSM)"A way for teachers to make equation painter worksheets for their students."Grab the file at thelatest release, or install with:pip3 install equation_painter_wsmor build from source:gitclonehttps://github.com/cole-wilson/wsmcdwsm
python3./setup.pydevelopor Homebrew:brew install cole-wilson/taps/Equation_Painter
Package: equation-scraper
Overviewequation_scraperis a Python package that scrapes Wikipedia pages for mathematical equations and then parses the equations into its components to build prior distributions. Specifically, these priors include information such as the number of times an operator or function appears across all equations scraped. For example, the expressionm*x+b*sin(y)would be parsed into the simple prior:{*: 2, +: 1, sin: 1}. The package includes much more information than this simple prior, for example conditional priors---a full breakdown of the included metrics is detailed on thePriorssection of our documentation. The package was designed to provide equation discovery modelling techniques, such as Symbolic Regression and the Bayesian Machine Scientist, with informed priors; however, the application of this package can extend far beyond this.Documentationequation_scraperdocumentation can be found athttps://autoresearch.github.io/equation-scraper/Equation-Scraper in ResearchThere are no current publications using theequation-scraper; however, we have two manuscripts currently under review. They are in a double-blind review process, so we are at this point refraining from sharing preprints, but will do so as soon as we are able.AboutThis project is in active development by theAutonomous Empirical Research Group, led bySebastian Musslick. The package was built byChad Williams. Furthermore, the package depends on another package of ours,equation-tree, which was developped by Younes Strittmatter and Ioana Marinescu.This research program is supported by Schmidt Science Fellows, in partnership with the Rhodes Trust, as well as the Carney BRAINSTORM program at Brown University.
Package: equation-sdk
🌞 equation-sdkA python 3 library to interact with Equation Devices.equation-sdkis a Python 3 library for the Equation HomeAssistant integration via a REST API.Installation[Supported devices] (#supported-devices)Installationpipinstallequation-sdkSupported devicesCurrently supported devices include:Hera radiatorsContributions usedPortions fromhttps://github.com/tggm/rointe-sdkPortions fromhttps://github.com/AndreMiras/equation-connect.js
Package: equation-solver-abhhii
Equation SolverThis package can be used to solve linear equations encode in JSON.
Sample format is given below:{
    "op": "equal",
    "lhs": {
        "op": "add",
        "lhs": 1,
        "rhs": {
            "op": "multiply",
            "lhs": "x",
            "rhs": 10
        }
    },
    "rhs": 21
}A driver program is included in the package to give an idea how to use the package.
Package: equationtracer
What is EquationTracer?EquationTracer uses NumPy and Pygame to convert an arbitrary scribble into a parametric equation which you can plot on Graphing Calculators such as Desmos!InstallationThis is a guide on how to install EquationTracer.Note: You need Python installed on your system, along with either pip or pipx.If you do not want to use pip or pipx, you can also alternatively clone this git repository, or simply copy the code!Linux:pip install equationtracerMac:pip3 install equationtracerWindows (pipx):pipx install equationtracerWindows (pip):pip install equationtracerNote: For Windows, it is recommended to use pipx as using pip does not allow the poetry scripttrace-equationto run, but pipx does support this. If pip is used, you need to run the program with the other command, as provided below. On Max and Linux, pip3 will automatically allow the poetry scripttrace-equationto be able to be executed.RunningTo run the program, type into a command line:trace-equationIf you installed the program with pip (instead of pipx) on windows, or if the above command doesn't work, you can also do:Windows:py -m equationtracerOthers:python3 -m equationtracerUpdatingTo update the program, use the following:Linux:pip install -U equationtracerMac:pip3 install -U equationtracerWindows (pipx):pipx upgrade equationtracerWindows (pip):pip install -U equationtracerDependenciesEquationTracer uses the libraries numpy, pygame and pyperclip, and runs on Python 3.9 and above.
Package: equation-tree
Equation TreeThe Equation Tree package is an equation toolbox with symbolic regression in mind. It represents
expressions as incomplete binary trees and has various features tailored towards testing symbolic
regression algorithms or training models. The main features are:Equation sampling (including priors)Feature Extraction from equation distributionsDistance metrics between equationsGetting StartedCheck out the documentation athttps://autoresearch.github.io/equation-tree.AboutThis project is in active development by
theAutonomous Empirical Research
Group(package developers: Ioana Marinescu andYounes Strittmatter,
PI:Sebastian Musslick. This research program is supported by
Schmidt Science Fellows, in partnership with the Rhodes Trust, as well as the Carney BRAINSTORM
program at Brown University.
Package: equator
Set of tools for comparing complex objectsQuickstartequator is available on PyPI and can be installed withpip.$pipinstallequatorAfter installing equator you can use it like any other Python module.Here is a simple example:fromequatorimportequalsitem1=[{1:[{1:[1,2]},[1,2.0001],],},[3,[4,[5]]],]item2=[{1:[{1.0001:[1,2.0001]},[1.0001,1.9999],],},[2.9999,[4,[5.002]]],]result=equals.approx(item1,item2,rel_tol=1e-2)assertresultThe functionapproxallows one
to compare approximately objects of various types.The motivation to create this function was thatpytest.approxdoes not allow comparison of the complex objects.
In contrast, this function allows one iterate through__dict__of arbitrary objects and make use ofmath.isclosewhen encountering numeric types.TODOCurrently one may expect issues with sets andDecimal.Change LogVersion History0.0.1Project created.
Package: equatorpy
EquatorA maths interpreter built in Python using SymPyFeatures:Solve simultaneous equationsSimplify expressionsIt can do maths faster than youInstallationEquator can be installed from PyPi. Run the commandpip3 install equatorpyUsage:Start-up:Equator can be run directly through the Python module. Run the commandpython3 -m equatorAlternatively, Equator can be invoked directly using the commandequatorThe program has been tested on Windows and Linux (Ubuntu), but not MacOS. It might work, but it might not.If no arguments are provided, the program launches into a full interpreter, built using the Curses library.If it is started with the argumentjson, then its output will be in a JSON format, where each line of input is treated as one set of equations and expressions. Each input will have one line of respective output, inJSON format.If it is started with the argumentev, then it will run a quick evaluation on the following argument. For exampleequator ev "1 + 1"would print2.Syntax:Order of operations is respected (including brackets)Use standard mathematical syntax (+, -, *, /, ^, =, etc)Functional notation is used for unary operators:|A|should be written asabs(A)Equations or expressions are separated by semicolonsDevelopmentWhen working with Equator, it is recommended to work with a virtual environment.Aftergit cloneing the repository, set up a virtual environment usingthese
instructions, then install the
required dependencies using the commandpip3 install -r requirements.txtor if you're on Windowspip install -r requirements_windows.txtYou should then be able to debug or develop the interpreter normally.
Package: eques-elf
Eques Elf pythonKudos to iamckn who has in-depth posts describing their work reverse engineering
the Eques Elf smart plug devices and has gocode alongside it, athttps://github.com/iamckn/equesThis module is adapted from it to provide a Python module to be used in
HomeAssistant.Command line usageSee helpdoc for specific details.List devicespythonsrc/main.pydiscover[{"ip":"10.0.0.123","mac":"dc-4f-22-25-ab-cd","password":"foobar","state":true}]Get statuspythonsrc/main.pysend--cmdstatus--macdc-4f-22-25-ab-cd--ip10.0.0.123--passwordfoobar[{"ip":"10.0.0.123","mac":"dc-4f-22-25-ab-cd","password":"foobar","state":true}]Toggle deviceToggle first fetches state (cmd: status) then sends a set command.pythonsrc/main.pysend--cmdtoggle--macdc-4f-22-25-ab-cd--ip10.0.0.123--passwordfoobar[{"ip":"10.0.0.123","mac":"dc-4f-22-25-ab-cd","password":"foobar","state":false}]Set device onpythonsrc/main.pysend--cmdset_on--macdc-4f-22-25-ab-cd--ip10.0.0.123--passwordfoobar[{"ip":"10.0.0.123","mac":"dc-4f-22-25-ab-cd","password":"foobar","state":false}]Set device offpythonsrc/main.pysend--cmdset_off--macdc-4f-22-25-ab-cd--ip10.0.0.123--passwordfoobar[{"ip":"10.0.0.123","mac":"dc-4f-22-25-ab-cd","password":"foobar","state":false}]APISeeeques_local.pyand use:discover_commandstatus_commandoff_commandon_commanddevice.Deviceis used for carrying the device data.
Package: equestions-pkg-joanclopezm
___        ______     ____ _                 _  ___  
    / \ \      / / ___|   / ___| | ___  _   _  __| |/ _ \ 
   / _ \ \ /\ / /\___ \  | |   | |/ _ \| | | |/ _` | (_) |
  / ___ \ V  V /  ___) | | |___| | (_) | |_| | (_| |\__, |
 /_/   \_\_/\_/  |____/   \____|_|\___/ \__,_|\__,_|  /_/
Package: equeue
# EQueueElastic Queue is a library to bear a PubSub projects### How to use itInstall via PIP```shell$ pip install equeue```#### ProducingUsing ipython```pythonIn [1]: from equeue.rabbit.publisher import PublisherIn [2]: pub = Publisher(host='localhost', username='guest', password='guest', queue_name='t')In [3]: pub.put(message_dict={'id': 1})Out[3]: <promise@0x10ef18b78>```#### By pollUsing ipython```pythonIn [1]: from equeue.rabbit.subscriber import SubscriberIn [2]: sub = Subscriber(host='localhost', username='guest', password='guest', queue_name='t')In [3]: msg = sub.get()In [4]: if msg:...:     print(msg)...:```#### ConsumingCreating a main.py you'd see better.```pythonfrom equeue.rabbit.subscriber import Subscriberdef events_out(callback, message, delivery_tag):print(message)print(delivery_tag)callback.ack(delivery_tag)def main():sub = Subscriber(host='localhost', username='guest',password='guest', queue_name='t')sub.setup_consumer(callback=events_out)while True:sub.consume()if __name__ == '__main__':main()```Then```shell$ python main.py```### Developing modeRunning testsTo run the project's test you will need to have pytest installed. The instalation is simple as :```shell$ pip install pytest```And to run the tests you need to ajust yout `PYTHONPATH````shell$ PYTHONPATH=equeue py.test```
Package: equibatch
Equiareal batch samplerStandard practice in Deep Learning is to train models on batches of data, keeping the number of samples in a batch ("batch size") constant.
However, what you really need is a constant memory footprint of a batch, to i.e. coordinate it with the memory of your GPU.
If your samples have different sizes (common in text, time series data), constant batch size will lead to a highly variable memory footprint.
This package provides a batch sampler that keeps constant "batch area": sum of lengths of samples.
Batch area mostly corresponds to its memory footprint, although padding will increase it slightly.Installationpip install equibatchUsagefromequibatchimportEquiarealBatchSamplerdata=['London','Birmingham','Glasgow','Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch','Liverpool','Bristol','Manchester']batch_sampler=EquiarealBatchSampler(sampler=range(len(data)),# the order in which the dataset is traversedlen_checker=lambdaix:len(data[ix]),# definition of "footprint of a sample"max_size=10,# maximum number of samples in a batchmax_footprint=60# maximum cumulative footprint of a batch)forbatchinbatch_sampler:sample=[data[ix]forixinbatch]print(sample)This will print['London', 'Birmingham', 'Glasgow']
['Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch']
['Liverpool', 'Bristol', 'Manchester']Pytorch supportIf you have Pytorch installed,EquiarealBatchSamplerwill be a subclass oftorch.utils.data.sampler.BatchSamplerand you can use it in yourtorch.utils.data.DataLoaderlike this:fromtorch.utils.dataimportDataLoaderdataloader=DataLoader(dataset=data,batch_sampler=batch_sampler)forinputindataloader:output=model(input)loss=loss_fn(output)loss.backward()optimizer.step()
Package: equid
equid下の方に日本語の説明がありますOverviewSolving library for simultaneous equations and inequalitiesUsageimportequidaseq# Example of solving an equationres=eq.solve(cond=(eq.x+3==5))print(res)# -> {"x": 2.0}# Inequalities and series are also possible. If there is more than one solution, one is randomly chosen.cond=((eq.x+2==eq.y)&(eq.x>=10))res=eq.solve(cond=cond)print(res)# -> e.g. {"x": 10.0, "y": 12.0}# Assignprint((eq.x+5).fix(x=3))# -> 8print((5+eq.x+eq.y).fix(x=3))# -> (+ 8 (var y))# Mathematical programming (find the one with the smallest loss among those satisfying cond)res=eq.solve(cond=(3*eq.x-eq.y==0),loss=(eq.y-1)**2)print(res)# -> {"x": 0.333, "y": 1}# convert to javascript codeprint(eq.to_js((3+eq.x)**2))# -> Running "(OUTPUT_STR({x: 1}))" in javascript will output 16.# Algorithmic differentiation (automatic differentiation)print((eq.x**2).diff("x"))# -> (* 2 (var x))# Interconversion between json format and equid objectformula=(3+eq.x)**2print(formula.to_json())# -> ["**", ["+", 3, ["var", "x"]], 2]print(eq.from_json('["**", ["+", 3, ["var", "x"]], 2]'))# -> Formula objectAdvanced Usage# 執筆中 (under_construction)概略連立方程式/不等式の求解ライブラリ利用例importequidaseq# 方程式を解く例res=eq.solve(cond=(eq.x+3==5))print(res)# -> {"x": 2.0}# 不等式・連立もできる。解が複数あるときはひとつ選ばれるcond=((eq.x+2==eq.y)&(eq.x>=10))res=eq.solve(cond=cond)print(res)# -> 例えば{"x": 10.0, "y": 12.0}# 代入print((eq.x+5).fix(x=3))# -> 8print((5+eq.x+eq.y).fix(x=3))# -> (+ 8 (var y))# 数理計画 (condを満たす中でlossが最小のものを見つける)res=eq.solve(cond=(3*eq.x-eq.y==0),loss=(eq.y-1)**2)print(res)# -> {"x": 0.333, "y": 1}# javascriptコードに変換print(eq.to_js((3+eq.x)**2))# -> 「(出てきた文字列)({x: 1})」をjavascriptで実行すると16を出力する# アルゴリズム的微分 (自動微分)print((eq.x**2).diff("x"))# -> (* 2 (var x))# json形式とequidオブジェクトの相互変換formula=(3+eq.x)**2print(formula.to_json())# -> ["**", ["+", 3, ["var", "x"]], 2]print(eq.from_json('["**", ["+", 3, ["var", "x"]], 2]'))# -> Formula object発展的な利用例# 執筆中 (under_construction)
Package: equilibrator-api
eQuilibrator - a thermodynamics calculator for biochemical reactionsWhat isequilibrator-api?equilibrator-apiis a Python package for obtaining estimates of reactions Gibbs energies.
It is mainly meant for biologists/bioengineers with basic programming skills that
work on metabolism and want to easily add thermodynamic data to their models.The documentation is browseable online atreadthedocs.If your list of reactions is very short, we recommend trying our
website calledeQuilibratorbefore spending
the time necessary for learning how to useequilibrator-api.The main advantages ofequilibrator-apiare:Batch mode: can be used for large reaction datasets (even more than 1000 reactions)Does not require a network connection (except during installation and initialization)Works with standard compound identifiers (such as ChEBI, KEGG, BiGG and MetaNetX) for more than 500,000 compoundsTo access more advanced features, such as adding new compounds that are not
among the 500,000 currently in the MetaNetX database, try using ourequilibrator-assetspackage.Cite usIf you plan to use results fromequilibrator-apiin a scientific publication,
please cite our paper:M. E. Beber, M. G. Gollub, D. Mozaffari, K. M. Shebek, A. I. Flamholz, R. Milo, and E. Noor,eQuilibrator 3.0: a database solution for thermodynamic constant estimationNucleic Acids Research (2021),DOI:10.1093/nar/gkab1106A very simple exampleNote that creating aComponentContributionobject for the first time after
installation, starts an initialization step which downloads ~1.5 GBytes of data
to your computer. It can take more than an hour (depending on the connection speed).
Note that the initialization might not work inside a Jupyter notebook environment -
in that case you should try running it in a standard python shell first and then
run the Jupyter notebook.fromequilibrator_apiimportComponentContributioncc=ComponentContribution()rxn=cc.parse_reaction_formula("kegg:C00002 + kegg:C00001 = kegg:C00008 + kegg:C00009")print(f"ΔG'0 ={cc.standard_dg_prime(rxn)}")
Package: equilibrator-assets
eQuilibrator AssetsA database application for caching data used by eQuilibrator and related projects.
Stored data includes compound names, structures, protonation state information,
reaction and enzyme info, and cross-references to other databases.
The majority of compounds stored in equilibrator-assets are cross-referenced
usingInChIKey.Supported Chemical Databases:MetaNetXKEGGChEBIExternal dependencies:Marvin(by ChemAxon)- get a license and install it on your system. Make sure that the commandcxcalcis in the shell PATH as it is called directly usingsubprocess.run().
Package: equilibrator-cheminfo
Light adapter classes around Open Babel, RDKit, and ChemAxon for the
functionality needed in eQulibrator.InstallPlease note that whileequilibrator-cheminfoas a pure Python package is
operating system independent, the same is not true for the cheminformatics
backends Open Babel, RDkit, or ChemAxon. While both Open Babel and RDKit
nowadays provide Python wheels, we do not test them on all platforms.RDKitpip install equilibrator-cheminfo[rdkit]orOpen Babelpip install equilibrator-cheminfo[openbabel]ChemAxonIf you wish to use ChemAxon, you need to install the software, acquire a
license, and set the environment variableCHEMAXON_HOME.pip install equilibrator-cheminfo[chemaxon]UsageThe main feature in this package is a uniform class interface to molecules from
Open Babel, RDKit, or ChemAxon.  The interface is defined by theequilibrator_cheminfo.AbstractMoleculeabstract class that the three
concrete classes adhere to.fromequilibrator_cheminfo.chemaxonimportChemAxonMoleculefromequilibrator_cheminfo.rdkitimportRDKitMoleculefromequilibrator_cheminfo.openbabelimportOpenBabelMoleculeSome of the supported methods are:mol=OpenBabelMolecule.from_smiles("CC=O")mol.get_charge()# 0mol.get_molecular_formula()# 'C2H4O'mol.get_molecular_mass()# 44.05mol.get_inchi_key()# 'IKHGUXGNUITLKF-UHFFFAOYSA-N'You can also always access the cheminformatics backend object directly and pass
it as an argument to functions directly imported from there.mol.native# <openbabel.pybel.Molecule at 0x7f2a14b36c70>mol.native.calcfp().bits# [330, 624, 671]If there are general methods that you think are missing from the abstract
interface, please say so in anissue.CopyrightCopyright © 2021, Moritz E. Beber.Free software distributed under theApache Software License 2.0.
Package: equilibrator-pathway
equilibrator-pathwayPathway analysis tools based on thermodynamic and kinetic models.
This package can run two different pathway analysis methods:Max-min Driving Force (MDF)1:
objective ranking of pathways by the degree to which their flux is constrained by low thermodynamic driving force.Enzyme Cost Minimization (ECM)2, 3:
estimating the specific cost in enzymes for sustaining a flux, given a kinetic model.InstallationThe easiest way to install equilibrator-pathway is PyPI (and we recommend using a virtual environment):virtualenv -p python3 equilibrator
source equilibrator/bin/activate
pip install equilibrator-pathwayor, if you prefer installing with conda:conda install -c conda-forge equilibrator-pathwayThe followingexample Jupyter notebookcan help you get started.If you only want to try out MDF or ECM without installing anything locally, we have
a simple web interface for you ateQuilibrator4.ReferencesE. Noor, A. Bar-Even, A. Flamholz, E. Reznik, W. Liebermeister, R. Milo (2014),Pathway Thermodynamics Highlights Kinetic Obstaclesin Central Metabolism, PLOS Comp. Biol.,DOI: 10.1371/journal.pcbi.1003483https://www.metabolic-economics.de/enzyme-cost-minimization/E. Noor, A. Flamholz, A. Bar-Even, D. Davidi, R. Milo, W. Liebermeister (2016),The Protein Cost of Metabolic Fluxes: Prediction from Enzymatic Rate Laws and Cost Minimization, PLOS Comp. Biol.,DOI: 10.1371/journal.pcbi.1005167Flamholz, E. Noor, A. Bar-Even, R. Milo (2012)eQuilibrator - the biochemical thermodynamics calculator, Nucleic Acids Res,DOI: 10.1093/nar/gkr874