Saravanan666/pypi-org huggingface dataset:
Package: etpclient
Etpclient==========Installation :Poetry is required to use the client.Poetry documentationpoetryupdate
poetryinstallSample commands :poetryrunpythonclient--hostRDDMS_HOST--port9002-tMY_TOKEN

poetryrunpythonclient--hostMY_HOST--port80--sub-pathetp-tMY_TOKEN

poetryrunpythonclient--host127.0.0.1--port17000--sub-pathetp--usernamelogin--passwordpasswordTest

poetryrunpythonclient--host127.0.0.1--port5432--usernametesterlogin--passwordpasswordtesterETP supported commands :When the client is connected you can send your request.This is the help menu :[XXX]:replaceXXXwithyourvalue[XXX=Y]:replaceXXXwithyourvalue,defaultisY[[XXX]]:optionalparameter

Help:showthismenu

Quit:hardquit(noCloseSessionsent)CloseSession:closethissession

GetDataArrayMetadata[URI][PATH_IN_RESOURCE]GetDataArray[URI][PATH_IN_RESOURCE]GetDataSubArray[URI][PATH_IN_RESOURCE][START][COUNT]PutDataArray[[UUIDS]]*[DATASPACE_NAME][EPC_FILE_PATH][H5_FILE_PATH]GetDataObject[URI_1][...][URI_N]PutDataObject[FILE_PATH][[DATASPACE_NAME]]GetResources[[uri=eml:///ornotUri=DataspaceName]][[depth=1]][[SCOPE]]GetDataspaces
PutDataspace[NAME]DeleteDataspace[NAME]ConfigurationIt is possible to change the "capabilities" of your client in the prefilled RequestSession object inetpclient/etp/requester.pyTo add/remove supported protocols and request, modify the fileetpclient/etp/serverprotocols.py. Do not forget to decorate your protocols to allow the class ETPConnection to use your protocol.
Example :@ETPConnection.on(CommunicationProtocol.CORE)classmyCoreProtocol(CoreHandler):...
Package: etpproto
ETP Protocol ImplementationInstallationEtpproto-python can be installed with pip :pip install etpprotoor with poetry:poetry add etpprotoDevelopingFirst clone the repo from gitlab.git clone https://github.com/geosiris-technologies/etpproto-python.gitTo develop, you should usePoetry.Install all necessary packages (including for development) with:poetry installThen setup the Git pre-commit hook forBlackandPylintby runningpoetry run pre-commit installas therevgets updated through time to track changes of different hooks,
simply runpoetry run pre-commit autoupdateto have pre-commit install the new version.To bump a new version of the project simply publish a release name 'vX.X.X' with X replaced by your numbersTestRun tests with poetrypoetry run pytest -v --cache-clear -rf --cov=etpproto/ --cov-report=term --cov-report=html --maxfail=10Test the code validity :poetry run black .poetry run flake8 .poetry run mypy etpproto
Package: etptypes
EtptypesIntroductionETP python dev kitRequirementspython ^3.8pydantic ~1typingx ^0.6.0Version History1.0.1:Initial Release1.0.2:Bug fix for ETP array deserialisationLicenseThis project is licensed under the Apache 2.0 License - see theLICENSEfile for detailsSupportPlease enter an issue in the repo for any questions or problems.
Package: etpy
Etpy | MyEtisalat Reverse EngineeringEtpy is a Reverse Engineering of MyEtisalat Masr android application
with this package you can control your etisalat number including cash wallet with pythonfrometpyimportClientclient=Client("011xxxxxxxx")# here you must put your etisalat phone numberclient.send_verification_code()# We are using this function to send verification code to procced the login requestclient.login_with_code(input("Code ?  : "))# here you must enter the verification code recevied on your phoneprint(client.getbalance())# Printing User BalanceSaving Sessionprint(client.access_token)# printing current user sessionLogin with Saved Sessionclient.session_login("xxxxxxxxxxxxxxxxxxxxxxxxxx....")Using Etisalat Cash Functionsclient.cash_login("your cash wallet pincode")client.generate_online_shopping_card(1)# Generating Online Card with x limitclient.cash_card_online_deposit(amount,"pan","expire-month","expire-year(2 digits only)","cvv")# Deposit Wallet With Credit Card (Still Developing)client.cash_transfer("phone-number","amount-to-transfer")# transfer cash to any meeza wallet in egyptclient.wait_for_cash()# Wait for x amount and once amount is received the function will releasdInstalling Etpy$python-mpipinstalletpySupported FeaturesOTP LoginSession LoginGetting User BalanceRechage User Balanceusing scrach cardGetting Daily GiftsRedeeming Daily GiftsGetting Call LogGetting Calling NumbersGetting011OffersRedeeming011OffersCash FeaturesGetting BalanceMoney TransferWaiting For Cash PaymentGetting Transcation HistoryTo do listGetting User usage and subscriptionsOut of credit ServiceSallefny 3la notaMegabytes 3al notaCashBalance Rechrage(done)Generating Online Payments Cards(done)Cash Out(done)PurchaseBank to Wallet
Package: etradebot
ETradeBotETradeBot is an automated trading software written in Python for E-Trade accounts that allows users to execute trades
based on custom trading strategies. ETradeBot is strategy-agnostic and will execute any strategy given to it. Schedule
aFREE Consultationto learn more about how ETradeBot can fit into
your trading strategy.Warning: ETradeBot is experimental software and is in early development. Test on small dollar
accounts only. This project is not affiliated with E-Trade or any other financial institution. By using ETradeBot, you
agree to thedisclaimer. The developer is not responsible for any
losses incurred from the use of ETradeBot. Use at your own risk.FeaturesFetches real-time market data from E-Trade APIAccesses market data from the Bloomberg API or Yahoo Finance APIExecutes trade types: buy, sell, sell short, and short coverSubmits price type: market orders to E-Trade APIManages portfolio: tracks positions, balance, and performanceTrades: common stocks and ETFsGetting StartedRefer to theETradeBot documentationfor instructions on installing, configuring, and using the software.Createyour Python environment and install ETradeBot.Obtainand securely store your E-Trade credentials.Insertyour strategy into the strategies directory as a .py file.Configurea batch file to run ETradeBot.RunETradeBot in either preview or live trading mode.ScheduleETradeBot to run automatically.If you are using the Bloomberg API, you will need toInstallthe Bloomberg SDK and C++ Build Tools.
Otherwise, ETradeBot will automatically use the Yahoo Finance API.ExampleThe following example shows ETradeBot being run in Anaconda Prompt:Also see this example of ETradeBot being run within ajupyter notebook.TroubleshootingRefer to thetroubleshootingsection of the documentation if you encounter any issues.RoadmapFuture releases will include the following features:More price types: limit, stop, and other order typesMore security types: options, mutual funds, and other security typesImportant LinksETradeBot DocumentationE-Trade Developer WebsiteKeyring DocumentationAnaconda DistributionWindows Task SchedulerContributingContributions to ETradeBot are welcome! Please see thecontributing guidelinesfor more information.DisclaimerYou must fully read, understand, and agree to the full disclaimerherebefore using ETradeBot. Please note that while the developer has taken care to ensure the quality and functionality of ETradeBot, there is no guarantee that the software is free from errors or bugs. The developer does not assume responsibility or liability for any damages or losses incurred as a result of using ETradeBot. Users of ETradeBot should use the software at their own risk and verify the accuracy and correctness of its output before making any investment decisions. By using ETradeBot, users agree to release the developer from any and all liability related to their use of the software. Users should read and understand all documentation and instructions provided before using ETradeBot. If you do not agree with any part of this disclaimer, do not use ETradeBot.LicenseETradeBot is licensed under theMIT License.
Package: eTraGo
eTraGoOptimization of flexibility options for transmission grids based on PyPSAA speciality in this context is that transmission grids are described by the
380, 220 and 110 kV in Germany. Conventionally, the 110kV grid is part of the
distribution grid. The integration of the transmission and ‘upper’ distribution
grid is part of eTraGo.The focus of optimization are flexibility options with a special focus on
energy storages. Grid expansion measures are not part of this tool and will be
instead part of ‘eGo’https://github.com/openego/eGoeTraGo is documented onreadthedocs.Input dataThe grid model data for eTraGo was created with the open source tooleGon-data. The resulting data will
be pubished on theOpenEnergyPlatform.
As long as the data is not published there, a local database is needed.
We published a backup of the required tables and instruction on how to use it
on zenodo:InstallationeTraGo is designed as a Python package therefore it is mandatory to havePython 3installed. If you have a
working Python3 environment, use pypi to install the latest eTraGo version.
We highly recommend you to use a virtual environment. Use following pip
command in order to install eTraGo..$pip3installeTraGoInstallation for DevelopersClone the source code from github:$ git clone https://github.com/openego/eTraGoYou can checkout to the dev branch and create new feature branches.
For the correct work-flow, please mind theDreissen Branching ModelUse the pip -e to install eTraGo directly from the cloned repository:$ pip3 install -e /path/to/eTraGo/When you want to draw geographical features in the background of network plots,
please install cartopy:$ pip3 install cartopyIf you run into problems when using cartopy, try to install shapely without binaries:$ pip3 install shapely --no-binary shapelyUsing a virtual environmentBefore installing eTraGo,
you create a virtual environment (where you like it) and activate it:$virtualenvvenv--clear-ppython3.8$sourcevenv/bin/activate$cdvenvInside your activated virtual environment you can
install eTraGo with the pip command, as previously explained.CopyleftCode licensed under “GNU Affero General Public License Version 3 (AGPL-3.0)”
It is a collaborative work with several copyright owners:
Cite as “eTraGo” © Flensburg University of Applied Sciences, Centre for
Sustainable Energy Systems © Europa-Universität Flensburg, Centre for
Sustainable Energy Systems © DLR Institute for Networked Energy Systems”
Package: etrainee-m4-utils
E-TRAINEE_M4_UTILSA package containing utilities for classification exercises in module 4 ofe-trainee.Includes tools for preprocessing gdal-compatible rasters and ingesting them into the classification workflows,
combining classified tiles after deep learning, visualising the process and exporting results. Also included are
Spectral Angle Mapper (SAM) and Spectral Information Divergence (SID) classifiers (implementation based on pysptools).
Package: etranslate
EtranslateEtranslateis afreeandunlimitedpython library for transiting your textsInstall it#to install:pipinstalletranslate# to upgrade:pipinstalletranslate-UFeaturesFast and reliable - it usesGoogle translateAuto language detectionBulk translationsUse itThe quality from this service is not as good as web google translate. There is nothing we can do about it.It's unclear whether your ip will be blocked if you relentlessly use the service. Please feedback should you find out any information.frometranslateimporttranslate# Translate to English by defaulttranslate("Hallo Welt!")# 'Hello world!'translate("Hello world!",to="fa")# '!Ø³Ù„Ø§Ù… Ø¯Ù†ÛŒØ§'translate("Hello world!",to="de")# 'Hallo Welt!'translate("Hello world!",src="en",to="fa")# '!Ø³Ù„Ø§Ù… Ø¯Ù†ÛŒØ§'RequirementsPython >=3.7
requestsDisclaimerEtranslatemakes use of a translate interface floating around the net and is for study and research purpose only.The interface may become invalid without notice, which would renderEtranslatecompletely useless.LicensesThis project is licensed under the MIT License - see theLICENSEfile for detailsChange log0.0.1 (23/8/2021)
-------------------
- First Release

0.0.2 (23/8/2021)
-------------------
- fix some problems

0.0.3 (23/8/2021)
-------------------
- fix README.md
Package: etrc
etrcDeveloper GuideSetup# create conda environment$mambaenvcreate-fenv.yml# update conda environment$mambaenvupdate-netrc--fileenv.ymlInstallpipinstall-e.# install from pypipipinstalletrcnbdev# activate conda environment$condaactivateetrc# make sure the etrc package is installed in development mode$pipinstall-e.# make changes under nbs/ directory# ...# compile to have changes apply to the etrc package$nbdev_preparePublishing# publish to pypi$nbdev_pypi# publish to conda$nbdev_conda--build_args'-c conda-forge'$nbdev_conda--mambabuild--build_args'-c conda-forge -c dsm-72'UsageInstallationInstall latest from the GitHubrepository:$pipinstallgit+https://github.com/dsm-72/etrc.gitor fromconda$condainstall-cdsm-72etrcor frompypi$pipinstalletrcDocumentationDocumentation can be found hosted on GitHubrepositorypages. Additionally you can find
package manager specific guidelines oncondaandpypirespectively.PyTorch Documentation:TorchDataHow to Package PyTorch
Modelstorch.monitor.Eventtorchvisiontorchvision.Datasets.VisionDatasettorchvision.utils.flow_to_imagePyTorch Models to Consider:Diffusion Video
AutoEncodersConvLSTM
AutoEncoderRecurrent All Pairs Field Transforms for Optical
FlowOptical Flow Toolbox
(mmflow)torchvision.models.optical_flow.raft
Package: etripy
Etripy누구나 쉽게 인공지능 오픈 API/DATA 서비스를누구나 손쉽게 ETRI에서 제공하는 오픈 API를 사용할 수 있어요!동기 비동기 모두 지원합니다!OPEN ETRI 언어처리 API의 모든 엔드포인트가 래핑되어 있습니다(추후 음성지능 및 시각지능도 업데이트 예정입니다!)자세한 사용법은 여기를 참조해주세요!Installation$ pip install etripyExample문장 패러플라이즈 인식[동기]frometripy.syncimportAnalysisClientetri=AnalysisClient(access_key="발급받은 키값을 입력해 주세요.")# 필수 인자(API)가 들어가는 곳입니다.data=etri.paraphrase("그녀는 책을 읽는 것을 좋아한다.","독서는 그녀의 취미이다.")print(data.is_paraphrase)# 두 문장의 의미가 동등할 경우 True를, 아니라면 False를 반환합니다.문장 패러플라이즈 인식[비동기]importasynciofrometripy.clientimportAnalysisClientasyncdefmain():etri=AnalysisClient(access_key="발급받은 키값을 입력해 주세요.")# 필수 인자(API)가 들어가는 곳입니다.data=awaitetri.paraphrase("그녀는 책을 읽는 것을 좋아한다.","독서는 그녀의 취미이다.")print(data.is_paraphrase)# 두 문장의 의미가 동등할 경우 True를, 아니라면 False를 반환합니다.asyncio.run(main())
Package: etrobo-python
Python middleware for ET-ROBOCON 2023.This is a python middleware to develop embedded programs to control robots at
ET-ROBOCON 2023 which is a embedded software contest in Japan. Using this
middleware, developers can write python programs that run both in robots
(ev3dev/raspike) and simulators. See the following GitHub repository, if you
would like to know more about this middleware (This repository supports only
Japanese, and does not have a planto support English).ET-ROBOCON 2023:https://www.etrobo.jp/Github repository:https://github.com/takedarts/etrobo-python
Package: etronome
EtronomeTkinter-based metronome.To install, runpip install etronome(as in 'metronome' without the 'm'). Then, to start the metronome, runpython -m etronome 100where 100 can be replaced with whatever bpm you'd like the metronome to run at. This requires Python 3.8 or higher. The package depends on ALSA, and as a result only runs on Linux.The metronome click sound was taken fromLudwig Müllerviafreesound.org.
Package: ets
http://github.enthought.com/The Enthought Tool Suite (ETS) is a collection of components developed by
Enthought and our partners, which we use every day to construct custom
scientific applications.This project is a “meta-project wrapper” that bundles up the actual
projects.But, it also contains the ets.py module, which allows pulling all other
ETS projects from github, and other useful features.Installation:mkdir ets
cd ets
git clone git@github.com:enthought/ets.git
cd ets
python setup.py develop
cd ..
ets -h
Package: etsdemo
This package provides a GUI application for browsing and executing Python
scripts, with the intention to demonstrate how Enthought Tool Suite
packages can be used.The actual demonstration materials are not provided by this package.How to runAfter installingetsdemo, the application can be launched from the
command line prompt:$ etsdemoIt can also be launched programmatically. For example, from Python prompt:>>> from etsdemo.main import main
>>> main()How to contribute data via entry pointsAny Python package can contribute data to be viewed from the application.
To do so, define a function in the package that returns information about the
data files. For example:def info(request):
    # request is currently a placeholder, not used.
    return {
        "version": 1,
        # Name to be displayed in the node wrapping the data files.
        "name": "Project X Examples",
        # Path to a directory where data files can be found.
        "root": pkg_resources.resource_filename("my_project", "data"),
    }Then add an entry point insetup.pythat points to the newly created
function. For example:from setuptools import setup

setup(
    name="my_project",
    ...
    entry_points={
        "etsdemo_data": ["demo = my_project.info:info"],
    ...
)Launch with specific data sourcesInstead of launching the application with data collected from packages
installed in the Python environment, the demo application can be launched with
specific data sources:from etsdemo.main import main
main(
    [
        {
            "version": 1,
            "name": "Project X Examples",
            "root": pkg_resources.resource_filename("my_project", "data"),
        },
        {
            "version": 1,
            "name": "Project X Demo",
            "root": pkg_resources.resource_filename("my_project", "demo"),
        },
    ]
)Notice that the nested dictionaries follow the same schema specification
described above.DependenciesTraitsTraitsUIPyface
Package: etsdevtools
http://github.enthought.com/etsdevtoolsThe etsdevtools project includes a set of packages that can be used during the
development of a software project, for understanding, debugging, testing, and
inspecting code.etsdevtools.debug: A collection of debugging tools, not to be included
in production code. NOTE: These tools are functional, but are not being
developed or supported. They have been mainly superceded by the tools
in the Enthought Developer Tool Suite.etsdevtools.developer: A collection of
utilities, designed to ease the development and debugging of Traits-based
programs. They can be used as plug-ins to your Envisage application while
you are developing it, and then removed when you are ready to release it.etsdevtools.endo: A Traits-aware tool for processing API documentation
of Python code. It extracts not only docstrings, but also plain comments
that immediately precede variable assignments (both module-scope variables
and class attributes).PrerequisitesNumpytraits
Package: etsi-qkd-014-client
etsi_qkd_014_clientThe ETSI GS QKD 014 specification is a specification for communication between a client and a QKD module to retrieve cryptographic keys that have been exchanged using a Quantum Key Distribution protocol.The specifications can be found at the following address :https://www.etsi.org/deliver/etsi_gs/QKD/001_099/014/01.01.01_60/gs_qkd014v010101p.pdfThe current version of the software uses the version V1.1.1 of the specifications (version from 2019-02).FeaturesConnect to a QKD server, using a custom CA, key and cert;Retrieve status of the QKD server with theget_statuscommand;Retrieve a secure key using theget_keycommand;Retrieve a secure key knowing the key's ID using theget_key_with_key_IDscommand.DocumentationThe full documentation can be found athttps://etsi-qkd014-client.readthedocs.io/en/latest/.LicenseThis software is distributed under the GNU Lesser General Public License v3 (GNU LGPLv3). A copy of the complete text of the license is included with the software (the LICENSE file).The header of the license can be found below :Copyright (C) 2022 Yoann Piétri
Copyright (C) 2022 LIP6 - Sorbonne Universitéetsi-qkd-14-client is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published > by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.etsi-qkd-14-client 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 Lesser General Public License for more details.You should have received a copy of the GNU Lesser General Public License
along with etsi-qkd-14-client. If not, seehttp://www.gnu.org/licenses.CitationIf you use this software, please consider citation. Here is the biblatex entry :@software{etsi_qkd_014_client,
  author ={{Yoann Piétri}},
  title ={ETSI QKD 014 client},
  url ={https://github.com/nanoy42/etsi_qkd_014_client},
  version ={0.1.1},
  date ={2022-06-02},}If@softwareis not available, you can also use@misc{etsi_qkd_014_client,
  author ={{Yoann Piétri}},
  title ={ETSI QKD 014 client},
  url ={https://github.com/nanoy42/etsi_qkd_014_client},
  date ={2022-06-02},}Plain text citation :Yoann Piétri. (2022). ETSI QKD 014 client (0.1.1) [Computer software].https://github.com/nanoy42/etsi_qkd_014_client
Package: etsm
python etsmTiny state machine for python, seeetsmDescriptionImplement a bare bones state machine in many languages. This library aim to be simple as possible and support only basic features:states on object (owner)optional enter/exit methodsvirtual state user methodsis inunrestricted transitionsno runtime allocationInstallinclude this file into your projectetsm.pyorimport itimportetsmExampleSimpleimportetsmclassFoo:def__init__(self):self.__sm=etsm.StateMachine(self)self.__a=etsm.State(Foo.EnterA,Foo.ExitA)self.__b=etsm.State(Foo.EnterB,None)defEnterA(self):print(' ->A ',end='')defExitA(self):print(' A-> ',end='')defEnterB(self):print(' ->B ',end='')# no exit for B# def ExitB(self):#     print(' B-> ', end='')defRun(self):self.__sm.Transition(self.__a);self.__sm.Transition(self.__b);self.__sm.Transition(None);foo=Foo()foo.Run()Output : " ->A  A->  ->B "Sample:ab.pyVirtual State MethodsimportetsmclassFooState(etsm.State):def__init__(self,enter,exit,tick):super().__init__(enter,exit)self.Tick=tickclassFoo:def__init__(self):self.__sm=etsm.StateMachine(self)self.__a=FooState(None,None,Foo.TickA)self.__b=FooState(None,None,Foo.TickB)defTickA(self):print(' A ',end='')defTickB(self):print(' B ',end='')# call tick on the current state, aka virtual calldefTick(self):if(self.__sm.Current!=None):self.__sm.Current.Tick(self)defRun(self):self.Tick();self.__sm.Transition(self.__a);self.Tick();self.__sm.Transition(self.__b);self.Tick();self.__sm.Transition(None);self.Tick();foo=Foo()foo.Run()Output: " A  B "Sample:virtual_call.py
Package: etsproxy
This is the ETS proxy package, it contains the proxy modules forallETS
projects which map the old enthought namespace imports (version 3) to the
namespace-refactored ETS packages (version 4).  For example:from enthought.traits.api import HasTraitsis now simply:from traits.api import HasTraitsFor convenience this package also contains a refactor tool to convert
projects to the new namespace (such that the don’t rely on the proxy):$ ets3to4 -h
usage: ets3to4 DIRECTORY

This utility, can be used to convert projects from ETS version 3 to 4.
It simply replaces old namespace strings (e.g. 'enthought.traits.api')
to new ones (e.g. 'traits.api'), in all Python files in DIRECTORY
recursively.
Once the conversion of your project is complete, the etsproxy module
should no longer be necessary.  However, this tool is very simple and
does not catch all corner cases.This module will be removed in the future, and old-style (enthought.xxx)
imports should be converted (over time) to the new ones.