Saravanan666/pypi-org huggingface dataset:
Package: emtransmission
emtransmissionemtransmission is collecting data sysstem for Electronic monitoring reporter.
this system collect the image data in shipe and transfer the image data to system of shore side
using ftpInstallingInstall from PyPIpip install emtransmissionUsagegenerate the config.ini file[DEFAULT]
GEOMETRY = 1200x550
VIDEOCAPTURE = 0
PATH = recoding_file
TARGET_PATH =
FTP_SERVER_IP =
FTP_ID =
FTP_PASS =
#DIVX or XVID
CODEC = DIVX
#Setting to AUTO or MANUAL
FPS = AUTO
#if u setting to AUTO it's not available
FPS_SET = 10
SETTING_FRAME_CNT = 1000
SNAP_FREQ = 10[IP]
GEOMETRY = 1200x550
VIDEOCAPTURE =
PATH = recoding_file
TARGET_PATH =
FTP_SERVER_IP =
FTP_ID =
FTP_PASS =
#DIVX or XVID
CODEC = DIVX
#Setting to AUTO or MANUAL
FPS = MANUAL
#if u setting to AUTO it's not available
FPS_SET = 10
SETTING_FRAME_CNT = 1000
SNAP_FREQ = 10import that package and runfromemtransmission.fk_recodingimportFk_viewerenv='default'# or 'ip't=Fk_viewer(env)TODO
Package: emtrees
emtreesTree-based machine learning classifiers for microcontroller and embedded systems.
Train in Python, then do inference on any device with support for C.Want Naive Bayes instead? Go toembayesKey featuresEmbedded-friendly InferencePortable C99 codeNo libc requiredNo dynamic allocationsInteger/fixed-point math onlySingle header file includeFast, sub-millisecond classificationMemory efficient. Can run with<100 bytes RAMConvenient TrainingAPI-compatible withscikit-learnImplemented in Python 3C classifier accessible in Python using pybind11MIT licensedCan be used as an open source alternative to MATLAB Classification Trees,
Decision Trees using MATLAB Coder for C/C++ code generation.fitctree,fitcensemble,TreeBagger,ClassificationEnsemble,CompactTreeBaggerStatusMinimally usefulRandom Forests and ExtraTrees classifiers implementedTested running on AVR Atmega, ESP8266 and Linux.On ESP8266, 8x8 digits classify in under 0.3ms with 95%+ accuracyOn Linux, is approx 2x faster than sklearnInstallingInstall from PyPIpip install emtrees --userUsageTrain your model in Pythonimportemtreesestimator=emtrees.RandomForest(n_estimators=10,max_depth=10)estimator.fit(X_train,Y_train)...Generate C codecode=estimator.output_c('sonar')withopen('sonar.h','w')asf:f.write(code)Use the C code#include<emtrees.h>#include"sonar.h"constint32_tlength=60;int32_tvalues[length]={...};constint32_tpredicted_class=sonar_predict(values,length):For full example code, seeexamples/digits.pyandemtrees.inoTODO0.2Standalone example application on microcontrollerInclude emtrees.h inline in generated code1.0Support returning probabilitiesSupport serializing/deserializing treesProbablySupport sklearn GradientBoostingClassifierSupport regression treesSupport weighted votingImplement Isolation Forests (requires path/depths)MaybeSupportXGBoostlearning of treesSupportLightGBMlearning of treesSupportCatBoostlearning of treesSupport/Implement a Very Fast Decision Tree (VFDT) learning algorithmImplement multithreading when used in Python bindings, using OpenMP
Package: emtvlcapi
EMTVLC-APIPython module that retrieves bus times for a given stop and stops within an extent.Data from EMT valencia.pipModule is available atPyPIand can be installed via pip:pip install emtvlcapiUsageAll methods return a list containing the resultsGet bus times for a given stop id and optionally a bus number:import emtvlcapi

# get bus times for stop 508
response = emtvlcapi.get_bus_times(508)
print(response)

