Saravanan666/pypi-org huggingface dataset:
Package: enlightenme
# Enlighten Me[![Build Status](https://travis-ci.com/singhgarima/enlightenme.svg?branch=master)](https://travis-ci.com/singhgarima/enlightenme)A simple python CLI for curating and reading news/updates from your favorite
channels.## Installation`bash pip install enlightenme `## Getting StartedGetting help<a href=”https://asciinema.org/a/wyubbW3B6KsOI4Gi5uBDMfJFf” target=”_blank”><img src=”https://asciinema.org/a/wyubbW3B6KsOI4Gi5uBDMfJFf.png” align=”center” width=”600”/></a>Hacker News Sample<a href=”https://asciinema.org/a/X8a922jbNjvpm4NZfKnmuCM94” target=”_blank”><img src=”https://asciinema.org/a/X8a922jbNjvpm4NZfKnmuCM94.png” align=”center” width=”600”/></a>Reddit Sample<a href=”https://asciinema.org/a/0aalvvZ8PBjCzOY6yBAMXBlBh” target=”_blank”><img src=”https://asciinema.org/a/0aalvvZ8PBjCzOY6yBAMXBlBh.png” align=”center” width=”600”/></a>
Package: enlilviz
A Python package for visualizing the output from the Enlil solar wind code.Documentation:https://enlilviz.readthedocs.io.FeaturesRead in Enlil data files into an xarray dataset for analysis:import enlilviz as ev

run = ev.read_enlil2d('wsa_enlil.latest.suball.nc')

evo = ev.read_evo('evo.earth.nc')Plot time series and slices with the data:import enlilviz.plotting as evplot

evplot.TimeSeries(run, 'Earth', 'den')

evplot.LongitudeSlice(run, 'den')

evplot.LatitudeSlice(run, 'vel')You can also generate common figures that are pre-arranged:forecaster = evplot.ForecasterPlot(run)
forecaster.save()Or iterate through the entire time series to make a movie:for plot in iter(forecaster):
    plot.save()
