Saravanan666/pypi-org huggingface dataset:
Package: elucidata
Parser en PythonDescriptionCe repo contient le code d'un module python permettant de parser du code source pour en extraire des indicateurs.InstallationDepuis Git bash :Cloner le projet (master)cd parserpip install -r requirements.txtpy.testContributionCloner le projetCréer une nouvelle brancheCheck out la brancheCommit et push du codeCréer un PR et alerter l'équipeConventionLe code et les commentaires seront de préférence en FrançaisOn utilisera Python 3.7Le linter sera PyLintDocumentationSchema des classes
Package: elu-core
Eingebettete Systeme ELU coreEinleitungModulGithubPip3OptionalEinleitungDas Projekt "Elektronische Lastenunterstützung" (ELU) ist im Rahmen des Studiummodules "Eingebettete Systeme" entstanden.Das Projekt soll Menschen helfen, die nicht mehr in der Lage sind schwer Lasten/Objekte zu tragen.Auf den Roboter muss lediglich die "Last" abgelegt werden.Anschließend kann über die Handyapp der Roboter gesteuert werden.Mögliche Einsatzgebiete sind:Transport von Getränkekisten oder EinkaufstaschenTransport von Blumen, Erde und weitere Artikel die zur Gartenarbeit benötigt werdenModulDieses Modul ist eins von insgesammt drei Komponenten, welches für die
die Steuerung der Hardware zuständig ist.Das Projekt zielt darauf ab auf einem Raspberry Pi lauffähig zu sein.Das Modul wurde auf einem Raspberry Pi 3b+ getestet.Modul startenDas Projekt kann über Github oder Pip3 heruntergeladen und genutzt werden.GithubDas Projekt mit dem Befehlgitclonegit@github.com:MaFa961/Eingebettete_Systeme_ELU_core.githerunterladen.Anschließend in das Projektverzeichnis wechselncdEingebettete_Systeme_ELU_coreDas Core Modul wird mit dem Konsolenbefehl./run.shgestartet.Es muss sichergestellt werden,das das Server Modul ebenfalls gestartet wurde.https://github.com/MaFa961/Eingebettete_Systeme_ELU_ServerPip3Installieren von virtualenvpip3installvirtualenvEin Projektverzeichnis erstellen und in das Verzeichnis wechselnmkdirproject_folder&&cdproject_folderDie virtualenv startenvirtualenvvenvDas vitrualenv aktivierensourcevenv/bin/activateEine requirements.txt erstellen und Abhängigkeiten einfügenecho"elu_coreRPi.GPIO==0.6.4requests">>requirements.txtDie Abhängigkeiten installierenpip3install-rrequirements.txtDas Projekt importieren und nutzen.Dies funktioniert nur auf einem Raspberry Pi.importelu_core.mainelu_core.main.startCore()Optional:Für den Fall, dass nach dem herunterladen von Github dasrun.shScript nicht ausführbar ist,
muss folgender Befehl eingegeben werden:chmod+xrun.shgegebenenfalls muss das Ganze mitsudoausgeführt werden.
Package: el-user
=====Data Karyawan=====Data karyawan adalah aplikasi berbasis web yang menghandlepembuatan user. Aplikasi ini juga mengirimkan email notifikasikepada user baru untuk aktivasi akun serta merubah password.Detailed documentation is in the "docs" directory.Quick start-----------1. Add "datakaryawan" to your INSTALLED_APPS setting like this::INSTALLED_APPS = [...'datakaryawan',]2. Include the datakaryawan URLconf in your project urls.py like this::path('datakaryawan/', include('datakaryawan.urls')),3. Run `python manage.py migrate` to create the datakaryawan models.4. Start the development server and visit http://127.0.0.1:8000/admin/to create a datakaryawan (you'll need the Admin app enabled).5. Visit http://127.0.0.1:8000/datakaryawan/ untuk mulai menggunakan aplikasi data karyawan.
Package: elu-server
Eingebettete_Systeme_ELU_coreEinleitungModulGithubPip3OptionalEinleitungDas Projekt "Elektronische Lastenunterstützung" (ELU) ist im Rahmen des Studiummodules "Eingebettete Systeme" entstanden.Das Projekt soll Menschen helfen, die nicht mehr in der Lage sind schwer Lasten/Objekte zu tragen.Auf den Roboter muss lediglich die "Last" abgelegt werden.Anschließend kann über die Handyapp der Roboter gesteuert werden.Mögliche Einsatzgebiete sind:Transport von Getränkekisten oder EinkaufstaschenTransport von Blumen, Erde und weitere Artikel die zur Gartenarbeit benötigt werdenModulDieses Modul ist eins von insgesammt drei Komponenten, welches für
die Kommunikation zwischen der Handyapp und des Hardwaremodules zuständig ist.Das Projekt zielt darauf ab auf einem Raspberry Pi lauffähig zu sein.Das Modul wurde auf einem Raspberry Pi 3b+ getestet.Modul startenDas Projekt kann entweder über Github oder mit Pip3 heruntergeladen und genutzt werden.GithubDas Projekt mit dem Befehlgit clone git@github.com:MaFa961Eingebettete_Systeme_ELU_Server.githerunterladen.Anschließend in das Projektverzeichnis wechselncd Eingebettete_Systeme_ELU_ServerDer Server wird mit dem Konsolen befehl./run.shgestartet.Es muss sichergestellt werden,dass das Core Modul ebenfalls gestartet wurde.https://github.com/MaFa961/Eingebettete_Systeme_ELU_corePip3Installation von virtualenvpip3 install virtualenvEin Projektverzeichnis erstellen und in das Verzeichnis wechselnmkdir project_folder && cd project_folderDie virtualenv startenvirtualenv venvDie vitrualenv aktivierensource venv/bin/activateInstall elu_serverpip3 install elu-serverDas Projekt importieren und nutzen.importserver.mainserver.main.startServer()Optional:Für den Fall, dass nach dem herunterladen von Github dasrun.shScript nicht ausführbar ist,muss folgender Befehl eingegeben werden:chmod +x run.shgegebenenfalls muss das Ganze mitsudoausgeführt werden.
Package: elutils
ElUtilsA small collection of code that I find myself reusing again and agian.Change Log0.01 (2020/07/02)Initial release0.04 (2020/07/11)Minor additions0.05 (2020/07/29)Add time methods and logging0.06 (2020/08/13)Updated logging methods to not refer to config files.Add filters to list_files methodexecute_by_pool now uses create_logger0.07 (2020/09/21)added decayable data decoratoradd alias for read and write jsonadded convenience for save and load pickle0.08 (2020/09/22)rename the decorator to cache instead of bufferadd a verbose option in the decorator0.09 (2020/09/23)Fix bug in logging moduleAdd update_json method0.10 (2020/11/21)Fix bug in cache_data decorator, now has a separate cache for the same function if its called with different args.0.11 (2021/03/22)Make epoch_to_datetime convert to UTC by default.
Package: elvet
Elvet is a machine learning-based differential equation and variational problem solver.It can solve any system ofcoupled ODEs or PDEswith any boundary conditions.It can go beyond differential equations, and solve variational problems that consist of theminimization of a given functional, without computing the corresponding Euler-Lagrange equations.It can also be used forfittingany family of functions (which are viewed as a machine learning model) to a set of multi-dimensional data points.By default,Elvetusesneural networksto solve these problems. A version 2 providing other methods, includingtensor networksandquantum computing, is currently under development.Quick startTry Elvet online in Google Colaboratory through theexample notebooks.Install Elvet by runningpip install elvet. Tensorflow is required, with version between 2.4 and 2.10 (both included).The following code solves thelogistic differential equation:importelvetdefequation(x,f,df_dx):returndf_dx-f*(1-f)bc=elvet.BC(0,lambdax,f,df_dx:f-1/2)domain=elvet.box((-5,5,101))result=elvet.solver(equation,bc,domain,epochs=5e3)Where have defined the equation, in the formequation(x, f, df_dx) == 0, the "boundary" conditionf(0) - 1/2 == 0, and the domain: the interval (or "box" in elvet's terms)[-5, 5], with 101 equally spaced points. Then we use thesolverfunction to generate a solver, which contains a machine learning model. This model is, by default, a fully connected neural net with one hidden layer with 10 units and 1 unit in the input and output layers. Theepochsargument specifies over how many epochs this model is to be trained.The predictions of the trained model, which give the solution to the differential equations, can be obtained throughresult.prediction(). They can also be plotted, and compared with the analytic solution, which is just the sigmoid functionimportelvet.plottingdefanalytic_solution(x):return1/(1+elvet.math.exp(-x))elvet.plotting.plot_prediction(result,true_function=analytic_solution)This code should produce the plotDocumentationThedocumentationcontains a detailed specification of Elvet's API.CitationIf you use elvet, please citearXiv:2103.14575Bibtex:@misc{araz2021elvet,
      title={Elvet -- a neural network-based differential equation and variational problem solver}, 
      author={Jack Y. Araz and Juan Carlos Criado and Michael Spannwosky},
      year={2021},
      eprint={2103.14575},
      archivePrefix={arXiv},
      primaryClass={cs.LG}}
Package: elvia
Unofficial API bindings for Elvia's consumer facing APIsWith the Elvia API you can access information about your own power consumption and get the
current grid tariffes in Elvia's power grid.InstallationInstall from pip by using:pip install --upgrade elviaRequirementsPython 3.6+Getting access tokensElvia's APIs are available for consumers using Elvia for their grid fees (nettleie).The MeterValue and GridTariff APIs uses different authentication methods, and different tokens.Meter Value APIGet token using this guide:https://www.elvia.no/smart-forbruk/alt-om-din-strommaler/slik-gjor-du-det-aktivering-og-bruk-av-elvias-metervalueapi/Grid Tariff APIGet token by logging intohttps://elvia.portal.azure-api.net/signinand subscribe to the GridTariffAPIUsing the APIfromelviaimportElviaimportjsonimportasyncioimportos# token from elvia.no/minsidemeter_value_token=os.environ.get("ELVIA_METER_VALUE_TOKEN")# token from https://elvia.portal.azure-api.net/signingrid_tariff_token=os.environ.get("ELVIA_GRID_TARIFF_TOKEN")# the metering point id of your homemetering_point_id=os.environ.get("ELVIA_METERING_POINT_ID")elvia=Elvia(meter_value_token=meter_value_token)asyncdefget_meter_values():meter_value_client=elvia.meter_value()meter_values=awaitmeter_value_client.get_meter_values(start_time="2021-12-08T01:00:00",end_time="2021-12-08T02:00:00",metering_point_ids=[metering_point_id],include_production=True)print(json.dumps(meter_values))asyncio.run(get_meter_values())# And use it to get grid tariffselvia=Elvia(grid_tariff_token=grid_tariff_token)asyncdefget_grid_tariffs():grid_tariff_client=elvia.grid_tariff()grid_tariffs=awaitgrid_tariff_client.grid_tariffs_for_metering_points(range="today",metering_point_ids=[metering_point_id])print(json.dumps(grid_tariffs))asyncio.run(get_grid_tariffs())
Package: elwaspatid
ELastic WAve SPAce-TIme Diagramselwaspatidis a Python module for the computation of space-time diagrams for
the propagation of elastic waves in 1D rods. The rods can have impedance variations
along the propagation axis, and it is possible to consider several rods in contact.Initial conditions can be:a prescribed input force at the left end of the left (first) rod;a prescribed velocity of the left rod, which impacts the next rod.Boundary conditions can be:free end;fixed end;contact interface with another rod;infinite end (ie. anechoic condition).This module is the extention of the work of the following reference:Bacon, C. (1993). Numerical prediction of the propagation of elastic waves in
longitudinally impacted rods : Applications to Hopkinson testing.International Journal of Impact Engineering, 13(4), 527‑539.https://doi.org/10.1016/0734-743X(93)90084-KInstallationpip install elwaspatidDocumentationReadTheDocsUsageSee the examples in the documentation and in theexamplesfolder of the github source.TestingTo test the installation, run all the examples (manually, or by compiling the docs).The examples can be retrieved from theGithub repositoryor from the sectionExamples of diagrams.Note: there are no automated tests of the module, because the aim of the module is to plot propagation diagrams and the underlying data is made of large matrices. However, running all the examples will test all the functionnalities of the module and one can check that we get the expected results/diagrams (ie. the correct relfection/transmission of waves).Community guidelinesContributingContributions are welcome, be it improvements or new functionalities. Either
contact directly the author, or usePull Requests.Refering to the example calledUnder the hoodmay be a good idea before diving into the code.Reporting issues or problemsUseissues. Be sure to fully
describe your issue or problem. If applicable, provide a minimal working example
(MWE).SupportDo not forget toread the docs!Several examples are provided, showing all the available functionalities. They
should be a good starting point. Check the references (articles and books)
listed in the examples introduction if you need mechanical background.Also search forissues.
Package: elx
ELX🚧 Under constructionA lightweight Python interface for extracting and loading using the Singer.io spec.⚡ Lazy install of Singer.io taps and targets⚡ Stream parallelism for high performance⚡ Remote state management⚡ Tap catalog is available in Python for metadata purposes🔗 Native integration with Dagster🔗 Native integration with Airflow (todo)🔗 Native integration with Prefect (todo)Installationpipinstallelx--preUsageThe most basic usage is as follows. Simply define the Tap and the Target and elx will take care of the rest.fromelximportRunner,Tap,Targetrunner=Runner(Tap("git+https://gitlab.com/meltano/tap-carbon-intensity.git"),Target("target-jsonl"))runner.run()ConfigurationYou can configure the tap and target by passing aconfigdictionary to theTapandTargetconstructors. The config will be injected into the tap and target at runtime.fromelximportTap,Targettap=Tap("tap-foo",config={"api_key":"1234567890","start_date":"2020-01-01"})target=Target("target-bar",config={"file_path":"/tmp"})StateBy default, elx will store the state in the same directory as the script that is running. You can override this by passing aStateManagerto theRunnerconstructor. Behind the scenes, elx usessmart-opento be able to store the state in a variety of locations.fromelximportRunner,StateManagerrunner=Runner(tap,target,state_manager=StateManager("s3://my-bucket/my-folder"))Supported paths include:PathRequired Environment VariablesElx Extras3://my-bucket/my-folderAWS_ACCESS_KEY_IDandAWS_SECRET_ACCESS_KEYelx[s3]gs://my-bucket/my-folderGOOGLE_APPLICATION_CREDENTIALSorGOOGLE_API_TOKENelx[gs]azure://my-bucket/my-folderAZURE_STORAGE_CONNECTION_STRINGelx[azure]~/my-folderNoneNone/tmp/my-folderNoneNone(ssh|scp|sftp)://username@host//my-folderNoneNone(ssh|scp|sftp)://username:password@host//my-folderNoneNoneConfig injectionThere are certain variables that are available to inject in the tap or target config. One common use case is to place the tap data in a schema with the tap name.target=Target("target-bar",config={"default_target_schema":"{TAP_NAME}"})Supported variables:VariableExampleNOW2023-08-17T11:06:54.233086YESTERDAY2023-08-16T11:06:54.233086LAST_WEEK2023-08-10T11:06:54.233086TAP_EXECUTABLEtap-smoke-testTAP_NAMEtap_smoke_testTARGET_EXECUTABLEtarget-postgresTARGET_NAMEtarget_postgres
Package: elyadata-mq
Broker-tools is a set of utility functions that allow working with different types of broker (Kafka, RabbitMQ,...).The main goal ofBroker-toolsproject is to reduce boileplate code in all Elyadata projects that uses messqge queue or streaming functionalities, via a predefined and tested set of tools that can be used in any situation.:warning: This package is under construction, it is not yet ready for use :warning::ballot_box_with_check:	 RoadmapInitialize the project repository in bitbucketInitialize the project structureAdd an abstract class for all brokersAdd kafka Synchronus producer/consumerAdd kafka Asynchronus producer/consumer
Package: ely.advancedquery
OverviewAdvanced Query extends the Advanced Query extension to zope’s ZCatalog
(http://www.dieter.handshake.de/pyprojects/zope/AdvancedQuery.html)example buildout:[buildout]
parts =
    plone
    zope2
    productdistros
    instance
    zopepy

# Add additional egg download sources here. dist.plone.org contains archives
# of Plone packages.
find-links =
    http://dist.plone.org
    http://download.zope.org/ppix/
    http://download.zope.org/distribution/
    http://effbot.org/downloads


# Add additional eggs here
# elementtree is required by Plone
eggs =
    elementtree

# Reference any eggs you are developing here, one per line
# e.g.: develop = src/my.package
develop =
    .

[plone]
recipe = plone.recipe.plone==3.0.3

[zope2]
recipe = plone.recipe.zope2install
url = ${plone:zope2-url}

[productdistros]
recipe = plone.recipe.distros
urls =
  http://www.dieter.handshake.de/pyprojects/zope/AdvancedQuery.tgz
nested-packages =
version-suffix-packages =

[instance]
recipe = plone.recipe.zope2instance
zope2-location = ${zope2:location}
user = admin:admin
http-address = 8090
debug-mode = on
verbose-security = on

# If you want Zope to know about any additional eggs, list them here.
# This should include any development eggs you listed in develop-eggs above,
# e.g. eggs = ${buildout:eggs} ${plone:eggs} my.package
eggs =
    ely.advancedquery
    ${buildout:eggs}
    ${plone:eggs}

# If you want to register ZCML slugs for any packages, list them here.
# e.g. zcml = my.package my.other.package
zcml =
    ely.advancedquery

products =
    ${productdistros:location}
    ${plone:products}

[zopepy]
recipe = zc.recipe.egg
eggs = ${instance:eggs}
interpreter = zopepy
extra-paths = ${zope2:location}/lib/python
scripts = zopepyTo buildout and test from sourcepython2.4 bootstrap.py
./bin/buildout -N -vvv
./bin/instance test -m ely.advancedquery
Package: ely.croppableimagefield
IntroductionCroppableImageField is a drop-in replacement for the Archetype field
ImageField. Includes support for:Generating cropped thumbnails so that a collection of images can
have thumbnails with a common aspect ratio independent of their
individual aspect ratios. CroppableImageField lets you indicate
which part of the image to crop from. You can configure
CroppableImageField to crop from the top, middle or bottom of an
image.Dynamic rescaling of the original image.(Other cropping or clipping products already exist. All have slightly
varying features.)StatusIn use on several production sites.Changelog1.0b1 (2010-01-18)Initial release.
Package: ely.kupu_useragent_patch
IntroductionKupu checks the user-agent header in requests as part of
isKupuEnabled. If user-agent is empty then it will return false. This
is not so useful in those situations where it is nice to clear out
user agent, e.g. with nginx in front of squid.This patch removes that check. So far it seems pretty stable to
inflict kupu on people without the user-agent data.(A similar patch has already been applied to Products.TinyMCE.)Changelog1.2 (2009-12-16)Fix packaging problem. Would not install due to missing docs.1.1TinyMCE patch now part of TinyMCE so no longer needed.1.0Initial release
Package: ely.portlets.image
IntroductionA portlet for attaching and linking a single image in plone 3This is quite basic at present. There are some things to know:The image is stored as an OFS.Image.Image in the portlet assignment
data - this is so we get access to get method that produces useful
headers for caching, and gives us some useful parameters for creating
a tag. However, since portlet Assignments do not provide enough
context to be Locatable in the zope sense, then we need to generate
our own tag based on an assignment path saved when the portlet was
added. Since portlet assignments can’t be moved, then this is ok. It’s
all transparent to you if you are simply interested in using this.Changelog0.1 - UnreleasedInitial release
Package: elyra-streamlit-extension
Streamlit JupyterLab ExtensionAn extension to open a streamlit app within JupyterLab.RequirementsJupyterLab >= 3.0InstallTo install the extension, execute:pipinstallelyra-streamlit-extensionUninstallTo remove the extension, execute:pipuninstallelyra-streamlit-extensionTroubleshootIf you are seeing the frontend extension, but it is not working, check
that the server extension is enabled:jupyterserverextensionlistIf the server extension is installed and enabled, but you are not seeing
the frontend extension, check the frontend extension is installed:jupyterlabextensionlistContributingDevelopment installNote: You will need NodeJS to build the extension package.Thejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You may useyarnornpmin lieu ofjlpmbelow.# Clone the repo to your local environment# Change directory to the streamlit_extension directory# Install package in development modepipinstall-e.# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Server extension must be manually installed in develop modejupyterserverextensionenablestreamlit_extension# Rebuild extension Typescript source after making changesjlpmbuildYou can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.# Watch the source directory in one terminal, automatically rebuilding when neededjlpmwatch# Run JupyterLab in another terminaljupyterlabWith the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).By default, thejlpm buildcommand generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:jupyterlabbuild--minimize=FalseDevelopment uninstall# Server extension must be manually disabled in develop modejupyterserverextensiondisablestreamlit_extension
pipuninstallelyra-streamlit-extensionIn development mode, you will also need to remove the symlink created byjupyter labextension developcommand. To find its location, you can runjupyter labextension listto figure out where thelabextensionsfolder is located. Then you can remove the symlink named@elyra/streamlit-extensionwithin that folder.Packaging the extensionSeeRELEASE
Package: elysia
ElysiaElysia is an addon forattrsthat provides an alternative API for creating fields on@defined classes.InstallationpipinstallelysiaUsageElysia's sole export is theFieldsclass, which wrapsattrs.field,attrs.setters, andattrs.validatorsto
provide a more concise API for defining instance attributes.Here's a brief example of a class created withattrsand Elysia:fromdatetimeimportdatetimefromattrsimportdefinefromelysiaimportFields@defineclassUser:name:str=Fields.field()password:str=Fields.field(on_setattr=Fields.setters.validate,validator=Fields.validators.min_len(8))created_at:datetime=Fields.attr(factory=datetime.utcnow,frozen=True)TheUserclass has two__init__arguments:nameandpassword. Whenever set,passwordis validated to
ensure it's at least 8 characters long.Useralso has acreated_atattribute that can't set via an__init__argument. When aUserobject is
instantiated,created_atis set to the current time and cannot be changed afterwards.So...how does all that work, exactly?Glad you asked.There are two ways to define an attribute with Elysia:Fields.field()andFields.attr().Fields.field()defines
attributes that map to__init__arguments;Fields.attr()defines attributes that do not. Both are wrappers aroundattrs.fieldand accept all the same arguments. Likeattrs.field, all arguments toFields.field()andFields.attr()are keyword-only.Both methods also accept an optional, boolean,frozenargument. Setting it toTrueis a shortcut
foron_setattr=attrs.setters.frozen— that is, it freezes the attribute, raising an exception if you try to set it
after initialization.WarningElysia is happy to combinefrozen=Truewith anything else you pass toon_setattr, butattrs.setters.frozenwill be appliedfirst, which may not be what you expect.Fields also provides access toattrs' setters and validators viaFields.settersandFields.validators,
respectively. It makes no difference whether setters and validators are accessed throughFieldsorattrs. Do what
you like.LicenseElysia is licensed under theMIT License.