# get bus times for stop 508 and line 93
response = emtvlcapi.get_bus_times(508, 93)
print(response)Output:[{'linea': '70', 'destino': 'Alboraia', 'minutos': '13'}, 
{'linea': '93', 'destino': 'Pass. Marítim', 'minutos': '15'}, 
{'linea': '93', 'destino': 'Pass. Marítim', 'minutos': '29'}, 
{'linea': '70', 'destino': 'Alboraia', 'minutos': '31'}, 
{'linea': 'N4', 'destino': 'Est.del Nord', 'horaLlegada': '22:41'}, 
{'linea': 'N4', 'destino': 'Est.del Nord', 'horaLlegada': '23:32'}]


[{'linea': '93', 'destino': 'Pass. Marítim', 'minutos': '14'}, 
{'linea': '93', 'destino': 'Pass. Marítim', 'minutos': '28'}]Get stops within the rectangle created by 2 lat-lon points in opposite corners:import emtvlcapi

response = emtvlcapi.get_stops_in_extent(39.471964, -0.394641, 39.474714, -0.405906)
print(response)Output:[{
	'lat': '39.4720832588597', 
	'lon': '-0.40559318566979', 
	'name': "Nou d'Octubre (par) - Democràcia", 
	'routes': [
		{'headSign': 'Tres Creus', 'id_linea': '73', 'LN': 'Tres Creus', 'SN': '73', 'type': 'A'}, 
		{'headSign': 'Hospital General', 'id_linea': '95', 'LN': 'Hospital General', 'SN': '95', 'type': 'A'}, 
		{...}
	], 
	'stopId': '2070', 
	'ubica': 'C NUEVE DE OCTUBRE 8 ACC - VALÈNCIA'
}, {
	...
}]cliThe repo also includes a python cli with a working example$ python -m emtvlcapi bus_times 508
Parada 508
	70 (Alboraia): 5 minutes left
	93 (Pass. Marítim): 13 minutes left
	70 (Alboraia): 22 minutes left
	93 (Pass. Marítim): 12:34$ python -m emtvlcapi stops_in_extent 39.471964 -0.394641 39.474714 -0.405906
Paradas en [ 39.471964 , -0.394641 ; 39.474714 , -0.405906 ] ->

	2070 - Nou d'Octubre (par) - Democràcia
		LatLon: 39.4720832588597, -0.40559318566979
		Lineas:
			73 - Tres Creus
			95 - Hospital General
			98 - Av. del cid
			99 - la Malva-rosa
	
	...