Package: enlp
Equinor Shared NLP PackageThis package contains functions often used in NLP ranging from processing to visualisation. The purpose behind the
package is to collect in one place common functions where a package can be installed to setup an nlp-focussed
environment and most common nlp tasks can be carried out without having to install extra packages.INSTALLATIONTo install the package directly from github:$ pip install git+https://github.com/equinor/eNLP.gitIf you wish to download the files directly and install, we recommend one of the 3 options as outlined below. Note that
the first two options use a Makefile.Using the Makefile and conda environment:Download or clone the repo and run$ make install_condawhich will create a conda environment with the package installed and all the necessary requirements. Prior to using
the package remember to change into your new environment.$ source activate enlpUsing the Makefile and pip requirements:Download or clone the repo and run$ make installWithout using the Makefile:Download or clone the repo and run$ pip install -r requirements.txt
$ pip install .DEVELOPING AND CONTRIBUTINGWe actively encourage others to contribute to the development of the package.DEV INSTALLATIONTo install the extra requirements for development, the following options can be
followed:Using the Makefile and conda environment:Download or clone the repo and run$ make dev-install_conda
$ source activate enlpUsing the Makefile and pip requirements:Download or clone the repo and run$ make dev-installWithout using the Makefile:Download or clone the repo and run$ pip install -r requirements-dev.txt
$ pip install -e .CONTRIBUTING GUIDELINESPrior to contributing back to the package, please make the documentation and read the section on contributing. In
particular, prior to contributing please ensure all tests run and all new code is adequately documented and any
required new tests have been wrote.DEV DOCUMENTATIONThe documentation includes reference documentation for all functions as well as an example gallery.To make the documentation,$ make docAnd then open the documentation and navigate to the example gallery,$ cd /docs/build/html
$ open index.html.All new features should have clear doc strings and have their paths included in the relevant file underdocs/source/api/.Examples of usage are also very welcome to be added to the example gallery.TESTINGAll new features should have tests written for them and should not break any of the old tests. To check tests run$ make tests
Package: enlyze
Python SDK for interacting with theENLYZE platformGetting started with developmentWe usetoxto manage most of the tasks in a development
workflow.To start developing locally, we suggest that you have tox installed in your environment
(you can install it globally or in a virtualenv) and then you can run the following
command to create a developmentvirtualenvfor the project with the required
dependencies installed.$tox--devenv.venv-edevwhich will create a virtualenv for you under the.venvdirectory. Afterwards you can
activate the virtualenv and start hacking away$source.venv/bin/activateRunning the test suite$toxRunning the linters$toxp-eflake8,black,isort,bandit,tox-fmt,pyproject-fmtRunningmypy$tox-emypyGenerating the documentation$tox-edocsNote that this requires theEnchant C library
<https://pyenchant.github.io/pyenchant/install.html>to be installed.Note for M1 users, theEnchantlibrary doesn’t work out of the box and the
workaround in the official docs is brittle, I suggest installing the library fromhomebrewand setting the environment variablePYENCHANT_LIBRARY_PATHlike
so:$exportPYENCHANT_LIBRARY_PATH=/opt/homebrew/lib/libenchant-2.dylibExamplesYou can find examples of how to use the Python SDK here:Notebooks
Package: enmerkar-underscore
Implements a underscore extractor for django-babel.Free software: BSD licenseDocumentation:http://django-babel-underscore.readthedocs.org.FeaturesTODOHistory1.0.0 (2020-05-29)Rename the repoUsing latest version of enmerkar.Release of pypi0.6.0 (2020-01-07)Adds support for Python 3.6, 3.7Adds support for Django 2.0, 2.1, 2.2 and 3.0.Drop support for Django < 1.110.5.2 (2018-08-18)Adds support for Django 1.10 and 1.11.0.5.1 (2016-07-15)Fix release0.5.0 (2016-07-15)Remove support for Python 2.6 and Python 3.3Remove support for Django < 1.8Add support for Python 3.5Add support for Django 1.9Now requires markey 0.80.4.2 (2015-08-28)Update to markey 0.70.4.1 (2015-08-28)Fix release0.4.0 (2015-08-28)Add support for Django 1.80.3.0 (2015-03-15)Addedunderscoreentry_point for babel.extractors (#1)0.2.0 (2014-12-24)Fix dependency names.0.1.0 (2014-05-25)First release on PyPI.
Package: enmet
Enmet is a programmatic API to Encyclopaedia Metallum - The Metal Archives site. It allows convenient access to Metal Archives data from python code.Enmet is designed for ease of use and ease of development and maintenance.See Documentation link for full documentation. Sample usage:>>>importenmet>>>megadeth=enmet.search_bands(name="Megadeth")[0]>>>print(megadeth.discography)# (output truncated)[<Album:LastRites(4250)>,<Album:KillingIsMyBusiness...andBusinessIsGood!(659)>,...]>>>print(megadeth.discography[0].discs[0].tracks)[<Track:LastRites/LovedtoDeth(38701A)>,<Track:Mechanix(38702A)>,<Track:TheSkullBeneaththeSkin(38703A)>]>>>print(megadeth.lineup)[<LineupArtist:DaveMustaine(184)>,<LineupArtist:JamesLoMenzo(2836)>,<LineupArtist:KikoLoureiro(3826)>,<LineupArtist:DirkVerbeuren(1391)>]>>>print([artist.nameforartistinmegadeth.lineup])['Dave Mustaine','James LoMenzo','Kiko Loureiro','Dirk Verbeuren']
Package: eNMRpy
# Info
This package is a nifty tool for the import and analysis of electrophoretic NMR(eNMR)-spectroscopic data. It is maintained by Florian Ackermann (nairolf.ackermann@gmail.com)For contributions and questions, please consider the <a href=”https://github.com/Flackermann/eNMRpy”>GitHub repository</a>.
When using this for scientific pusposes, please cite <a href=”https://doi.org/10.1002/mrc.4978”>this paper</a>.For documentation please read <a href=”https://enmrpy.readthedocs.io/en/testbranch/”> the read the docs page</a>.# Installation
Install the latest release simply via <code>$ pip install eNMRpy</code># Range of functions coveredImport of Bruker-based eNMR-Data3 different experimental Setups so farplease considerpull requestson  <a href=”https://github.com/Flackermann/eNMRpy”>GitHub</a> to get help for your own experimental setupPhasenwinkelanalysePhasenkorrektur-Analyse (old approach)EntropieminimierungSpektrenabgleichVergleich der Phasenkorrigierten Spektren durch ÜbereinanderlegenPhasenanalyse mittels Fitting (new approach)Lorentz/Voigt-Peakssuperposition von beliebig vielen PeaksIndividuelles festsetzen von ParameternRegressionsrechnungBerechnung der jeweiligen Mobilitäten aus automatisch bestimmten experimentellen ParameternVergleich der verschiedenen Ergebnisse(- einfaches Tool zum Erstellen von Graphen)Phasenanalyse mittels 2D FFT –> Mobility ordered Spectroscopy (MOSY)States-Haberkorn-MethodeErmittlung der MobilitätsachsePlotten von Slices zum Vergleich der Ergebnisse/PeaksAutomatische normierung der Intensitäten und Auffindung der Maxima.Durch Signalverlust mit steigender Spannung stellt man eine zu hohe Mobilität fest!!!
Package: ennemi
This package performs non-linear correlation analysis with mutual information (MI).
MI is an information-theoretical measure of dependency between two variables.
The package is designed for practical data analysis
with no theoretical background required.Features:Non-linear correlation detection:Mutual information between two variables, continous or discreteConditional MI with arbitrary-dimensional conditioning variablesQuick overview of many-variable datasets with pairwise MI estimationPractical data analysis:Interfaces for evaluating multiple variable pairs and time lags with one callIntegrated withpandasdata frames (optional)Optimized and automatically parallelized estimationAlgorithms verified to work, so that you can focus on your dataThis package depends only on NumPy and SciPy;
Pandas is suggested for more enjoyable data analysis.
Python 3.8+ on the latest macOS, Ubuntu and Windows versions
is officially supported.For more information on theoretical background and usage, please see thedocumentation.
If you encounter any problems or have suggestions, please file an issue!This package was initially developed atInstitute for Atmospheric and Earth System Research (INAR),
University of Helsinki.
Package: en-neuralcoref
neural coref spaCy modelThis spaCy model annotates and resolves coreference clusters using a neural network.
Note: as of now the model is only available in English.InstallationBefore using the neural coref model, make sure spaCy English model is installed.$python-mspacydownloaden_core_web_smNow the neural coref spaCy model can be installed.$pipinstallen-neuralcorefUsage# Import spacy and load the en_neuralcoref modelimportspacynlp=spacy.load('en_neuralcoref')# You're done. You can now use NeuralCoref as you usually manipulate a SpaCy document annotations.doc=nlp(u'My sister has a dog. She loves him.')doc._.has_corefdoc._.coref_clustersdoc._.coref_resolvedLicenseMIT
Package: ennio
ennioEnnio is an interstack orchestration framework for AWS CloudFormationInstallationUse the package managerpipto install foobar.pipinstallennioWhyCloudformation alone cannot do all the infrastructure work. Frequently we need some extra operational steps between deployments of Cloudformation stacks. Moreover, we often split a huge application into several smaller stacks to minimize the maintenance effort. It is good to have a mechanism to do all the stack deployments in a single step, and possibly do rollback all the changes to a previous when a stack deployment failed. Ennio did all that for us.This framework, like many others, are opinionated, in that:We believe in reproducible deployments. For each build of infra code, we should create a bundle that can be deployed and redeployed anytime we like.We had made a decision to store this bundle in S3.Although we had provided a way to generate cloudformation templates using jinja2, and prefer that all templates be written in yaml, you can still bring your own way to generate all the templates.ExamplePlease take a look at the sample project in example dir.ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseApache
Package: enniolearning
Ennio-LearningEnnio is a machine learning program.
It takes musics in MID format to learn a theme.
Themes are collections of datasets (collection of MID files) having common features, for example :Heroic fantasyThrillerHorrorSuspenseClassicMangaetc.Once learning (training) for one theme is done, the model (network weights) is serialized and can be reused for later music generation.
Such models are used for instance inEnnio app project.Training featuresEnnio Learning handlesJordanfeatures during training and model evaluation. As these are long processes, Jordan app gives remote access to logs (and ETA), and some control over loops. For example, one may skip a training task if it is not going to be efficient (loss is not decreasing).LoggingA default logger exists, at levellogging.INFO. You may adjust this level by callingimport logging
from enniolearning.utils import set_default_logger_level

