Saravanan666/pypi-org huggingface dataset:
Package: eloqua-lib
Eloqua Python ConnectorPython 3 library for using the Eloqua APIEloqua API Documentation HereFeaturesManage your connectionelq=EloquaConnection(COMPANY,USERNAME,PASSWORD)CRUD actions with Eloqua Assets (Custom Objects, Forms, Emails, Landing Pages)dog_owner_custom_object=CustomObject()dog_owner_custom_object.raw_data={"name":"TEST_Dog_Owner","description":"Testing Custom Object for dog owners","fields":[{"name":"DogBreed","displayType":"text","dataType":"text"},{"name":"StartOfOwnership","displayType":"text","dataType":"date"},{"name":"AgeAtStartOfOwnership","displayType":"text","dataType":"number"},{"name":"DogColor","displayType":"text","dataType":"text"},{"name":"DogName","displayType":"text","dataType":"text"}]}elq.create(dog_owner_custom_object)Generate Usable Models from Custom ObjectsGenerate model code. Useful for when you have data stored in Eloqua like a database.object_code=elq.generate_custom_object_code("Dog_Owner_0003",class_name="DogOwner")print(object_code)Yields:classDogOwner(CustomObjectModel):NAME="Dog_Owner_0003"PARENT_ID="501"FIELDS=["DogName1","Breed1","DateOfOwnership1"]ID_FIELD_MAP={"123":"DogName1","124":"Breed1","125":"DateOfOwnership1"}DogName1=NoneBreed1=NoneDateOfOwnership1=NoneCRUD actions with Custom Object Data Modelsfirst_dog_owner=elq.get(DogOwner,record_id='1')all_corgi_dog_owners=elq.get_list(DogOwner,params={"search":"Breed1='Corgi'"})first_dog_owner.name="New Dog Name"elq.update(first_dog_owner)elq.delete(first_dog_owner)Variable PathsThepaths.pyholds all the paths used for interaction with the API.
Sometimes, a certain API versions works better than others so this is a place where you can change that.# LoginDEFAULT_LOGIN_URL="https://login.eloqua.com/id"# FormsFORM_CREATE_PATH="/api/REST/2.0/assets/form"FORM_DELETE_PATH="/api/REST/2.0/assets/form/{id}"FORM_UPDATE_PATH="/api/REST/2.0/assets/form/{id}"FORM_GET_PATH="/api/REST/2.0/assets/form/{id}"FORM_GET_LIST_PATH="/api/REST/2.0/assets/forms"# Custom ObjectsCUSTOM_OBJECT_CREATE_PATH="/api/REST/2.0/assets/customObject"CUSTOM_OBJECT_DELETE_PATH="/api/REST/2.0/assets/customObject/{id}"CUSTOM_OBJECT_UPDATE_PATH="/api/REST/2.0/assets/customObject/{id}"CUSTOM_OBJECT_GET_PATH="/api/REST/2.0/assets/customObject/{id}"CUSTOM_OBJECT_GET_LIST_PATH="/api/REST/2.0/assets/customObjects"...TestingTo perform testing, it is preferable to use your sandbox instance.Create aeloqua/test/creds.pyfile. An outline is provided in example_creds.pyRuneloqua/test/test.pyunittestsRequirementsPython 3
Package: elo-rating
Reference implementation of Elo rating systemInstallation$python-mpipinstall-Uelo_ratingExample Usagefromelo_ratingimportEloe=Elo()e.add_match("p1","p2",1.0,k=0.15)e.add_matches([("p1","p2",1.0),("p2","p1",0.5)],k=0.15)e.ratings()# {"p1": 0.13363123747494593, "p2": -0.1336312374749459}e.items()# ['p1', 'p2']e.rankings()# {'p1': 0, 'p2': 1}e.ranking('p1')# 0e.rating('p1')# 0.13363123747494593
Package: elphmod
Python modules for electron-phonon modelsel- tight-binding models from Wannier90ph- mass-spring models from Quantum ESPRESSOelph- electron-phonon coupling from EPWelel- Coulomb interaction from RESPACKMPI- work distribution and shared memorybravais- lattices, symmetries, and interpolationdispersion- diagonalization on paths and meshesdos- 2D tetrahedron methodsdiagrams- susceptibilities, self-energies, etc.occupations- step and delta smearing functionsmd- charge-density-wave dynamics using i-PIeliashberg- parameters for McMillan's formulaplot- BZ plots, fatbands, etc.misc- constants, status bars, parsing, etc.InstallationTo install the latest version of elphmod:python3 -m pip install elphmodAlternatively, to install the latest development version:python3 -m pip install git+https://github.com/janberges/elphmodelphmod can optionally be run in parallel via MPI (with shared-memory support).
Using APT and pip, you can install the corresponding dependencies as follows:sudo apt install libopenmpi-dev
python3 -m pip install mpi4py --no-binary=mpi4pyIf you plan to work on elphmod itself, we recommend to download the complete
repository and also install the requirements of examples and documentation:git clone https://github.com/janberges/elphmod
python3 -m pip install -r elphmod/requirements.txtAlso consider adding the absolute paths toelphmodandelphmod/binto the
environment variablesPYTHONPATHandPATH, respectively.DocumentationThe documentation can be found athttps://janberges.github.io/elphmod. It has
been automatically generated from the NumPy-style docstrings in the source code
using Sphinx:cd doc
make htmlPlease also have a look at the examples.LicenceThis program is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later
version.This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details.You should have received a copy of the GNU General Public License along with
this program. If not, seehttps://www.gnu.org/licenses/.Copyright (C) 2017-2023 elphmod Developers
Package: elphy
MR ElastographyMaterial property estimation and analysis for magnetic resonance elastography (MRE) data.Free software: MIT licenseDocumentation:https://elphy.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-09-27)First release on PyPI.
Package: elpigraph-python
DescriptionThis package provides a Python implementation of the ElPiGraph algorithm with cpu and gpu support. Usage is explained in thedocumentationand a
self-contained description of the algorithm is availablehereor in thepaperIt replicates theR implementation,
coded byLuca Alberganteand should return exactly the same results. Please open an issue if you do  notice different output. Differences between the two versions are detailed indifferences.md. This package extends initial work byLouis FaureandAlexis Martin.A native MATLAB implementation of the algorithm (coded byAndrei
ZinovyevandEvgeny
Mirkes) is alsoavailableRequirementsRequirements are listed in requirements.txt. In addition, to enable gpu support cupy is needed:https://docs-cupy.chainer.org/en/stable/install.htmlInstallationgitclonehttps://github.com/j-bac/elpigraph-python.gitcdelpigraph
pipinstall.orpipinstallelpigraph-pythonCitationWhen using this package, please cite ourpaper:
Albergante, L.  et al . Robust and Scalable Learning of Complex Intrinsic Dataset Geometry via ElPiGraph (2020)
Package: elp-mpp02
ELP_MPP02: accurate Moon positions using the lunar solution ELP/MPP02 in PythonCompute accurate Moon positions using the semi-analytical lunar solution ELP2000/MPP02 by Chapront & Francou
(2003) in Python.InstallationThis package can be installed usingpip install elp-mpp02.  You will need to manually download the six data
filesELP_MAIN/PERT.S1/2/3fromftp://cyrano-se.obspm.fr/pub/2_lunar_solutions/2_elpmpp02and save them in a directory of your choice.Using the packageYou can import the package as follows:fromelp_mpp02importmpp02asmppThen, make sure you define the directory where the data files are located (if not in the current dir).
For the subdirdata/of the current directory, do:mpp.dataDir='data'# Set the dir where the ELP_*.S* data files can be foundChoose whether to run the code in LLR (mode=0; default) or DE405 (mode=1; 'historical') mode, select a
Julian day and compute the Moon position for that instance:mode=1# Historical modejd=2451545lon,lat,dist=mpp.compute_lbr(jd,mode)print('jd =',jd,':   lon =',lon,'rad,  lat =',lat,'rad,  dist =',dist,'km.')The result should bejd = 2451545 :   lon = -2.385534575256455 rad,  lat = 0.09024868423130429 rad,  dist = 402448.6385830673 kmThe ecliptical longitude and latitude are expressed in radians, the distance is in kilometres.  The
coordinates are valid for the mean equinox of J2000.  Note that on the first call, the constants must be
initialised and the data files need to be read, which can take ~10s.  Ifmodeis changed between calls, the
data must be reinitialised.Author and licenceAuthor: Marc van der SluysContact:http://astro.ru.nl/~sluys/Website:Github,PyPILicence:GPLv3+ReferencesChapront & Francou (2003)FTP data files— in caseFTP urls don't work in Markdown:ftp://cyrano-se.obspm.fr/pub/2_lunar_solutions/2_elpmpp02This Python code is adapted from the Fortran implementation inlibTheSky
Package: elsa-plotting-wand
Plotting WandPlot experimental results.This project mainly usesPlotlyconfigurations and have limited compatibility withSeaborn.FeaturesFriendly API interfacePlotting examplesPrerequisitesLinux-based terminals (For Windows, I recommend usinggit-sdk)Python 3.5 or higherOrca(For saving image when plotting with Plotly)InstallationRun the following command:pipinstallelsa-plotting-wandExamplesTo get started, see the exampleMinimalist. For practical usage, see the exampleSubplots.
Package: elsec
The goal of the project is to provide an easy to use, interactive
command line (terminal) client to Elasticsearch, with behavior similar
to ‘mysql’ or ‘psql’ clients. The tool is to give a safe (read-only) way
to explore data in ES indices, addressing use cases common among
non-technical, non-administrator users. Anyone capable of using the
mysql client to dig around a mysql database should be able to use the
‘elsec’ to look at data in an ES index.
Package: elseql
elseql======You know, for Query-------------------A SQL-like command line / REPL client for ElasticSearch### USAGEelseql [--debug] [--port=host:port]### COMMANDS* select - see SEARCH SYNTAX* describe [index]* set options [on|off]* help### SEARCH SYNTAXSELECT {fields}[FACETS facet-fields][SCRIPT script-field = 'script']FROM index[WHERE where-condition][FILTER filter-condition][ORDERY BY order-fields][LIMIT [start,] count]where:fields: '*' or comma-separated list of field names to be returnedfacet-fields: comma-separated list of fields to execute a facet query onscript-field: name of script field, to be used in select clausescript: ElasticSearch scriptindex: index to querywhere-condition:{field-name} [ = != > >= < <= ] {value}{field-name} LIKE {value}{field-name} IN (value1, value2, ...){field-name} BETWEEN {min-value} AND {max-value}NOT {where-condition}{where-condition} AND {where-condition}{where-condition} OR {where-condition}or where-condition:'query in Lucene syntax'filter-condition:QUERY {where-condition} - query filter, same syntax as where conditionEXIST {field-name}      - exists field filterMISSING {field.name}    - missing field filterorder-fields: comma-separated list of {field-name} [ASC | DESC]start: start index for paginationcount: maximum number of returned resultsA special case for LIMIT start,count allows to do a "scroll" query (i.e. results will be returned in batches):start: -1 - enable "scroll" querycount: batch size - the query will return {count} results (actually {count} per shard) and will be repeated until all results are returned.This is very useful when you are expecting large result sets (or you are doing a full table scan). Note that in"scroll" mode sort and facets are disabled.### INSTALLATIONFrom pypi:sudo easy_install elseqlor:sudo pip install elseqlWith python and setuptools installed:sudo python setup.py installYou can also run the command without installing as:python -m elseql.elseqlTo do this you will need the pyparsing, rawes and cmd2 packages installed, that are automatically installed in the previous step.sudo easy_install pyparsingsudo easy_install rawessudo easy_install cmd2The cmd2 package add a few extra features "command-line" related features. The most useful is redirection:elsesql> select id,field1,field2 from index where condition > result.csvNote that because '>' is used for redirection you'll need to use GT in the where clause insted (also available LT, GTE, LTE)### SEE ALSOhttp://elasticsearch.org/, You know, for Search
Package: elspice
EL-SPICEEfficient Language - Simulation Program with Integrated Circuit Emphasispip install elspiceEL-Spice isefficient-languagebased analog electronic circuit simulator. The simulated circuit is created from an expression, then required mathematical operations are applied. Overall, simulation is done.
The lingual expression is a geometric code, describes an edge connected to points, which component lies in the edge and what is SI unit magnitude associated with the component. For example:(0,0) (0,1) R 5M;This means that a 5 MΩ resistor is connected between points (0,0) and (0,1). Points are not necessarily 2D, it can be in any dimension. Each identifier follows each other by a space. Each component follows the other by a semicolon(;)(0,0) (0,1) I 2m;(0,1) (1,1) R 1K;(1,1) (0,0) R 2K;This time, a current source of 2mA is connected with two resistors; one them is 1KΩ, other is 2KΩ. Wires don't have any parameter.(0,0) (0,1) -;In summary, all components and usage scheme is listed below:(0,0) (0,1) -;
(0,0) (0,1) V 5;
(0,0) (0,1) I 2.3m;
(0,0) (0,1) R 3.3M;
(0,0) (0,1) C 4.7p;
(0,0) (0,1) L 3.4u;RLC Circuit(ω=107)(1,0) (1,1) V 5;(1,1) (0,1) C 2n;
(0,1) (0,0) L 5u;(1,0) (0,0) R 5;UsageFirstly define your circuit withcirc = elspice.Circuit(D)where D is number of dimensions.Create a string of circuit expression with the efficient language and AC frequency. If the circuit is DC, then just write 0 or nothing, it is default to 0.circ.decode(string_of_circuit, frequency)Get node voltages by callingcirc.nodes()You can export each node voltagecirc.node_voltages(). It returns an array and a dictionary describes that which index of array is which node.Overallimport elspice
circ=circ = elspice.Circuit(D)