Package: emu86
Emu86 KernelThe Emu86 kernel emulates Intel assembly language in Jupyter notebooks.Installation Instructions in Terminalpip install emu86python -m kernels.intel.installUsing Emu86 Kernel in Jupyter NotebookTypejupyter notebookin terminalAfter jupyter notebook launches in browser, click theNewdropdown on the upper right and then click onIntelMore Information About Emu86 KernelRulebookSample Jupyter Notebook Giving an Introduction to Assembly Language TutorialUpdate to Latest Version in Terminal (if you already have Emu86 Kernel Installed)pip install emu86==LATEST_VERSION_NUMBERFind the latest versionhereeg: if latest version number is 0.0.2:pip install emu86==0.0.2Uninstallation Instruction in Terminalpython -m kernels.intel.uninstallASM_Comment_ShortcutAn extension that adds a keyboard shortcut to comment/uncomment Emu86 Kernel code in Jupyter Notebook.
Package: emukit
Emukit|||Website|Documentation|Contribution GuideEmukit is a highly adaptable Python toolkit for enriching decision making under uncertainty. This is particularly pertinent to complex systems where data is scarce or difficult to acquire. In these scenarios, propagating well-calibrated uncertainty estimates within a design loop or computational pipeline ensures that constrained resources are used effectively.The main features currently available in Emukit are:Multi-fidelity emulation:build surrogate models when data is obtained from multiple information sources that have different fidelity and/or cost;Bayesian optimisation:optimise physical experiments and tune parameters of machine learning algorithms;Experimental design/Active learning:design the most informative experiments and perform active learning with machine learning models;Sensitivity analysis:analyse the influence of inputs on the outputs of a given system;Bayesian quadrature:efficiently compute the integrals of functions that are expensive to evaluate.Emukit is agnostic to the underlying modelling framework, which means you can use any tool of your choice in the Python ecosystem to build the machine learning model, and still be able to use Emukit.InstallationTo install emukit, simply runpip install emukitFor other install options, see ourdocumentation.Dependencies / PrerequisitesEmukit's primary dependencies are Numpy and GPy.
Seerequirements.Getting startedFor examples see ourtutorial notebooks.DocumentationTo learn more about Emukit, refer to ourdocumentation.To learn about emulation as a concept, check out theEmukit playgroundproject.Citing the libraryIf you are using emukit, we would appreciate if you could cite our paper about Emukit in your research:@inproceedings{emukit2019,
  author = {Paleyes, Andrei and Pullin, Mark and Mahsereci, Maren and McCollum, Cliff and Lawrence, Neil and González, Javier},
  title = {Emulation of physical processes with Emukit},
  booktitle = {Second Workshop on Machine Learning and the Physical Sciences, NeurIPS},
  year = {2019}
}The paper itself can be found onarXiv.LicenseEmukit is licensed under Apache 2.0. Please refer toLICENSEandNOTICEfor further license information.
Package: emulaterest
WSGI middleware that does Rails style PUT and DELETE request emulation.The middleware intercepts the wrapped application’s response and looks
for forms withmethod="PUT"ormethod="DELETE". For each such form
it replaces the value ofmethodwith “POST” and adds a hidden input
field_methodthat contains the original request method.
It also intercepts incoming requests and does the inverse transformation.What this all means is that you can use PUT and DELETE forms in your
HTML code, without having to worry about browser support for these
request methods.InstallYou can install EmulateRest fromPyPI:easy_install emulaterestor you can install the latest version from thegithub repository:git clone git://github.com/abiczo/emulaterest.git
cd emulaterest
python setup.py installNotesFortext/htmldocuments the default behavior is to inject HTML style<input>elements. You can tell EmulateRest to inject XHTML style<input/>elements either by using theforce_xhtmloption or by
serving your documents asapplication/xhtml+xml.If you are using a gzipping middleware or any other middleware that modifies
the content-encoding, make sure that EmulateRest is wrapped in that
middleware and not the other way round.ExampleA complete working example usingweb.py:import web

urls = ('/', 'index')

class index:
    def GET(self):
        web.ctx['headers'].append(('Content-Type', 'text/html'))
        return """<html><head><title>PUT test</title></head><body><div>
            <form method="PUT" action="/">
                <div>
                    <input type="text" name="inp" value="value">
                    <input type="submit" value="Submit">
                </div>
            </form>
            </div></body></html>
            """

    def PUT(self):
        return 'PUT ' + str(web.input())

if __name__ == '__main__':
    import emulaterest
    app = web.application(urls, globals())
    app.run(emulaterest.EmulateRestMiddleware)
