Saravanan666/pypi-org huggingface dataset:
Package: eqnp
eqnpA simple symbolic derivative calculator and simplification engine.GoalThe goal of eqnp is to be a program which can parse expressions (and maybe
equations at some point) and can manipulate them in various ways. This might
eventually include:SimplifyingDifferentiating (finding derivatives)Integrating (finding integrals)Solving (isolating variables)In addition, this is a project that I'm creating only from my own knowledge. My
goal is to not use any resources relating to the actual function of eqnp.
(Python documentation is acceptable, of course.)Installeqnp is a Python package, so it can be installed in multiple ways.Install directly from repositoryRun the following command to download and install eqnp.$python-mpipinstallgit+https://github.com/kdkasad/eqnpClone repositoryAnother method is to clone the repository first, then install from the local
copy.$gitclonehttps://github.com/kdkasad/eqnp
$cdeqnp
$python-mpipinstall.UsageImport theparse_expression()function fromeqnp.parser:fromeqnp.parserimportparse_expression# orfromeqnpimport*Then runparse_expression(...), passing in a string which is an expression.See belowfor syntax.ExampleIn[1]:importeqnpIn[2]:function=eqnp.parse_expression(' 1 / x^2 ')In[3]:print(function)Out[3]:Division(1,Exponent(x,2))In[4]:derivative=function.differentiate(respectTo='x')In[5]:print(derivative)Out[5]:Division(Subtraction(Multiplication(0,Exponent(x,2)),Multiplication(1,Multiplication(Multiplication(2,Exponent(x,Subtraction(2,1))),1))),Exponent(Exponent(x,2),2))In[6]:derivative=derivative.simplify_fully()In[7]:print(derivative)Out[7]:Division(Subtraction(0,Multiplication(2,x)),Exponent(x,4))# Out[7] is equivalent to '(-2 * x) / (x ^ 4)'Expression string syntaxCurrently, the following operators, functions, and other syntactical structures
are supported (...means an expression):SyntaxMeaning... + ...Addition -- Must have operands on either side... - ...Subtraction -- Must have operands on either side... * ...Multiplication -- Must have operands on either side... / ...Division -- Must have operands on either side(...)Grouping -- used to group operations to enforce a certain order|...|Absolute value -- same asabs(...)abs(...)Absolute valuesin(...)Sine functioncos(...)Cosine functiontan(...)Tangent functioncsc(...)Cosecant functionsec(...)Secant functioncot(...)Cotangent function-nNegation --nmust be a constant numberNote: The absolute value bars do not have to be escaped. They're only that way in the markdown file because the table syntax uses pipe characters.To doThere are still a lot of features that I want to implement. Some are listed as# TODO:comments in the source code, but I'll put a list here too:Pull all constants out of nested multiplication expressionsFlip negative exponents in fractions to opposite sideAdd inverse trigonometric functionsImplement integration
Package: eqone
world-earthquake-one-monthThis program shows the number of earthquakes occurred around the world during a one-month period on a map.Using a USGS dataset, 'eqone' can visualize where earthquakes occurs.The USGS dataset is downloadable from:https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/all_month.csvThis is sample of earthquakes around Japan.How to install eqone on Linux, MacOS, or WSL on WindowsYou may need folium library.$pip install folium$pip install eqoneHow to run eqoneEqone program allows user to specify up to arthquake scale(1~) to plot on world map.$eqone 4If you don't specify a number, program shows where earthquakes with intensity 5 upper are around the world.$eqone
Package: eqparse
eqparsePython processing for eQUEST SIM, HSR, and INP filesGetting StartedThese instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.InstallingUse pip to install this package (you can always clone and manually import it as well):pip install eqparseto Load a SIM file, use LoadSim and do not use a file extension:'''
mysim = eq.LoadSim('C:/myinputfile')
'''This allows access to 'sim', 'hsr', and 'inp' modules (inp module is currently a work in progress. Support will be added to handle running simulations and creating ECMs.Most reports can be accessed like this, returning Pandas Dataframes:mysim.sim.bepu()
mysim.sim.ssa()HSR files can be accessed like this:df = mysim.hsr.dfThere are also some plotting functions, using Plotly, optimized for eQUEST HSR files:mysim.hsr.plot.line(df)
mysim.hsr.plot.heatmap(df, 0) # < 0 refers to column numberAuthorsMichael Sweeney (github.com/michaelsweeney)LicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for detailsAcknowledgmentsThanks to Santosh Philip and his excellent Eppy project for inspiration!
Package: eqsolvcarlover101
EqsolveA mathematical Python package by Zakkai ThomasOld Package (eqsolvcarlover101)WebsiteBug ReportsEmailPyPI PageDocumentationThis is a project that solves mathematic equations for you!Functions:Quadraticeqsolve.quadsolve()To type a square in python, you need to use a carrot^or two astrix **. (Ex. 2x^2 -5x +4)Slope Intercepteqsolve.slopeint()Put in two points, and output an equation in slope-intercept form.Midpointeqsolve.midpoint()Put in two points and output the midpoint.Perpendicular Lineseqsolve.perpint()Put in the slope of a line, and the intersection point, and get the slope-intercept equation of the perpendicular line.Similar Shapes Checkeqsolve.issim()Takes the lengths of the sides of one shape and the corresponding side lengths of the sides of a second shape.
If the shapes are similar, it will return the scale factor.Missing Right Triangle Lengthseqsolve.findright()Finds the missing length of a right triangle.Compounding Intersesteqsolve.intcompound(p,r,n,t)Calculates the amount of money present/money owed after a number of years using the provided interest rate and the number of times it is compounded yearly.Continuously Compounding Interesteqsolve.contcompound(p,r,t)Calculates the amount of money present/money owed after a number of years if the interest provided is compounded continuously.Other Commands:Command Listeqsolve.commands()Helpeqsolve.help()Version Info:V0 - V1.5.2:To use these older versions, go toHelpful Infodown below.V1.6:Addedeqsolve.intcompound()andeqsolve.expcompound()functions.Updated all function descriptions so they work with python's defaulthelp(function).Updated all functions to move away frominput()towards proper function notation.UpdatedREADME.mdso it reflects current statistics and project version info.Helpful Info:For previous versions and version error info, refer togithub (ver: oldest - current)orold pypi (ver: oldest - 1.5.1.0).Thanks to all for using my work!
Package: eqsolve
EqsolveA mathematical Python package by Zakkai ThomasContinuation (eqsolvcarlover101 - Deprecated)WebsiteBug ReportsEmailPyPI PageDocumentationThis is a project that solves mathematic equations for you!How to Install:Make sure you have Python installed by typingpython3in the command prompt.If not, go topython.orgto get the latest release.Enterpip install eqsolve.Useimport eqsolvein your code to begin using the package.Functions:Quadraticeqsolve.quadsolve(eq)To type a square in python, you need to use a carrot^or two astrix **. (Ex. 2x^2 -5x +4)Slope Intercepteqsolve.slopeint(x1, y1, x2, y2)Put in two points, and output an equation in slope-intercept form.Midpointeqsolve.midpoint(x1, y1, x2, y2)Put in two points and output the midpoint.Perpendicular Lineseqsolve.perpint(eq, intsec)Put in the slope of a line, and the intersection point, and get the slope-intercept equation of the perpendicular line.Similar Shapes Checkeqsolve.issim(shape1, shape2)Takes the lengths of the sides of one shape and the corresponding side lengths of the sides of a second shape.
If the shapes are similar, it will return the scale factor.Missing Right Triangle Lengthseqsolve.findright(missing, s1, s2)Finds the missing length of a right triangle.Compounding Intersesteqsolve.intcompound(p, r, n, t)Calculates the amount of money present/money owed after a number of years using the provided interest rate and the number of times it is compounded yearly.Continuously Compounding Interesteqsolve.contcompound(p, r, t)Calculates the amount of money present/money owed after a number of years if the interest provided is compounded continuously.Other Commands:Command Listeqsolve.commands()Helpeqsolve.help()Version Info:Deprecated:V0 - V1.5.2:To use these older versions, go toHelpful Infodown below.Current:V1.0.0:Addedeqsolve.intcompound(p,r,n,t)andeqsolve.contcompound(p,r,t)functions.Updated all function descriptions so they work with python's defaulthelp(...)function.Updated all functions to move away frominput()towards proper function notation.UpdatedREADME.mdso it reflects current statistics and project version info.V1.0.1:Fixed some errors with theREADME.mdfile.Helpful Info:For previous versions and version error info, refer togithub (ver: oldest - current)orold pypi (ver: oldest - 1.5.1.0).Thanks for using my work!
Package: eqsormo
Eqsormo: Equilibrium sorting models in PythonEqsormo implements equilibrium sorting models in Python. Equilibrium sorting models are models that simulate how households will re-sort across a metropolitan region in response to a change in policy or amenities. They allow evaluating non-marginal effects of policy changes---i.e. not only how the policies will affect the utility of people in the places they currently live, but how they will affect utility after households have re-sorted across the region in response to amenity and price changes.It currently supports discrete-choice-based sorting models, specifically of the type implemented by Tra (2007, 2010, 2013), wherein the price enters the first stage of the model as a nonlinear budget term. This is in contrast to much of the literature where a constant price coefficient is estimated in the second stage. The advantage of the Tra approach is that by including price in the first stage, where there are also fixed effects for all housing types, there is less concern about unobserved housing attributes being correlated with price.Eqsormo is currently alpha-stage software. Any results should be carefully evaluated, and issues reported tothe issue tracker. API documentationis available on readthedocs; additional documentation is forthcoming.Eqsormo can be installed withpip:pip install eqsormoReferencesTra CI (2007) Evaluating the equilibrium welfare impacts of the 1990 Clean Air Act amendments in the Los Angeles area. Doctoral dissertation. University of Maryland, College Park, College Park, MD, USA. Available at:http://hdl.handle.net/1903/7236.Tra CI (2010) A discrete choice equilibrium approach to valuing large environmental changes. Journal of Public Economics 94(1): 183–196. DOI: 10.1016/j.jpubeco.2009.10.006.Tra CI (2013) Measuring the General Equilibrium Benefits of Air Quality Regulation in Small Urban Areas. Land Economics 89(2): 291–307.
Package: eqsql
EMEWS QUEUES in SQL for PythonThe eqsql package provies an API for HPC workflows to submit tasks (such as
simulation model runs) to a queue implemented in a database. eqsql worker pools pop tasks
off this queue for evaluation, and push the results back to a database input queue.
The tasks can be provided by a Python or R language model exploration (ME) algorithm.A task is submitted with the following arguments: an experiment id; the task work type; the task payload; an optional
priority that defaults to 0; and an optional metadata tag string. The payload contains sufficient information for a
worker pool to execute the task and is typically a JSON formatted string, either a JSON dictionary or in less complex
cases a simple JSON list. On submission, the API creates a unique task identifier (an integer) for the task and
inserts that identifier, the experiment identifier, the work type, and the payload into the EMEWS DB tasks table,
together with a task creation timestamp. That task identifier, priority and work type are then inserted into the EMEWS
DB output queue table.API docs arehere
Package: eqt
eqt: Qt ElementsA number of templates and tools to develop Qt GUI's with Python effectively.Developing GUIs I often find myself creating forms to pass some input and also
running some task asynchronously so that the interface is still responsive.This little package tries to address both recurring requirements.UIFormWidget, a class to help creating Qt forms
programmatically, useable inQDockWidgetsandQWidgetFormDialog, aQDialogwith a form inside with OK and Cancel buttonWorker, a class that defines aQRunnableto
handle worker thread setup, signals and wrap upInstallationYou may install viapiporcondapython-mpipinstalleqt# orcondainstalleqt-cpaskinoExamplesIn theexampledirectory there is an example on how to launch aQDialogwith a form inside usingeqt'sQWidgetorFormDialog.Running asynchronous tasksTo run a function in a separate thread we use aWorkerwhich is a subclass of aQRunnable.For theWorkerto work one needs to define:the function that does what you needOptional callback methods to get the status of the thread by means ofQtCore.QSignalsOninitialisationof theWorkerthe user needs to pass the function that has to run in the thread, i.e.fnbelow, and additional optional positional and keyword arguments, which will be passed on to the actual function that is run in theQRunnable.classWorker(QtCore.QRunnable):def__init__(self,fn,*args,**kwargs):self.fn=fnself.args=argsself.kwargs=kwargsself.signals=WorkerSignals()In practice the user will need to pass to theWorkeras many parameters as there are listed in thefunctionto be run.result=self.fn(*self.args,**self.kwargs)ButWorkerwilladdto the**kwargsthe followingQSignal.# Add progress callback to kwargsself.kwargs['progress_callback']=self.signals.progressself.kwargs['message_callback']=self.signals.messageself.kwargs['status_callback']=self.signals.statusTherefore it is advisable to always have**kwargsin the functionfnsignature so that you can access theQSignaland emit the signal required. For instance one could emit a progress by:deffn(num_iter,**kwargs):progress_callback=kwargs.get('progress_callback',None)foriinrange(num_iter):do_somethingifprogress_callbackisnotNone:progress_callback.emit(i)Passing a signal to a WorkerThis is done just after one has defined theWorker:defhandle_progress(num_iter):# do something with the progressprint("Current progress is ",num_iter)worker=Worker(fn,10)worker.signals.progress.connect(handle_progress)So, each timefncomes toprogress_callback.emit( i )the functionhandle_progresswill be called with the parameteriof itsforloop.Signals availableThe signals that are available in theWorkerclass are defined inWorkerSignaland are the following. Below you can also see the type of data that each signal can emit.finished=QtCore.Signal()error=QtCore.Signal(tuple)result=QtCore.Signal(object)progress=QtCore.Signal(int)message=QtCore.Signal(str)status=QtCore.Signal(tuple)Read more onQt signals and slotsand on how to use them inpyside2.
Package: equacao-segundo-grau
equacao_segundo_grauDescription.
The package equacao_segundo_grau is used to:
- Calcular o resultado de uma equaÃ§Ã£o do segundo grauInstallationUse the package managerpipto install equacao_segundo_graupipinstallequacao_segundo_grauUsagefromequacao_segundo_grauimportbaskarabaskara.calcular(a,b,c)AuthorGenildoLicenseMIT
Package: equake
equakeequakeis a Python library to intuitively access and handle earthquake data.This library retrieves earthquake data from theUSGS earthquake databaseand allows
you to apply various filters to customise your search.BenefitsThis library is a convenient wrapper of the USGS Earthquake API, meaning you
can communicate with its key functionality in an object-oriented, Pythonic way.Plenty of very thoroughvalidationis provided to ensure robustness.Theabstractionmeans you can focus on the more important details of your
program rather than actually preparing the query string to send a request, for example.Bothkilometres and milesare supported.The code has been rigorouslytestedfor Python 3.7 and above, and major bugs have been fixed.The library has beendocumentedfully, with the documentation inside the code.There areno third-party dependenciesat all, not even the widely used requests library.
This makes installation of the library very easy and error-free.InstallationPip can be used to easily install this library.pip install equakeNote: This library supportsPython 3.7and above. Slightly older versions might work, but
they have not been tested, so this is not guaranteed. Python 2 is incompatible.Getting StartedFor full details, consult the code documentation.The main modules available arefiltandquakefilthandles the filter functionality, allowing you to create filters to search for earthquakes.quakeallows you to count/get earthquakes from the API, and also holds the Earthquake class.Create a FilterTo search for earthquakes, you first must create a filter in thefiltmodule.The overarching filter object isEarthquakeFilter, which consists of sub-filters.TimeFilter- filter earthquakes bytimeof the event, and time updated.LocationFilter- filter earthquakes bylocation(Rectangle/Circle).DepthFilter- filter earthquakes bydepth.MagnitudeFilter- filter earthquakes bymagnitude.IntensityFilter- filter earthquakes bymaximum intensity.PAGER Level - filter earthquakes byseverityof damage.Minimum reports - filter earthquakes byminimum number of reportsfrom the public.For example, to create a filter for earthquakes with a depth between 100 and 200 kilometres,
a magnitude between 5 and 7, a PAGER level of 'orange', and 100 minimum reports, the
following code would be used:from equake import filt

earthquake_filter = filt.EarthquakeFilter(
    filt.DepthFilter(100, 200),
    filt.MagnitudeFilter(5, 7),
    pager_level="orange",
    min_reports=100
)For more complex use cases, see the examples folder and the documentation.Count or Get EarthquakesOnce you have a filter, you can count/get earthquakes by using thequakemodule.To count/get the number of earthquakes in a simple way, this is the code you would use.from equake import filt, quake

earthquake_filter = filt.EarthquakeFilter() # Just for example purposes.
earthquake_count = quake.count(earthquake_filter)
earthquakes = quake.get(earthquake_filter)Again, for more complex use cases, see the examples folder and the documentation.
Package: equality
This package is pre-alpha. The API may change.When comparing structures like this dict:assert actual == {
    'id': 123,
    'created': "2017-11-10T23:59:58",
    'field1': 1,
    ...
}This fails because ‘id’ and ‘created’ are different every test run.
Fix this using:assert actual == {
    'id': AnyInt(),
    'created': AnyTimestamp(datetime.now(), seconds=3),
    'field1': 1,
    ...
}AnyIntcompares equal to any integer.Timestampcompares equal
to string timestamps that are within the given number of seconds.CompatibilityPython 3.6 and 2.7.Known ProblemsIf timestamps are generated locally, in-process, then it’s easier to
patch out datetime.now(). But if this is an end-to-end test that hits
other services, that might not be an option. That’s when I find AnyTimestamp
useful.This is all hot off the press, so is doubtless full of mistakes.AlternativesThis doubtless duplicates better work elsewhere. In particular the package
‘equals’ looks very nice, but it’s missing the central feature of ‘equality’,
approximate comparison of string timestamps.ContactUsers’ downloads & documentation:http://pypi.python.org/pypi/equality/Contributors’ souce & issues:https://github.com/tartley/equality/Author: Jonathan Hartley, email: tartley at domain tartley.com, Twitter: @tartley.
Package: equality-check
equality-checkfrom equality_check import EQUALITY

EQ = EQUALITY (
	FOLDER ("STATUS_FOLDERS/1/EQ_1"),
	FOLDER ("STATUS_FOLDERS/1/EQ_2")
)If the folders are equal,
then these assertions should pass.assert (len (EQ ['1']) == 0)
assert (len (EQ ['2']) == 0)Otherwise:#
# UNIQUE TO 1
# UNIQUE TO 2
#
#	"f" 	UNIQUE FILE
#	"fc" 	UNIQUE FILE CONTENTS
#
#	"d"		UNIQUE DIRECTORY
#
#	"s"		UNIQUE SYMLINK
#	"sc"	UNIQUE SYMLINK CONTENTS
#
EQ = {
	1: {
		"asdf/asdf": "f",
		"asdf/asd": "d",
		"asdff/asd": "?"
	},
	2: {}
}
Package: equal-odds
equal-oddsFast postprocessing of any score-based predictor to meet fairness criteria.Theequal-oddspackage can achieve strict or relaxed fairness constraint fulfillment,
which can be useful to compare ML models at equal fairness levels.InstallingInstall package fromPyPI:pip install equal-oddsOr, for development, you can clone the repo and install from local sources:git clone https://github.com/AndreFCruz/equal-odds.git
pip install ./equal-oddsGetting started# Given any trained model that outputs real-valued scoresfair_clf=RelaxedEqualOdds(predictor=lambdaX:model.predict_proba(X)[:,-1],# for sklearn API# predictor=model,  # use this for a callable modeltolerance=0.05,# fairness constraint tolerance)# Fit the fairness adjustment on some data# This will find the optimal _fair classifier_fair_clf.fit(X=X,y=y,group=group)# Now you can use `fair_clf` as any other classifier# You have to provide group information to compute fair predictionsy_pred_test=fair_clf(X=X_test,group=group_test)How it worksGiven a callable score-based predictor (i.e.,y_pred = predictor(X)), and some(X, Y, S)data to fit,RelaxedEqualOddswill:Compute group-specific ROC curves and their convex hulls;Compute ther-relaxed optimal solution for the chosen fairness criterion (usingcvxpy);Find the set of group-specific binary classifiers that match the optimal solution found.each group-specific classifier is made up of (possibly randomized) group-specific thresholds over the given predictor;if a group's ROC point is in the interior of its ROC curve, partial randomization of its predictions may be necessary.Implementation road-mapWe welcome community contributions forcvxpyimplementations of other fairness constraints.Currently implemented fairness constraints:equality of odds(Hardt et al., 2016);i.e., equal group-specific TPR and FPR;