set_default_logger_level(logging.DEBUG)You can also provide your own logger (defined fromlogging library)
by passingloggerargument. For example :import logging, logging.config
logging.config.fileConfig('logging.yml')
logger_from_config = logging.getLogger('simpleExample')

from ennio_training import train
train(logger=logger_from_config)
Package: en-nligraphspacy
Knowledge graph in SpacyFeature | Description |— | — |Name|en_nligraphspacy|Version|0.0.1|spaCy|>=3.5.2,<3.6.0|Default Pipeline|tok2vec,ner|Components|tok2vec,ner|Vectors| 514157 keys, 20000 unique vectors (300 dimensions) |Sources| n/a |License| n/a |Author| [Vishnu](https://github.com/Vishnunkumar/nligraphspacy) |### Label Scheme<details><summary>View label scheme (3 labels for 1 components)</summary>Component | Labels |— | — |`ner`|EDGE,SOURCE-NODE,TARGET-NODE|</details>### AccuracyType | Score |— | — |ENTS_F| 98.39 |ENTS_P| 98.34 |ENTS_R| 98.45 |TOK2VEC_LOSS| 72299.90 |NER_LOSS| 154859.70 |
Package: enno
Wrapper around Evernote’s python client that makes it just a little more
pleasant to use.Get an access tokenGohereand clickGET AN API
KEY.Fill out the information for your Oauth appCreate an account on thedevelopment
serveradd your key and secret to the environment:$ export ENNO_CONSUMER_KEY=...
$ export ENNO_CONSUMER_SECRET=...Create an access token:$ enno oauth --sandboxExport your sandbox access token:$ export ENNO_SANDBOX=1
$ export ENNO_SANDBOX_ACCESS_TOKEN=...When you are ready to use your app on your actual live evernote, gohereand clickActivate an
API Key.When your api key is activated you can then get a real access token:$ enno oauth
$ export ENNO_SANDBOX=0
$ export ENNO_ACCESS_TOKEN=...Querying notesfromennoimportNote# get the first 10 notes containing foo in the titleq=Note.query.in_title("foo").limit(10)forninq.get():print(n.title)Creating notessave text:fromennoimportNoten=Note()n.title="this is the title"n.plain="this is the content"n.save()print(n.guid)Save html:n=Note()n.title="this is the title"n.html="<p>this is the content</p>"n.save()print(n.guid)Evernote saves its notes in a format calledENML, this is
available in the.contentproperty:n=Note()n.title="this is the title"n.html="<p>this is the content</p>"print(n.content)# the html will have been converted to enmlCreating NotebooksfromennoimportNotebooknb=Notebook()nb.name="foo bar"nb.save()print(nb.guid)InstallationUse pip:$ pip install ennoTo get the latest and greatest:$ pip install git+https://github.com/jaymon/enno#egg=enno
Package: eno
testing phone networks with GSM modules### requirements* one or more eno hardware nodes (Beaglebone Black + a Fona module)* Python 2.7### installation```shell$ pip install eno```### usageA cluster of eno hardware nodes are setupwith network connectivity to a testing machine.The testing machine uses `eno.nodes.Node` to control the connected nodesand to read data from them.The nodes themselves run the `eno.server.app`.Other clients (like the testing machine) connect to this serverto give instructions to the hardware and to read data back.The hardware uses [python-gsmmodem](https://github.com/faucamp/python-gsmmodem)to communicate with the onboard GSM modem.The testing machine should have an `~/.enorc` describing the test cluster:```yaml- name: node Aip_address: 192.168.1.102sim: endaga- name: node Bip_address: 192.168.1.105sim: endaga- name: node Cip_address: 192.168.1.107sim: tingphone_number: 19195551234```See additional examples in `server.py` and `sample_test.py`.### testing concurrent callsBy default, when making a call, the test serverwill make the modem hang up a few seconds after the call connects.I experimented with a `/hangup` endpoint but that complicates things --we would need signals and some WSGI runnerin order to have more than one server process.So instead you can specify `hangup_after` as a request param,this will hangup the call after the specified number of seconds.### licenseMIT### releases* 0.0.17 - adjusts return values in `server.call`* 0.0.16 - fixes modem definition* 0.0.15 - adds call functionality* 0.0.14 - adds more request timeouts and `Node.get_info`* 0.0.13 - adjusts handling of `Node.wait_for_activity`* 0.0.12 - adds protocol in `Node.server_address`* 0.0.11 - fixes port default* 0.0.10 - allows tilde expansion when searching for enorc config file* 0.0.9 - adds `Node.wait_for_activity` for sms* 0.0.8 - adjusts handling of sms log in Node class* 0.0.7 - changes sms log deletion method* 0.0.6 - improves error handling and modem connection management* 0.0.5 - adjusts package structure* 0.0.4 - adds missing requests requirement* 0.0.3 - adjusts server script filename* 0.0.2 - adds SMS handling capabilities* 0.0.1 - barebones setup for pypi### release processyou need a `~/.pypirc` like this:```[distutils]index-servers =pypi[pypi]repository: https://pypi.python.org/pypiusername: yosemitebanditpassword: mhm```bump the versions in `setup.py` and here in the readme, then run:```shell$ git tag 0.0.1 -m 'eno-python v0.0.1'$ git push origin master --tags$ python setup.py sdist upload -r pypi```
Package: enocean2mqtt
enocean2mqttpublish EnOcean received packets to MQTTSend commands to EnOcean equipments via MQTTIt is based onPython EnOceanandEclipse Paho™ MQTT Python Client.Installpip install encoean2mqtt --userFor Linux systems pip install lib to~/.local/liband executable to~/.local/bin(check withpython -m site).ConfigureGet inspired byenocean2mqtt-sample.yamland/or readconfiguration documentation on GitHubRun manually# Minimal
~/.local/bin/enocean2mqtt --config /your/path/enocean2mqtt.yaml

# All args
~/.local/bin/enocean2mqtt --config /your/path/enocean2mqtt.yaml --verbose --log-file /your/path/enocean2mqtt.logRun as a systemd serviceSample made for Raspbian 10 andpiusercopy fileenocean2mqtt.serviceto/etc/systemd/system/enocean2mqtt.servicecustomize with your user and configuration file pathsudo chown root:root /etc/systemd/system/enocean2mqtt.servicesudo chmod 644 /etc/systemd/system/enocean2mqtt.servicesudo systemctl daemon-reloadsudo systemctl enable enocean2mqttsudo systemctl start enocean2mqttCheck status :sudo systemctl status enocean2mqttSee logs :journalctl -f -u enocean2mqtt
Package: enocean-webthing
enocean_webthingA web connected enocean gateway. This project provides awebthing APIto an enocean gateway such as theEnOcean USB 300 USB-GatewayThe enocean_webthing package exposes a http webthing endpoint supporting enocean devices.E.g.# webthing has been started on host 192.168.0.23

curl http://192.168.1.198:9090/0/properties

{
   "eep_id":"F6:10:00",
   "enocean_id":"81:00:F0:4E",
   "state":3
}Currently, thedeviceslisted below are supportedWindow Handle such asHOPPE Window Handle ConnectHome(EEP ID: F6:10:00)To install this software you may use thePIPpackage manager such as shown belowPIP approachsudo pip install enocean_webthingAfter this installation you may start the webthing http endpoint inside your python code or via command line usingsudo enocean --command listen --port 9090 --path /dev/ttyUSB-enocean --devices 'Office/F6:10:00/81:00:F0:4E, Patiodoor/F6:10:00/01:9A:CC:06'Here, the webthing API will be bound to the local port 9090 by using the USB-Gateway /dev/ttyUSB-enocean.
To list the devices to be supported a comma-separated list is used with the syntax {Device name}/{EEP ID}/{ENOCEAN ID}Alternatively to thelistencommand, you can use theregistercommand to register and start the webthing service as systemd unit.
By doing this the webthing service will be started automatically on boot. Starting the server manually using thelistencommand is no longer necessary.sudo enocean --command register --port 9090 --path /dev/ttyUSB-enocean --devices 'Office/F6:10:00/81:00:F0:4E, Patiodoor/F6:10:00/01:9A:CC:06'
Package: enochecker3
enochecker3A FastAPI based checker library for writing async checkers in python. It is called enochecker3 even though enochecker2 never existed, because it is intended to be the reference implementation for version 3 of the enochecker API specification which is yet to come.Quick StartGetting started is really easy. Simply installenochecker3usingpip3 install enochecker3Create anexample.pyfile with the following content:importsecretsfromtypingimportOptionalfromhttpximportAsyncClientfromenochecker3import(ChainDB,Enochecker,GetflagCheckerTaskMessage,MumbleException,PutflagCheckerTaskMessage,)fromenochecker3.utilsimportFlagSearcher,assert_equals,assert_inchecker=Enochecker("ExampleService",1337)@checker.putflag(0)asyncdefputflag_test(task:PutflagCheckerTaskMessage,client:AsyncClient,db:ChainDB,)->None:token=secrets.token_hex(32)r=awaitclient.post("/note",json={"token":token,"flag":task.flag})assert_equals(r.status_code,200,"storing note with flag failed")awaitdb.set("token",token)@checker.getflag(0)asyncdefgetflag_test(task:GetflagCheckerTaskMessage,client:AsyncClient,db:ChainDB)->None:try:token=awaitdb.get("token")exceptKeyError:raiseMumbleException("Missing database entry from putflag")r=awaitclient.get(f"/note/{token}")assert_equals(r.status_code,200,"getting note with flag failed")assert_in(task.flag,r.text,"flag missing from note")@checker.exploit(0)asyncdefexploit_test(searcher:FlagSearcher,client:AsyncClient)->Optional[str]:r=awaitclient.get("/note/*",)assertnotr.is_errorifflag:=searcher.search_flag(r.text):returnflagStart the checker usinguvicorn --reload example:checker.appAnd browse to (http://localhost:8000/docs) to explore the web interface, which allows you to send requests to the checker.DocumentationYou can check out the full tutorial at (https://enowars.github.io/docs)
Package: enochecker-async
EnoChecker AsyncThis is the asynchronous python variant of the ENOWARS checkerlib.Implementing an asynchronous checkerConsumers must extend the BaseChecker class:classDemoChecker(BaseChecker):port=8000def__init__(self):super(DemoChecker,self).__init__("Demo",8080,2,0,0)# 2 flags, 0 noises, 0 havocsasyncdefputflag(self,logger:LoggerAdapter,task:CheckerTaskMessage,collection:MotorCollection)->None:passasyncdefgetflag(self,logger:LoggerAdapter,task:CheckerTaskMessage,collection:MotorCollection)->None:passasyncdefputnoise(self,logger:LoggerAdapter,task:CheckerTaskMessage,collection:MotorCollection)->None:passasyncdefgetnoise(self,logger:LoggerAdapter,task:CheckerTaskMessage,collection:MotorCollection)->None:passasyncdefhavoc(self,logger:LoggerAdapter,task:CheckerTaskMessage,collection:MotorCollection)->None:passFor a full example, check out theWASP checker.Testing your checkerenochecker_cliis a nice cli tool that you can use to send tasks to your checker.
Package: enochecker-cli
Enochecker CLIUsageusage: enochecker_cli [-h] [-A CHECKER_ADDRESS] [-a ADDRESS] [-t TEAM]
                      [-T TEAM_ID] [-I RUN_ID] [-r ROUND] [-R ROUND_LENGTH]
                      [-f FLAG] [-F FLAG_ROUND] [-x TIMEOUT] [-i FLAG_IDX]
                      {putflag,getflag,putnoise,getnoise,havoc}Installationpip3 install enochecker_cli