Package: emulator2df
Android emulators to DataFramepip install emulator2dfTested against Windows / Python 3.11 / AnacondaProvidesafunctiontogatherinformationaboutallrunningANDROIDemulatorsandtheirconnectionsbycreatingapandasDataFrameforWindows-specificoperations.Functionality:-ConnectstoallTCPdevicesusingtheprovidedADBpathandretrievestheirIPaddressesandportnumbers.-Identifiesprocessesassociatedwithvariousemulatorexecutables.-MatchestheconnectionsbetweenADBandemulatorsbasedonIPaddressesandportnumbers.-ConstructsapandasDataFramecontainingdetailsabouteachidentifiedconnectionbetweenADBandemulators.Dependencies:-pandas-psutilParameters:adb(str):PathtotheADBexecutable.DefaultissettoastandardlocationforWindows.emulator_exe(tuple):Tupleofemulatorexecutablenames(e.g.,'Ld9BoxHeadless.exe','MEmuHeadless.exe').Defaultsto('Ld9BoxHeadless.exe','MEmuHeadless.exe','HD-Player.exe','NoxVMHandle.exe').Returns:pandas.DataFrame:ADataFramecontainingdetailedinformationaboutallidentifiedconnectionsbetweenADBandemulators.ThecolumnsoftheDataFrameareprefixedwith'aa_'.Note:ThisfunctionisspecificallydesignedforWindowsandreliesonWindows-specificfunctionalities.Example:fromemulator2dfimportall_emulators_as_dfdf=all_emulators_as_df(adb=r"C:\ProgramData\anaconda3\envs\ldbot\platform-tools\adb.exe",emulator_exe=('Ld9BoxHeadless.exe','MEmuHeadless.exe','HD-Player.exe','NoxVMHandle.exe'))# df# Out[3]:#                                           aa_threads  ...                                          aa_PSUTIL# 0  [(19956, 0.765625, 0.71875), (8484, 0.0, 0.0),...  ...  psutil.Process(pid=1292, name='HD-Player.exe',...# 1  [(22392, 0.03125, 0.015625), (12392, 0.0, 0.0)...  ...  psutil.Process(pid=22188, name='NoxVMHandle.ex...# 2  [(22392, 0.03125, 0.015625), (12392, 0.0, 0.0)...  ...  psutil.Process(pid=22188, name='NoxVMHandle.ex...# 3  [(22392, 0.03125, 0.015625), (12392, 0.0, 0.0)...  ...  psutil.Process(pid=22188, name='NoxVMHandle.ex...# 4  [(22392, 0.03125, 0.015625), (12392, 0.0, 0.0)...  ...  psutil.Process(pid=22188, name='NoxVMHandle.ex...# 5  [(22392, 0.03125, 0.015625), (12392, 0.0, 0.0)...  ...  psutil.Process(pid=22188, name='NoxVMHandle.ex...# 6  [(22392, 0.03125, 0.015625), (12392, 0.0, 0.0)...  ...  psutil.Process(pid=22188, name='NoxVMHandle.ex...
Package: emulchem
emulchemA statistical emulator built using neural networks of the UCLCHEM and RADEX astronomical codes. More detail can be found in the associated paper (put paper). If you end up using this code in published work, you can cite it as follows: put citation methodFree software: MIT licenseDocumentation:https://emulchem.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-05-30)First release on PyPI.
Package: emulica
Emulica is a software library to build simulation models of production and logistic systems, with
an accent on control system design. The goal is to create a a model of the physical system, to test the control (or supervision) system agains this model. If the emulated system is sufficiently detailed, the control system can indifferently be connected to the real or emulated system.Tutorial and documentation can be found athttps://emulica.readthedocs.io/en/develop/The dependencies have been reduced as much as possible; but there are still a number
of requirements to meet:simpy, since its the discrete event sytem that is used to make simulations runmatplotlib if you want to plot resultstwisted to run the emulation model as a server
Package: emulsion
Framework EMULSION is intended for modellers in epidemiology, to help
them design, simulate, and revise complex mechanistic stochastic
models, without having to write or rewrite huge amounts of code.It comes with aDomain-Specific Languageto represent all components
of epidemiological models (assumptions, model structure,
parameters…) in an explicit, intelligible and revisable way, and
thus facilitate interactions with other scientists (biologists,
veterinarians, economists…) throughout the modelling
process. EMULSION models are automatically processed by a modular
simulation engine, which, if needed, can also incorporate small code
add-ons for representing very specific features of a model.Models can use classical modelling paradigms (compartments,
individual-based models, metapopulations) and multiple scales (from
individuals to metapopulations), thanks to recent research in
Artificial Intelligence.
Package: emunium
🤖 EmuniumA Python module for automating interactions to mimic human behavior in browsers when using Selenium or Pyppeteer. Provides utilities to programmatically move the mouse cursor, click on page elements, type text, and scroll as if performed by a human user.🚀 Quickstart (with Selenium)importtimefromseleniumimportwebdriverfromselenium.webdriver.common.byimportByfromselenium.webdriver.support.uiimportWebDriverWaitfromselenium.webdriver.supportimportexpected_conditionsasECfromemuniumimportEmuniumSeleniumdriver=webdriver.Chrome()wait=WebDriverWait(driver,10)emunium=EmuniumSelenium(driver)driver.get('https://duckduckgo.com/')element=wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR,'[data-state="suggesting"]')))emunium.find_and_move(element,click=True)emunium.silent_type('Automating searches')submit=wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR,'[aria-label="Search"]')))emunium.find_and_move(submit,click=True)time.sleep(5)driver.quit()🚀 Quickstart (with Pyppeteer)importasyncioimportpyppeteerfromemuniumimportEmuniumPpeteerasyncdefmain():browser=awaitpyppeteer.launch(headless=False)page=awaitbrowser.newPage()awaitpage.bringToFront()emunium=EmuniumPpeteer(page)awaitpage.goto('https://duckduckgo.com/')element=awaitpage.waitForSelector('[data-state="suggesting"]')awaitemunium.find_and_move(element,click=True)awaitemunium.silent_type('Automating searches')submit=awaitpage.waitForSelector('[aria-label="Search"]')awaitemunium.find_and_move(submit,click=True)awaitasyncio.sleep(5)awaitbrowser.close()asyncio.get_event_loop().run_until_complete(main())🖱 Moving the MouseThefind_and_move()method moves the mouse cursor smoothly to the provided element with small randomizations in speed and path to seem human.Options:click- click the element after moving to itoffset_xandoffset_y- offset mouse position from element center⌨ Typing TextThesilent_type()method types the provided text in a "silent" way, spreading out key presses over time with small randomizations to mimic human typing.Options:characters_per_minute- typing speed in characters per minute (default 250)offset- randomization in milliseconds between key presses (default 20ms)🖱 Scrolling PagesThescroll_smoothly_to_element()method scrolls the page to bring the provided element into view using smooth scrolling.Includes timeouts and checks to handle issues scroll getting stuck.🏁 ConclusionEmunium provides a set of utilities to help automate browser interactions in a more human-like way when using Selenium. By moving the mouse, clicking, typing, and scrolling in a less robotic fashion, tests can avoid detection and run more reliably.While basic Selenium or Pyppeteer scripts can still get the job done, Emunium aims to make tests appear even more life-like. Using the randomizations and smooth behaviors it offers can be beneficial for automation projects that require avoiding detections.
Package: emuparadise-dl
Emuparadise-dlemuparadise-dl is a (maybe) helpful script to search and retrieve roms from the top rom-hosting websites out there.It was originally built because I wanted to access Emuparadise's huge database in a faster (and less javascriptish) way, but then I decided to extend the support to more sites.Installationpip3 install emuparadise-dlUsageBasic Usageemuparadise-dl"Metal Gear Solid"It will search using the search function provided by the site and It will report back the found results in a tabular format. You will be prompted to insert the ID (first column) of the rom to retrieve (or just type N to abort).To know the list of supported backend as well as a full set of options just typeemuparadise-dl-hBy default it uses emuparadise.me as backend, it is possible to use a different one withemuparadise-dl -b <backend>or to search on all the avaliable backend at once withemuparadise-dl --all(WARNING: please note that the output could be very long for common roms)FAQQ: I'm the owner of one of those backend supported by emuparadise-dl and I want you to stop supporting my site.A: Ok, I sent you an email, since you didn't reply I supposed you don't mind. However, send me an email and I'll remove support from future releasesQ: Is this a scraper?A: NO, it is a TUI search engine for roms (actually the search function is called on the backend), all the content is hosted on the sites, so you sould support the backend you are usingQ: The name sounds familiar...A: Yeah, I took inspiration from youtube-dlQ: OMG, your parsing-fu skills sucks, I bet it's possible to rewrite all those parsing in 2 linesA: Pull request or GTFO
Package: emu-power
Emu-ApiThis library allows communication with a Rainforest Automation EMU-2 device.
It is a rewrite of Rainforest's Emu-Serial-API in Python 3, and follows a similar architectural pattern where possible.InstallationThis library is distributed via pip and may be installed usingpip install emu-power.UsageThis API can be used in asynchronous mode or synchronous mode. Technically, communication always happens asynchronously
with the Emu, but this library allows for a synchronous API to emulated.As in Rainforest's library, we do not automatically start communication once the main object is instantiated. This
is done because the EMU-2 constantly pushes data to us over the serial connection, so we want to give the consumer
control over when this channel is opened. Before any commands are issued, thestart_serial(<serial port>)method
must be called to open the serial port and begin receiving data.The serial port name is the platform-specific device that
you wish to use. Note that unlike Rainforest's library, we do not attempt to detect the host platform or set
any port prefixes - this means that the full name of the device (prefixed withCOMfor Windows or/devfor OSX
and Linux, usually) must be used.Example UsageSynchronousfrom emu_power import Emu

