Saravanan666/pypi-org huggingface dataset:
Package: eadred
eadred is a Django-app for generating sample data.Why? Here are the use cases we’re solving:Use Case 1: ContributorsMildred wants to contribute to your Django project, but your
Django project is non-trivial and out of the box it’s not very
usable because it needs data.However, you’re using eadred, so in your setup documentation, you
have a one-liner that generates all the sample data Mildred needs
to start hacking immediately.Use Case 2: BootstrappingWillhelm wants to set up an instance of your Django project. It
requires certain non-trivial initial data to be in place before it
works.However, you’re using eadred, so in your setup documentation, you
have a one-liner that generates all the initial data needed.Use Case 3: Large amounts of random dataPhylida is a hacker on your Django project and trying to fix bugs
with a section of code that requires large amounts of data—say
it’s one of those things that graphs data sets or something.You’re using eadred, so it’s a one-liner to generate a large set
of initial data.“Wait, use cases 1 and 2 are easily solved with Django and fixtures!”I think fixtures are good for specific use cases where your models
aren’t changing and you have some contributor who likes entering in
data to build the initial fixtures. Having said that, I don’t use
fixtures.eadred allows you to programmatically generate the data using model
makers, factories, fixtures, random seeds—whatever your needs are.Additionally, eadred provides library functions to make generating
data easier.Project detailsCode:http://github.com/willkg/django-eadredDocumentation:http://django-eadred.rtfd.org/Issue tracker:https://github.com/willkg/django-eadred/issuesLicense:BSD 3-clause; see LICENSE file
Package: eadtoolbox
26th September 2013 (2013-09-26)ContentsDescriptionAuthor(s)Latest VersionDocumentationRequirements / DependenciesInstallationExamplesCommand-lineWeb-based GUIPython APIBugs, Feature requests etc.Copyright & LicensingDescriptionThe EAD Toolbox provides a number of tools for working withEncoded Archival
Description(EAD) XML documents.Current capabilities include validation to the DTD, cross-walk to other
metadata schemas, and extraction and display of subjects and named entities.It also includes a web-based user interface for validating, cross-walking and
extracting data from your own EAD files, provided via aPythonWSGIcompliant
web applicationAuthor(s)John Harrison <john.harrison@liv.ac.uk> at theUniversity of LiverpoolLatest VersionLatest version is available from PyPI:https://pypi.python.org/pypi/eadtoolboxSource code is under version control and available from:https://github.com/bloomonkey/ead-toolboxDocumentationAll executable commands are self documenting, i.e. you can get help on how to
use them with the-hor--helpoption. e.g.ead-validate --helpAt this time the only additional documentation that exists can be found in this
README file!Requirements / DependenciesPython>= 2.6lxmlInstallationUserspip install eadtoolboxDevelopersI recommend that you usevirtualenvto isolate your development environment
from systemPythonand any packages that may be installed there.InGitHub, fork the repositoryClone your fork:git clone git@github.com:<username>/ead-toolbox.gitInstall dependencies:pip install -r requirements.txtInstall in develop / editable mode:pip install -e .ExamplesCommand-lineEAD ValidationTo validate using the EAD 2002 DTD:ead-validate FILE [FILE [...]]The EAD Toolbox currently only supports validation using the EAD 2002 DTD. I
hope to add validation using the XSD schema in the near future.Web-based GUIThe features availble though the commnad-line can also be accessed, and made
available to other users over a local network or the web, through the EAD
Sandbox application. Run the application using the following command:ead-sandbox [--hostname=HOSTNAME] [--port=PORT]This will start a quick demonstration WSGI server (not recommended for
production use) to serve the application, and also open the application in a
new browser window/tab if possible. If you don’t want the browser window/tab,
you can launch the application with the--no-browseroption:ead-sandbox --no-browser [--hostname=HOSTNAME] [--port=PORT]Python APIEAD Validationfromlxmlimportetreefromeadtoolbox.validateimportEAD2002DTDValidatoread=etree.parse(open('eadfile.xml','r'))validator=EAD2002DTDValidator()ifvalidator.validate(ead):print"VALID"else:print"INVALID"foreinvalidator.errors:printstr(e)Bugs, Feature requests etc.Bug reports and feature requests can be submitted to the GitHub issue tracker:http://github.com/bloomonkey/ead-toolbox/issuesIf you’d like to contribute code, patches etc. please email the author, or
submit a pull request on GitHub.Copyright & LicensingCopyright (c) University of Liverpool, 2010-2013See LICENSE.rst for licensing details.
Package: eae
# eAE for pythonPython pip package to interact with the eAE.# InstalleAE has two pre-requisites:  requests and requests_toolbelt.The simplest way to install eAE is to use the **Py**thon **P**ackage **I**ndex (PyPI):```bash# For a first installationpip install  eAE# For upgrading to the latest releasepip install --upgrade eAE```## *Example of an eAE script to submit a job*```python# We import the eAE packagefrom eAE import eAEdirectory = ''# We create the connection to the backendeae = eAE.eAE("admin", "admin", "127.0.0.1")# We list the jobs with their associated parametersparameters = ["first_analysis_type 0 1"]# We list the required files for the analysis to be sent to the back-enddata_files = ["job.py", "faust.txt"]# We submit a jobanswer = eae.submit_jobs("python2", "job.py", parameters, data_files)# We check that the submission has been successfulprint(answer)"""answer = { "status": "OK","jobID": "5c47530c6ad68800121c72be","jobPosition": 1,"carriers": ["carrier:3000"]}"""# We check the current status of the jobstatus = eae.get_job(answer['jobID'])print(status)"""status = {'status': ['eae_job_completed', 'eae_job_done', 'eae_job_running', 'eae_job_scheduled', 'eae_job_queued', 'eae_job_transferring_data', 'eae_job_created'],'startDate': '2018-01-22T17:29:53.983Z','main': 'job.py','endDate': '2018-01-22T17:30:14.077Z','executorPort': '9000','executorIP': '127.0.0.1','stdout': 'Hello World !\n','output': ['test_out.txt'],'params': ['first_analysis_type 0 1'],'statusLock': False,'stderr': '','requester': 'admin','swiftData': {},'input': ['job.py', 'faust.txt'],'message': {'context': 'success'},'_id': '5c47530c6ad68800121c72be','type': 'python2','exitCode': 0}"""# We download the resultsresult = eae.get_job_result(directory, answer['jobID'])# We have a look at the computed result"""Hello World !first_analysis_typeThe Project Gutenberg EBook of Faust, by Johann Wolfgang Von GoetheThis eBook is for the use of anyone anywhere at no cost and withalmost no restrictions whatsoever.  You may copy it, give it away orre-use it under the terms of the Project Gutenberg License includedwith this eBook or online at www.gutenberg.net""""""```
Package: eaf
EAFEnterprise Application Framework.This framework contains all the pieces you need to create feature-rich
enterprise-grade distributed and distributedn’t applications.Also means Extensible As Fuck.Requirements>=python-3.7>=tornado-6.0Installation$pipinstalleafDevelopmentInstallation$poetryinstallTesting$poetryrunpytest-s-vtests/# run all tests$poetryrunpytest--cov=eaf-s-vtests/# run all tests with coverage$poetryrunblackeaf/tests/# autoformat code$# run type checking$poetryrunpytest--mypy--mypy-ignore-missing-imports-s-veaf/tests/$# run code linting$poetryrunpytest--pylint-s-veaf/tests/DocumentationTo be added
Package: eaftest
Usage: eaftest <fileA> <fileB>eaftest -i <indicators_file><fileA> and <fileB>: non-dominated sets of two-dimensionalobjective vectors<indicators_file>: point indicator file from the joint-eafcomputationCurrent limitations: second-order onlymaximum executions: 64 (32 + 32)
permutations: 10240 (fixed)
significance level: 0.05 (fixed)
Package: eagerpy
EagerPy: Writing Code That Works Natively with PyTorch, TensorFlow, JAX, and NumPyEagerPyis aPython frameworkthat lets you write code that automatically works natively withPyTorch,TensorFlow,JAX, andNumPy. EagerPy isalso great when you work with just one frameworkbut prefer a clean and consistent API that is fully chainable, provides extensive type annotions and lets you write beautiful code.🔥 Design goalsNative Performance: EagerPy operations get directly translated into the corresponding native operations.Fully Chainable: All functionality is available as methods on the tensor objects and as EagerPy functions.Type Checking: Catch bugs before running your code thanks to EagerPy’s extensive type annotations.📖 DocumentationLearn more about EagerPy in thedocumentation.🚀 QuickstartpipinstalleagerpyEagerPy requires Python 3.6 or newer. Besides that, all essential dependencies are automatically installed. To use it with PyTorch, TensorFlow, JAX, or NumPy, the respective framework needs to be installed separately. These frameworks are not declared as dependencies because not everyone wants to use and thus install all of them and because some of these packages have different builds for different architectures andCUDAversions.🎉 Exampleimporttorchx=torch.tensor([1.,2.,3.,4.,5.,6.])importtensorflowastfx=tf.constant([1.,2.,3.,4.,5.,6.])importjax.numpyasnpx=np.array([1.,2.,3.,4.,5.,6.])importnumpyasnpx=np.array([1.,2.,3.,4.,5.,6.])# No matter which framwork you use, you can use the same codeimporteagerpyasep# Just wrap a native tensor using EagerPyx=ep.astensor(x)# All of EagerPy's functionality is available as methodsx=x.reshape((2,3))x.flatten(start=1).square().sum(axis=-1).sqrt()# or just: x.flatten(1).norms.l2()# and as functions (yes, gradients are also supported!)loss,grad=ep.value_and_grad(loss_fn,x)ep.clip(x+eps*grad,0,1)# You can even write functions that work transparently with# Pytorch tensors, TensorFlow tensors, JAX arrays, NumPy arraysdefmy_universal_function(a,b,c):# Convert all inputs to EagerPy tensorsa,b,c=ep.astensors(a,b,c)# performs some computationsresult=(a+b*c).square()# and return a native tensorreturnresult.raw🗺 Use casesFoolbox Native, the latest version of
Foolbox, a popular adversarial attacks library, has been rewritten from scratch
using EagerPy instead of NumPy to achieve native performance on models
developed in PyTorch, TensorFlow and JAX, all with one code base.EagerPy is also used by other frameworks to reduce code duplication (e.g.GUDHI) or tocompare the performance of different frameworks.📄 CitationIf you use EagerPy, please cite ourpaperusing the this BibTex entry:@article{rauber2020eagerpy,
  title={{EagerPy}: Writing Code That Works Natively with {PyTorch}, {TensorFlow}, {JAX}, and {NumPy}},
  author={Rauber, Jonas and Bethge, Matthias and Brendel, Wieland},
  journal={arXiv preprint arXiv:2008.04175},
  year={2020},
  url={https://eagerpy.jonasrauber.de},
}🐍 CompatibilityWe currently test with the following versions:PyTorch 1.4.0TensorFlow 2.1.0JAX 0.1.57NumPy 1.18.1
Package: eagle
Eagle is an abstraction layer atop Graphical Toolkits focused on
making simple applications easy to build while powerful in features.With Eagle you have many facilities to build application that needs
just some buttons, user input and a canvas to draw.Canvas is really simple, what makes Eagle a great solution to
Computer Graphics and Image Processing software, the primary focus
of this library.User input widgets are persistent, you just need to mark them
“persistent” or put them in the preferences area.Eagle is not meant to be another Graphical Toolkit, you already
have a bunch of them, like Qt, Gtk, wxWidgets (to name just a few).
It’s focused on applications that have few windows, with buttons,
simple user input and canvas. Widgets are laid out automatically
in 5 areas: left, right, top, bottom and center.It provides useful widgets like: Color selector, Font selector,
Quit button, Preferences button and bialog, About dialog and Help
dialog.
Package: eagle100
eagle100Rainforest EAGLE 100 client (forked from uEagle)Basic, lightweight client for accessing the local REST API of Rainforest Automation's EAGLE 100 device.Based off a micropython module, this uses minimal local resources.This has been forked fromtoddsay/uEagleto get his fix tojcalber/uEaglepublished to PyPi.
Example use:fromeagle100importEagleCLOUD_ID='012abc'INSTALL_CODE='0123456789abcdef'ADDRESS='192.168.1.123'#optional if your platform can resove mDNSeagle=Eagle(CLOUD_ID,INSTALL_CODE,address=ADDRESS)demand_data=eagle.get_instantaneous_demand()print('Current Usage:{:.3f}kW'.format(demand_data['Demand']))
Package: eagle200-reader
Gather data locally from a Rainforest Eagle-200 device.Eagle200 Reader provides the ability to retrieve data from a
[Rainforest Eagle-200](https://rainforestautomation.com/rfa-z114-eagle-200/) device
from the local network, rather than from the cloud.  Three arguments are needed to
connect to the device; IP Address, Cloud ID (aka Username), and Install Code (aka Password).Typical usage often looks like this:#!/usr/bin/env python

import eagle200_reader

IP_ADDR = 1.1.1.1
CLOUD_ID = '0012ef'
INSTALL_CODE = '4234343242343242'

device = eagle200_reader.EagleReader(IP_ADDR, CLOUD_ID, INSTALL_CODE)

print("Instantanous Demand:     {} kW".format(device.instantanous_demand()))
print("Total Energy Delivered:  {} kWh".format(device.summation_delivered()))
print("Total Energy Received:   {} kWh".format(device.summation_received()))
print("Total Net Energy:        {} kWh".format(device.summation_total()))
Package: eagle2svg
eagle2svgEagle cad to SVG converter.eagle2svg helps social coding based circuit development.
It is easy to upload and embed drawings to the pull-request comment
by usinggh-pr-comment.Install$ pip install --user eagle2svgUsageeagle2svg eagle-file [sheet# [layer# [layer# ...]]]sheet#: schematic sheet index (for board layout rendering, set 0)default:0layer#: visible layer indexdefault:1 16 17 18 19 20 21 22 25 26 29 30 91 92 93 94 95 96 97 104e.g. board top layers:1 20 17 18 21 25 19e.g. board bottom layers:16 20 17 18 22 26 19LicenseThis package is released under BSD license.
Package: eagleeyeair
Eagle Eye AirThis package provides Python SDK for accessing APIs provided bythe eagleeye platform.Setup environmentTo use the package, we need to first configure os with following variables:EES_AUTH_CLIENT_ID: this is youreagleeyeclient idEES_AUTH_CLIENT_SECRET: youreagleeyesecret, will be used for payload encryptionEES_API_PREFIX: api version to use, default to/2.0EES_POS_API_HOST: hostname of the POS API serverEES_WALLET_API_HOST: hostname of the Wallet API serverEES_RESOURCES_API_HOST: hostname of the Resources API serverInvoke APIWith environment setup, you can invoke the APIs as shown below:importjsonfromeagleeyeairimportresourcesprint(json.dumps(resources.list_campaigns(limit=5),indent=2))
Package: eagleeye_te
EagleEye TE(4)InstallationInstall external dependencies:sudoapt-getinstallchromium-browserpython-pipredis-serverunzip xvfbInstall chromedriver:curlhttps://chromedriver.googlecode.com/files/chromedriver_linux64_2.2.zip| funzip > chromedriverchmod +x chromedriversudo mv chromedriver /usr/bin/chromedriverInstall eagleeye itself:sudo pip install eagleeye_teUsageStart some eagleeye workers:tasa eagleeye:Screenshot &mkdir-pouttasa eagleeye:Writer &And feed the system a job:eagleeyehttp://google.com
Package: eagle-gtk
Eagle is an abstraction layer atop Graphical Toolkits focused on
making simple applications easy to build while powerful in features.With Eagle you have many facilities to build application that needs
just some buttons, user input and a canvas to draw.Canvas is really simple, what makes Eagle a great solution to
Computer Graphics and Image Processing software, the primary focus
of this library.User input widgets are persistent, you just need to mark them
“persistent” or put them in the preferences area.Eagle is not meant to be another Graphical Toolkit, you already
have a bunch of them, like Qt, Gtk, wxWidgets (to name just a few).
It’s focused on applications that have few windows, with buttons,
simple user input and canvas. Widgets are laid out automatically
in 5 areas: left, right, top, bottom and center.It provides useful widgets like: Color selector, Font selector,
Quit button, Preferences button and bialog, About dialog and Help
dialog.
Package: eagle-kaist
Stock Prediction PipelineStep 1 - Build Stock DatabaseStep 2 - Normalize Stock DataStep 3 - Build Features and VisualizationStep 3 - Build Prediction ModelsMetricsThe metrics of prediction models should be based on profits and loss they give.Profit vs. lossBacktestStock dataCollected stock data include following values:CloseOpenHighLowVolumnChangePercentage ChangeDerivative values:ReturnAlphaVolatilityAlpha*SharpeBusiness TaxonomyThere is a large number of companies in stock market. It is crucial to take a look over their financial reports and market indices to have a correct view of the companies' business status.In this section, we want to build several main groups of companies. Each group represents the area of business that the company is taking part in. In addition, we target to give a common credit score for each group, and also the rank of company in that group.Input:Stock indicesCompanies financial reportsOutput:We want to have a comparison between the areas and give the advice on which business we should invest in.We want to have a table that ranks companies and shows their potential in market.Installation:condacreate--nameeaglepython=3.7
condaactivateeagle
pipinstall-rrequirements.txt
Package: eagle-maemo
Eagle is an abstraction layer atop Graphical Toolkits focused on
making simple applications easy to build while powerful in features.With Eagle you have many facilities to build application that needs
just some buttons, user input and a canvas to draw.Canvas is really simple, what makes Eagle a great solution to
Computer Graphics and Image Processing software, the primary focus
of this library.User input widgets are persistent, you just need to mark them
“persistent” or put them in the preferences area.Eagle is not meant to be another Graphical Toolkit, you already
have a bunch of them, like Qt, Gtk, wxWidgets (to name just a few).
It’s focused on applications that have few windows, with buttons,
simple user input and canvas. Widgets are laid out automatically
in 5 areas: left, right, top, bottom and center.It provides useful widgets like: Color selector, Font selector,
Quit button, Preferences button and bialog, About dialog and Help
dialog.
Package: eaglepy
A Python package for creating, modifying, and writing Cadsoft EAGLE filesDependenciesFor writing EAGLE files, the non-standard Python package [lxml] is required. This can be installed using pip:pip install lxmlIf lxml is not available (for example, with IronPython), it is still possible to read EAGLE files, but it is not possible to write EAGLE files.InstallationThe package can be installed by cloning into the repository and then invokingsetup.pyfrom the source directory:python setup.py installThis package is also avilable on the [Python Package Index][ppi], and can be installed using pip:pip install eaglepyBasic UsageAs a basic example, the following will create (and save) an empty schematic:from eaglepy import default_layers, eagleschematic_path = ‘schematic.sch’schematic = eagle.Schematic(sheets = [eagle.Sheet()])drawing = eagle.Drawing(grid = eagle.Grid(),layers = default_layers.get_layers(),
document = schematic)e = eagle.Eagle(drawing)e.save(schematic_path)DocumentationMore extensive documentation is available [here][doc].There are a number of example modules provided in theexamples/directory.[lxml]:http://lxml.de/[ppi]:https://pypi.python.org/pypi/eaglepy[doc]:http://richard-h-clark.com/projects/eaglepy
Package: eagleview
ongoingv1.0|v1.1(current)v0.1|v0.2Colab Preview for CodeWebsite for eaglevieweagleviewA package for greatly increasing the visualisation of datasets, in minimal lines of code.UsageIt is advised to use `Method 1`, as the github repository is updated from time to time, it may occour that new changes are not still updated.Method 1Clone the repository:!gitclonehttps://github.com/hexronuspi/eagleviewUpload the folder containing your images. If they are in a zip or any other file, extract them first.Navigate to the cloned repository:%cd eagleviewInstall the package:!pip install .Use the package in your Python code:Method2using pip install!pipinstalleagleviewimporteagleviewInput:#v0.xfromeagleview.figshowimportImageMatriximage_display=ImageMatrix('/content/path_to_folder_containing_images')#v1.xfromeagleview.figshowimportImageMatrixim=ImageMatrix('/content/path_to_folder_containing_images','/content/path_to_file_containing_label.csv')#only .csv extensionOutput:#v1.0im.rand((a,b)).display_image(# a,b is the size of matrixcheck_col='col_name',# replace 'col_name' with the name of column, which has image namedisplay_label=True,# by default this is Falsedisplay_cols=['col1','col2'],# replace '', to the column name which you want to print as labeldisplay_name=True,# by default this is Falseprint_all=False,# by default this is Truex=,# X-coordinate of labely=,# Y-coordinate of labelfig_size=(m,n)# by default this is set to max(image_size), maximum size of all the images which will be displayed)#v0.2(ImageMatrix('/content/path_to_folder_containing_images').rand()).display_image((2,2),print_all=False,display_name=True)# v0.1(ImageMatrix('/content/path_to_folder_containing_images')).display_image((2,2),print_all=False)Releases:v0.1This will display the images in a grid with 3 columns and 2 rows, without printing the left out images. If you want to print all images, you can callimage_display.display_image((2, 3))orimage_display.display_image((2, 3), True).v0.2This will display the name of the images, as their titles. In v0.1, the images were printed starting from first and consecutive until upper bound is reached, this is an optional and random option is added.v1.0Added capability to display label with a variey of options.v1.1Added capability to change label display and visuals with a variey of options.