string_of_circuit="""(1,0) (1,1) V 5;(1,1) (0,1) C 2n;
(0,1) (0,0) L 5u;(1,0) (0,0) R 5;"""

circ.decode(string_of_circuit, 1591549.430)
circ.nodes()OutputNode Voltages:
(1, 0): 0V 0°
(1, 1): 5.0 V  -1.3232932312128532e-46 °
(0, 1): 50.24937807687795 V  84.28940752087149 °
(0, 0): 4.999999999999999 V  6.616466159068361e-07 °
Package: elsw
ElswTool providing a nice way to view the Portage "world" file.Options-h, --help            show this help message and exit
  -V, --version         show program's version number and exit
  -a, --all             List all available packages
  -i, --installed       List @installed packages
  -w, --world           List @world set(s) packages
  -s, --sets            List non-@world packages
  -e EXCLUDE, --exclude EXCLUDE
                        Exclude package categories from being listed (pass in a delimited list string)LicenseCopyright (c) 2019-2024, Maciej Barćxgqt@xgqt.orgLicensed under the GNU GPL v2 LicenseSPDX-License-Identifier: GPL-2.0-or-later
Package: eltako14bus
Eltako14Bus Python libraryThis repository contains a library and some tools for interacting with the Eltako Series 14 bus system,
which is an extension to the EnOcean Serial Protocol ESP2.This is part of the reverse engineering approach that allows using Eltako
Series 14 devices without a FAM.It can work both on a direct RS485 serial connection to the bus,
with or without a FAM14 present on the bus,
through a FAM14's serial connection,
or through a bespoke CoAP interface to the ESP2 protocol.ToolsThe eltakotool program shipped with it can
do various raw interactions with the bus
(replacing some FAM14 functionality, locking and unlocking the bus, sending arbitrary messages)
as well as reading and writing the bus participants' memory
(including verification and annotation of the memory contents).Protocol description(This is a short version.
The long is partially available in the EnOcean and Eltako documentations,
and the rest is in the reverse engineered code).The EnOcean serial protocol is a point-to-point serial protocol between a computer and a radio transceiver;
it contains synchronization bytes, some structured data bytes, and checksumming.
The most common message formats are RPS and 4BS,
which have equivalent messages (with short and long (4 byte) data, respectively) on the radio side.
These messages contain some addressing information both when receiving (indicating which device sent it)
and when sending through the transceiver (in which case the addresses need to match the address range of the transceiver, giving about 128 possible sending addresses).The Eltako protocol is loosely built on the ESP2 protocol,
but is used on an RS485 bus (with up to 127 participants),
and uses several message types that are not defined in ESP2.Part of the Eltako bus protocol is enumeration:
Devices on the bus can be put into an addressing mode,
and the bus master (a FAM14 or the library user) can assign one of the 127 available address to the device.Commands are also known to visually identify devices on the bus,
and to read and write their configuration (eg. in a relay, setting which buttons it should react to).LicenseThis was developed by Christian Amsüssc.amsuess@energyharvesting.atand Energy Harvesting Solutions 2016-2020.It is published under the terms of GNU LGPL version 3 or later.
Package: eltch
EltchEltchis a module that will help you in working with electricity.Now, an "electric current wheel" based on Ohm's law has been implemented. With it, you can calculate:Volts, Watts, Ohms, Amps. Having only two values from this list.importeltche=eltch.EWheel()# e.volts_amps(volts_val, volts_val)all_values=e.volts_amps(100,200)print(all_values){'U':100.0,'R':0.5,'I':200.0,'P':20000.0}The "EWheel" class has a number of functions:watts_volts(),watts_ohms(),watts_amps(),volts_watts(),volts_ohms(),volts_amps(),ohms_watts(),ohms_volts(),ohms_amps(),amps_watts(),amps_volts(),amps_ohms().With an example, you can see how it works. A function is selected for the value you have. Based on the name of the function, you pass these values to it.
The function returns a dictionary with all the values from "electric current wheel" that you can use for your own purposes.resist_sum=all_values['R']+0.6# ...Installing Eltch and Supported VersionsEltchis available on PyPI:$ python -m pip install eltchEltch officially supports Python 3.6+.
Package: e-lti
This library is a fork oflti_lti_pyIt has been modified to accept non-standard params and bubble up useful
error messages in the form of exceptions to the caller.ltiis a Python library implementing the
Learning Tools Interoperability (LTI) standard.
It is based onlti_lti_py,
which is based ondce_lti_py,
which is based onims_lti_py.InstallationpipinstallltiDependencieslxmloauthlibrequests-oauthlibUsageThe primary goal of this library is to provide classes
for building Python LTI tool providers (LTI apps).
To that end, the functionality that you’re looking for
is probably in theToolConfigandToolProviderclasses (ToolConsumeris available too, if you want to consume LTI Providers).Tool Config Example (Django)Here’s an example of a Django view you might use as the
configuration URL when registering your app with the LTI consumer.fromltiimportToolConfigfromdjango.httpimportHttpResponsedeftool_config(request):# basic stuffapp_title='My App'app_description='An example LTI App'launch_view_name='lti_launch'launch_url=request.build_absolute_uri(reverse('lti_launch'))# maybe you've got some extensionsextensions={'my_extensions_provider':{# extension settings...}}lti_tool_config=ToolConfig(title=app_title,launch_url=launch_url,secure_launch_url=launch_url,extensions=extensions,description=app_description)returnHttpResponse(lti_tool_config.to_xml(),content_type='text/xml')Tool Provider OAuth Request Validation Example (Django)fromlti.contrib.djangoimportDjangoToolProviderfrommy_appimportRequestValidatorfromoauthlib.oauth1importSignatureOnlyEndpoint# create the tool provider instancetool_provider=DjangoToolProvider.from_django_request(request=request)# the tool provider uses the 'oauthlib' library which requires an instance# of a validator class when doing the oauth request signature checking.# see https://oauthlib.readthedocs.org/en/latest/oauth1/validator.html for# info on how to create onevalidator=RequestValidator()# validate the oauth request signatureok=tool_provider.is_valid_request(SignatureOnlyEndpoint,validator)# do stuff if ok / not okTool Consumer Example (Django)In your view:defindex(request):consumer=ToolConsumer(consumer_key='my_key_given_from_provider',consumer_secret='super_secret',launch_url='provider_url',params={'lti_message_type':'basic-lti-launch-request'})returnrender(request,'lti_consumer/index.html',{'launch_data':consumer.generate_launch_data(),'launch_url':consumer.launch_url})At the template:<formaction="{{ launch_url }}"name="ltiLaunchForm"id="ltiLaunchForm"method="POST"encType="application/x-www-form-urlencoded">{% for key, value in launch_data.items %}<inputtype="hidden"name="{{ key }}"value="{{ value }}"/>{% endfor %}<buttontype="submit">Launch the tool</button></form>TestingUnit tests can be run by executingtoxThis usestoxto set up and run the test environment.
Package: eltime
The simplest possible time tracker:press Enter on window or mouse click Play button to start sessionpress Enter or mouse click Stop button to end sessionOptionally task description may be entered. Autocompletion will make suggestions from previous task.To see stats for the last two days, press Ctrl-HNote 1:Intentionally time duration is combined all over the each single hour for each task name, then total amount rounded up to 10min.E.g.:three sessions by 1 min each calculates as 10mintwo sessions by 7 min each and one 1min calculates as 20minNote 2:Hour activity ended is one that counts.E.g.:session started 17:57 ended 18:51In report you'll have "18h - 10min"To quit, press Ctrl-Q
Package: eltyer
Official ELTYER Python ClientThe ELTYER python client is a python library that can be used by your
investing algorithm. With this client your can connect your algorithm to
the ELTYER platform.InstallationYou can install the client directly using pip:pipinstalleltyerUsageExample usagefromeltyerimportClient,OrderStatus# Create a client and configure it with your algorithm api keys from ELTYERclient=Client()# ****Configuration options****# Configuration with dictclient.config.from_dict({"API_KEY":"<YOUR_API_KEY>"})# Configuration with attribute setterclient.config.API_KEY="<YOUR_API_KEY>"# Configuration with environment variable 'ELTYER_API_KEY'client.config.from_env()# ****Configuration options****# ****Available Operations****# Start the ELTYER clientclient.start()# Get the api key context/environmentclient.get_environment()# Create a limit orderlimit_order=client.create_limit_order(target_symbol="btc",amount=1,price=5,side="BUY",)# Create a market order (only sell market orders are supported)market_order=client.create_market_order(target_symbol="btc",amount=1)# Get positionspositions=client.get_positions()position=client.get_position("btc")# Get ordersorders=client.get_orders()orders=client.get_orders(target_symbol="btc",status=OrderStatus.PENDING.value)# Get the portfolioportfolio=client.get_portfolio()# Stop the clientclient.stop()DocumentationYou can find the official documentation at ourdocumentation website
Package: eltyer-investing-algorithm-framework
ELTYER Investing Algorithm Framework PluginThis is the official plugin for theinvesting algorithm frameworkopen source project.InstallationYou can install the plugin with pip.pipinstalleltyer-investing-algorithm-frameworkUsageExample trading bot using binance data using the eltyer components.importosfrominvesting_algorithm_frameworkimportAlgorithmContextfromeltyer_investing_algorithm_framework.setupimportcreate_appdir_path=os.path.abspath(os.path.join(os.path.realpath(__file__),os.pardir))app=create_app(resource_directory=dir_path,key="<YOUR_ELTYER_TRADING_BOT_API_KEY>")@app.algorithm.strategy(time_unit="SECOND",interval=5,data_provider_identifier="BINANCE",target_symbol="BTC",trading_data_type="TICKER",)defperform_strategy(context:AlgorithmContext,ticker):print("Running my strategy")if__name__=="__main__":app.start()DocumentationYou can find the official documentation at ourdocumentation website