api = Emu(synchronous=True)
api.start_serial("/dev/tty.usbmodem146101")

# This will return an instance of InstantaneousUsage, or None on timeout.
response = api.get_instantaneous_usage()Asynchronousfrom emu_power import Emu
from emu_power.response_entities import InstantaneousUsage
import time

api = Emu()
api.start_serial("/dev/tty.usbmodem146101")

# This will return immediately. The response data will become available
# when the device responds.
api.get_instantaneous_usage()
time.sleep(5)
response = api.get_data(InstantaneousUsage)Note: In real programs using asynchronous mode, it would probably make sense to make
use of the schedule function of the EMU-2. This sets the frequency that certain events
are sent, and allows for data to be received without constant polling. The schedule may
be set using the set_schedule(...) method of the API. After the schedule is set up, the
consuming program may periodically call the get_data method to access the most recent
received data.ContributingContributions are welcome! Not all commands have been thoroughly tested yet, since I
haven't have a reason to use some of them. This library was written both to provide a
more convenient interface with the EMU-2, as well as to get some experience writing
Python modules. Functionality and style improvements suggestions are welcome.This library is based off of the XML spec for the Rainforest RAVEN, which may be foundon Rainforest Automation's website.
This spec is similar but not identical to the API that the EMU-2 uses. Some commands not
listed in this document were implemented based off of the official Python 2 library, which may
befound on Github.
Package: emusica
Extractor de músicaCon este programa puedes extraer música que está unida en un solo archivo de música a partir de una lista con sus marcas de tiempo,
también permite agregar los metadatos de la canción como el nombre de artista o album.Cada la lista tiene que tener la siguiente estructura: (El nombre no puede contener guiones)00:00 Nombre de canción 1
15:00 Nombre de canción 2
30:00 Nombre de canción 3Si quieres agregar información del artista o album se usan las opciones -a y -bPor ejemplo usando la opción -a la estructura de la lista sería la siguiente:00:00 Nombre de artista 1 - Nombre de canción 1
15:00 Nombre de artista 2 - Nombre de canción 2
30:00 Nombre de artista 3 - Nombre de canción 3Usando la opción -b la estructura sería:00:00 Nombre de album 1 - Nombre de canción 1
15:00 Nombre de album 2 - Nombre de canción 2
30:00 Nombre de album 3 - Nombre de canción 3Si se unen las 2 opciones -ab la estructura sería:00:00 Nombre de album 1 - Nombre de artista 1 - Nombre de canción 1
15:00 Nombre de album 2 - Nombre de artista 2 - Nombre de canción 2
30:00 Nombre de album 3 - Nombre de artista 3 - Nombre de canción 3Opciones del comando:-h,     --help     show this help message and exit
  
  --list    LIST     Es el nombre del archivo donde esta la lista de muscia con las marcas de tiempo.
  
  --music   MUSIC    Es el nombre del archivo de música con las canciones unidas
  
  --album,  -b       Si el archivo contiene albumes puedes agregar esta bandera. 
                     El formato del archivo para cada línea debera ser: 
                     [tiempo] [album] - [nombre]
                     
  --artist, -a       Si el archivo contiene artistas puede agregar esta bandera. 
                     El formato del archivo para cada línea debera ser: 
                     [tiempo] [artista] - [nombre]RequisitosPython 3FfmpegSistemas Operativos compatiblesWindowsLinuxMacOS