Saravanan666/pypi-org huggingface dataset:
Package: energonai
Energon-AIA service framework for large-scale model inference, Energon-AI has the following characteristics:Parallelism for Large-scale Models:With tensor parallel operations, pipeline parallel wrapper, distributed checkpoint loading, and customized CUDA kernel, EnergonAI can enable efficient parallel inference for larges-scale models.Pre-built large models:There are pre-built implementation for popular models, such as OPT. It supports the cache technique for the generation task and distributed parameter loading.Engine encapsulation：There has an abstraction layer called engine. It encapsulates the single instance multiple devices (SIMD) execution with the remote procedure call, making it acts as the single instance single device (SISD) execution.An online service system:Based on FastAPI, users can launch a web service of the distributed infernce quickly. The online service makes special optimizations for the generation task. It adopts both left padding and bucket batching techniques for improving the efficiency.For models trained byColossal-AI, they can be easily transferred to Energon-AI.
For single-device models, they require manual coding works to introduce tensor parallelism and pipeline parallelism.InstallationThere are three ways to install energonai.Install from pypipipinstallenergonaiInstall from source$gitclonegit@github.com:hpcaitech/EnergonAI.git
$pipinstall-rrequirements.txt
$pipinstall.Use docker$dockerpullhpcaitech/energon-ai:latestBuild an online OPT service in 5 minutesDownload OPT model:To launch the distributed inference service quickly, you can download the checkpoint of OPT-125Mhere. You can get details for loading other sizes of modelshere.Launch an HTTP service:To launch a service, we need to provide python scripts to describe the model type and related configurations, and start an http service.
An OPT example isEnergonAI/examples/opt.The entrance of the service is a bash scriptserver.sh.
The config of the service is atopt_config.py, which defines the model type, the checkpoint file path, the parallel strategy, and http settings. You can adapt it for your own case.
For example, set the model class as opt_125M and set the correct checkpoint path as follows. Set the tensor parallelism degree the same as your gpu number.model_class=opt_125Mcheckpoint='your_file_path'tp_init_size=#gpuNow, we can launch a service:bashserver.shThen openhttps://[ip]:[port]/docsin your browser and try out!PublicationYou can find technical details in our blog and manuscript:Build an online OPT service using Colossal-AI in 5 minutesEnergonAI: An Inference System for 10-100 Billion Parameter Transformer Models@misc{du2022energonai, 
      title={EnergonAI: An Inference System for 10-100 Billion Parameter Transformer Models}, 
      author={Jiangsu Du and Ziming Liu and Jiarui Fang and Shenggui Li and Yongbin Li and Yutong Lu and Yang You},
      year={2022},
      eprint={2209.02341},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}ContributingIf interested in making your own contribution to the project, please refer toContributingfor guidance.Thanks so much!
Package: energy
Energy is a consumable and recoverable stuff in social games. It limits how far
players can advance in each session.Players use energy to do actions like farming, housing, or social actions. Then
consumed energy will be recovered after few minutes. Recovery is the essence of
energy system. It will make players to come back to the game periodically.In popular social games such asFarmVilleorZoo InvasionorThe Sims Social, this system drives high retention rate.>>> energy = Energy(10, recovery_interval=300)
>>> print energy
<Energy 10/10>
>>> energy.use()
>>> print energy
<Energy 9/10 recover in 05:00>LinksGitHub repositorydevelopment version
Package: energy-assistant
Energy AssistantEnergy Assistant is a free, opensource Energy Management System which works together withHome AssistantandEvcc.Energy Assistant is usingEmhassin order to optimize the energy consumption of your house.Documentation and supportFor issues, please go tothe issue tracker.For feature requests, please seefeature requests.Running the Energy AssistantPreferred method: Home Assistant Add-onBy far the most convenient way to run the Energy Assistant is to install the Energy Assistant Add-on:Add the Energy Assistant repository to your Home Assistant instance.Install the Energy Assistant add-on.Alternative method: Docker imageAn alternative way to run the Energy Assistant is by running the docker image:Copy theenergy_assistant.yaml.distfile toenergy_assistant.yamland modify it to match your setup and then start the docker container in the same folder.docker run --name em -p 8080:5000 -v "$(pwd)/energy_assistant.yaml:/config/energy_assistant.yaml" ghcr.io/pail23/energy-assistant-server:latestConfigure Energy AssistantPlease find information on how to configure Energy Assistanthere.User documentationPlease consult the user documentation forEnergy Assistant.Local DevelopmentThe easiest way to get started with development is to use Visual Studio Code with devcontainers. This approach will create a preconfigured development environment with all the tools you need. This approach is enabled for the Energy Assistant frontend and the Energy Assistant backend repository.Learn more about devcontainers.Getting started:Go toEnergy Assistant backendrepository and click "fork".Clone the forked repository locally (git clone ...)Open the devcontainer in VSCodeCopyenergy_assistan.yaml.disttoenergy_assistan.yamland configure your setup (e.g. connection to Home Assistant)Press F5 to start Energy AssistantGo toEnergy Assistant frontendrepository and click "fork".Clone the forked repository locally (git clone ...)Open the devcontainer in VSCodeEnteryarn installand thenyarn devin the Terminal of VSCodeUsefull commands:./scripts/install-client.shInstall the client (Web UI) from Github in the/clientfolder in the container../scripts/lint.shrun the linter to check the code quality../scripts/create-dev-db.shcreate a new database in the root folder of the project.
Package: energy-assistant-frontend
Energy Assistant frontend (Vue PWA)The Energy Assistant frontend/panel is developed in Vue, development instructions below.Recommended IDE SetupVS Code+Volar(and disable Vetur) +TypeScript Vue Plugin (Volar).Type Support For.vueImports in TSTypeScript cannot handle type information for.vueimports by default, so we replace thetscCLI withvue-tscfor type checking. In editors, we needTypeScript Vue Plugin (Volar)to make the TypeScript language service aware of.vuetypes.If the standalone TypeScript plugin doesn't feel fast enough to you, Volar has also implemented aTake Over Modethat is more performant. You can enable it by the following steps:Disable the built-in TypeScript ExtensionRunExtensions: Show Built-in Extensionsfrom VSCode's command paletteFindTypeScript and JavaScript Language Features, right click and selectDisable (Workspace)Reload the VSCode window by runningDeveloper: Reload Windowfrom the command palette.
Package: energy-callback
2022-B : Energy and Performance tracking with TensorflowUsing Tensorflow and TensorboardTODO add usage for tensorflow and tensorboard to ensure users have their code setup in the correct formatEnergy Callback Python PackageInstall the python package for generating the callback function$pip install energy-callbackUsageImport the package, please first ensure the packages tensorflow and energy-monitor are installed as these are requirments for the package.import energy_callbackCreate a callback objectcallback = energy_callback.Callback()Args:country (str): Country for estimating gCO2e per kWh Default: 'United Kingdom'csv_path (str): Filepath to csv file to log results. Default: './tb_experiment_1.csv'For example to change the country to France and the csv path to 'my_csv.csv':callback = energy_callback.Callback('France', 'my_csv.csv')Input the callback object into the model.fit functionhistory = model.fit(x=x_train,
          y=y_train,
          epochs=5,
          validation_data=(x_test, y_test),
          callbacks=[tensorboard_callback, callback])Use callback.get_csv() to generate csv containing performance and energy values for each epoch of training. Make sure to pass in the history value from model.fit to include the tensorboard model performance metrics in the csv. Default csv filepath is 'tb_experiment_1.csv'callback.get_csv(history)Energy CalculationsThe package will check if it can access the intel-rapl directory and use the values here for
calculating joules otherwise it will use thepython-energy-monitorpackageTo estimate the co2e value the tracker uses the carbon intensity for the given country and uses the corresponding gco2/kWh value from herehttps://ourworldindata.org/grapher/carbon-intensity-electricityThe default value is United Kingdom.Using RAPL energy readingsDue to a security issue all Linux distributions are changing the permisions of the RAPL files used by the raplMonitor in this package. There is a workaround for this:sudo apt install sysfsutilsAdd this line inetc/sysfs.conf:mode class/powercap/intel-rapl:0/ = 0444rebootOr to temporarily change the permission (will reset on reboot)sudo chmod -R a+r /sys/class/powercap/intel-rapl
Package: energy-dashboard-library
Energy Dashboard Library (EDL)This is a collection of common library functions used by theEnergy
Dashboard, a
project of theEnergy Analytics
Project.OverviewCommon utility functions are used by:energy-dashboard-clidata feedsfeed generatorThis is probably only interesting to project maintainers. Tool users will want
to look atenergy-dashboard-cli.DependenciescondamakeGetting Started# only required the first time around, creates a conda environment named 'eap-dev'makesetup# activate the created conda environmentcondaactivateeap-dev# buildmakebuildPublishingEnsure that you have a valid account and that your account has permissions to push to this project.Ensure that your~/.pypircfile is up to date. Note that I'm using auth tokens below:[distutils]
index-servers=
    pypi
    testpypi

[testpypi]
repository: https://test.pypi.org/legacy/
username: __token__
password: pypi-...elided...

[pypi]
username: __token__
password: pypi-...elided...Publish to test first# publishmaketest-publishIf that worked, then publish to prod# publishmakeprod-publishLinkshttps://geohackweek.github.io/Introductory/01-conda-tutorial/https://packaging.python.org/guides/migrating-to-pypi-org/https://packaging.python.org/guides/using-testpypi/https://packaging.python.org/tutorials/packaging-projects/AuthorTodd Greenwood-Geer (Enviro Software Solutions, LLC)
Package: energydram
Version info:Compatibility:Test status:DRAM energy calculation.Current supported standards:DDR2/3/4LPDDR2/3/4GDDR5 (only for termination)byMingyu GaoReferencesMicron, Calculating Memory System Power for DDR3, tech note TN-41-01.Micron, Calculating Memory Power for DDR4 SDRAM, tech note TN-40-07.N. Jouppi, A. B. Kahng, N. Muralimanohar and V. Srinivas, CACTI-IO: CACTI With
Off-Chip Power-Area-Timing Models, IEEE Transactions on Very Large Scale
Integration (VLSI) Systems 23(7) (2015), pp. 1254-1267.
Package: energyflip-client
EnergyFlip clientClient to communicate with the API behindEnergyFlip.EnergyFlip is an app and measuring device to monitor the usage of electricity and gas in real time.Installationpip install energyflip-clientUsageSee theexampleon how to use this library.DevelopmentThis project usespipenvfor dependency and environment management.Install dependencies usingpipenv install --devTestingRun all tests usingpipenv run pytestPackagingCreate a package usingpython3 setup.py sdist bdist_wheelThis creates a package indistUpload the package usingpython3 -m twine upload dist/*
Package: energyid-webhooks
energyid-webhooks-pyLight weight Python package to interface with EnergyID WebhooksInstallationpipinstallenergyid-webhooksUsageGet your URL athttps://app.energyid.eu/integrations/WebhookInfromenergyid_webhooksimportWebhookClienturl="https://app.energyid.eu/integrations/WebhookIn/..."client=WebhookClient(url)# Get some information about the webhookprint(client.get())# Post some data to the webhookdata={'remoteId':'my-solar-inverter','remoteName':'My Solar Panels','metric':'solarPhotovoltaicProduction','metricKind':'total','unit':'kWh','interval':'P1D','data':[['2022-10-05T08:00+0200',0.004]]}client.post(data)Async usageimportasynciofromenergyid_webhooksimportWebhookClientAsyncurl="https://app.energyid.eu/integrations/WebhookIn/..."client=WebhookClientAsync(url)asyncdefmain():# Get some information about the webhookprint(awaitclient.get())# Post some data to the webhookdata={'remoteId':'my-solar-inverter','remoteName':'My Solar Panels','metric':'solarPhotovoltaicProduction','metricKind':'total','unit':'kWh','interval':'P1D','data':[['2022-10-05T08:00+0200',0.004]]}awaitclient.post(data)asyncio.run(main())Demo NotebookSeedemo.ipynbfor a demo notebook.DevelopmentSetuppython3-mvenvvenvsourcevenv/bin/activate
pipinstall-rrequirements.txt
Package: energy-logger
energy-loggerTable of ContentsInstallationLicenseEnergy Logger is a way to log 'energy inputs' to data outputs periodically. The inputs and outputs
are declared in theconfig.tomlfile. At least one input and one output should be present in the
configuration file.Energy Logger can be run on its own, or included as a module in other projects.Installationpip install energy-loggerLocal installspip install .Testingpip install '.[test]'Docspip install '.[docs]'Licenseenergy-loggeris distributed under the terms of theMITlicense.
Package: energy-machines-jupyter-reports
energy_machines_jupyter_reportsA JupyterLab extension.RequirementsJupyterLab >= 3.0Installpipinstallenergy_machines_jupyter_reportsContributingDevelopment 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 energy_machines_jupyter_reports directory# Install package in development modepipinstall-e.# Rebuild extension Typescript source after making changesjlpmrunbuildYou 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 neededjlpmrunwatch# Then 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).Uninstallpipuninstallenergy_machines_jupyter_reports
Package: energymeter
Energymeter Python ModuleThis is a Python module that implements the communication to several electricity meters and related equipment.At the moment, the following meters are supported:ABB B21, B23, A43 and similar ABB meters (Modbus Serial)SMA SunnyBoy (Modbus TCP)MultiCube metersSome base classes are also provided for you to implement new meter variants.Installationgit clone https://github.com/ElaadNL/python-energymeter
cd python-energymeter
pip3 install .UsageTo read all registers from a meter:from energymeter import ABBMeter

meter = ABBMeter(port="/dev/ttyUSB0", baudrate=38400, slaveaddress=1, model="B23")
data = meter.read()This returns a dictionary with all key-value pairs of data.To read a single register:data = meter.read('current_l1')This returns just the value (usualy a float or int).To read multiple registers:data = meter.read(['current_l1', 'voltage_l1_n'])This returns a dictionary with the requested keys and values.
Package: energyml-common2-0
<PROJECT_NAME>Installation<PROJECT_NAME> can be installed with pip :pip install <PROJECT_NAME>or with poetry:poetry add <PROJECT_NAME>Content of the moduleenergyml/eml/v2_0/gco.py energyml/eml/v2_0/commonv2.py energyml/eml/v2_0/xlink.py energyml/eml/v2_0/gmd.py energyml/eml/v2_0/gts.py energyml/eml/v2_0/gsr.py energyml/eml/v2_0/mod_3.py
Package: energyml-common2-1
<PROJECT_NAME>Installation<PROJECT_NAME> can be installed with pip :pip install <PROJECT_NAME>or with poetry:poetry add <PROJECT_NAME>Content of the moduleenergyml/eml/v2_1/gco.py energyml/eml/v2_1/commonv2.py energyml/eml/v2_1/xlink.py energyml/eml/v2_1/gmd.py energyml/eml/v2_1/gts.py energyml/eml/v2_1/gsr.py energyml/eml/v2_1/mod_3.py
Package: energyml-common2-2
<PROJECT_NAME>Installation<PROJECT_NAME> can be installed with pip :pip install <PROJECT_NAME>or with poetry:poetry add <PROJECT_NAME>Content of the moduleenergyml/eml/v2_2/gco.py energyml/eml/v2_2/commonv2.py energyml/eml/v2_2/xlink.py energyml/eml/v2_2/gmd.py energyml/eml/v2_2/gts.py energyml/eml/v2_2/gsr.py energyml/eml/v2_2/mod_3.py
Package: energyml-resqml2-0-1
energyml_resqml2_0_1Installationenergyml_resqml2_0_1 can be installed with pip :pip install energyml_resqml2_0_1or with poetry:poetry add energyml_resqml2_0_1Content of the moduleenergyml/resqml/v2_0_1/resqmlv2.py
Package: energyml-resqml2-2-dev3
energyml_resqml2_2_dev3Installationenergyml_resqml2_2_dev3 can be installed with pip :pip install energyml_resqml2_2_dev3or with poetry:poetry add energyml_resqml2_2_dev3Content of the moduleenergyml/resqml/v2_2_dev3/resqmlv2.py
Package: energy-pandas
energy-pandasAn extension of pandas to deal with building related time series such as temperature, load and energy.Installationpipinstallenergy-pandasUsagefromenergy_pandasimportEnergyDataFrame,EnergySeriesedf=EnergyDataFrame({"temp":EnergySeries(range(0,100),units="degC"),"q_heat":EnergySeries(range(0,100),units="W"),"q_cool":EnergySeries(range(0,100),units="W")},name="Zone 1")edf.units{'temp':<Unit('degree_Celsius')>,'q_heat':<Unit('watt')>,'q_cool':<Unit('watt')>}
Package: energyplus
EnergyPlus API Python BindingsThis package provides the Python bindings for accessing the EnergyPlus API to do:Functional API calls into the EnergyPlus libraryPython plugins to allow EnergyPlus to call your python scriptsRuntime actuation where you can control the EnergyPlus time stepping through callbacksData transfer API where you can get sensor/meter data from EnergyPlus and set actuator values during a simulationIn the future, access helper methods for creating input structures programmatically
Package: energyplus-api-helpers
EnergyPlus API Helper ScriptsThis project is a small library of helper functionality and, more importantly, demo scripts, for interacting with the EnergyPlus API.
The EnergyPlus Python API is not on PyPi (as of now), it simply comes with the EnergyPlus installation.
This library makes that process a bit easier, and also offers a set of demos in theenergyplus_api_helpers/demosfolder.A super minimal example using the helper class here:frompathlibimportPathfromenergyplus_api_helpers.import_helperimportEPlusAPIHelperhelper=EPlusAPIHelper(Path('/path/to/EnergyPlus-22-2-0'))api=helper.get_api_instance()state=api.state_manager.new_state()return_value=api.runtime.run_energyplus(state,['-D',helper.path_to_test_file('5ZoneAirCooled.idf')])In this example, the helper class is constructed simply by pointing it to a valid EnergyPlus install path (or build/Products directory for developers).
The helper class is then used to get an EnergyPlus API instance, which is in turn used to create a new EnergyPlus "state".
Finally, EnergyPlus is executed with some basic command line arguments passed into therun_energyplusfunction of the main EnergyPlus API.Code QualityCode is checked for style using GitHub Actions.ReleasesWhen a release is tagged, a GitHub Action workflow will create a Python wheel and upload it to the PyPi server.To install into an existing Python environment, executepip install energyplus_api_helpers
Package: energyplus-diff-analysis
CSV CompareThis is a very basic tool used for plotting and comparing csv data from two separate csv files.UsageA version of the jupyter notebook is hosted atmybinder.orgHow is this used?Open the binder (https://mybinder.org/v2/gh/mitchute/energyplus-diff-analysis/main). This may take a few minutes to build and load the container images running behind the scenes. Once completed, mybinder.org will launch the jupyter dashboard in your web browser. This looks like a file explorer.Launch the "Make_Plots.ipynb" jupyter notebook by clicking on it from the jupyter dashboard. This will launch a new tab in your browser with this notebook loaded and running.Upload your data by clicking "upload" from the jupyter dashboard. For example, you could upload and name your baseline csv file "base.csv", and your modified version csv "mod.csv".Back over on the "Make_Plots" jupyter notebook, update the names of your baseline and modified csv data files to match what you uploaded.Select how you want your data plotted. See the examples section below for additional information.To execute, you can select Cell >> Run All (or other available options). You can also run individual cells with the "shift+return" command."ExamplesExample 1 - Plotting all columns with diffsAs described, this plots all columnsplot(baseline_path, mod_path, output_path)Example 2 - Plot only one seriesIf you only want to plot a single column from the csv data, the column name can be passed explicitly to thecolsfield.plot(baseline_path, mod_path, output_path, cols="Col Name 1")Example 3 - Plot a selected set of columns from the csv dataThecolsfield also accepts a list input for when you want to plot more than one column, but not all of them.plot(baseline_path, mod_path, output_path, cols=["Col Name 1", "Col Name 2"])Example 4 - Plot one series for a specified number of rowsYou may also specify the range of rows you want to plot.plot(baseline_path, mod_path, output_path, cols="Col Name 1", low_row_num=10, high_row_num=20)Example 5 - Only plot files with diffsTo plot all files with including files without diffs, you can add theplot_all_seriesflag and set it toTrue.plot(baseline_path, mod_path, output_path, plot_all_series=True)Example 6 - Zip plotsYou can also zip your plots once plotting is complete for easier downloading.plot(baseline_path, mod_path, output_path, create_archive=True)Command Line InterfaceThere's also a command line interface.$energyplus_diffs--help
Usage:eplus-diff[OPTIONS]BASELINE_CSVMODIFIED_CSVOUTPUT_DIR

Options:-p,--plot-all-seriesPlotallseriesincludingserieswithoutdiffs-a,--create-archiveCreatearchiveofplotsafterwards--helpShowthismessageandexit.
Package: energyplus-launch
EnergyPlus LaunchCross platform replacement for EP-Launch for EnergyPlus, written in Python using thetkintergraphics library.DocumentationThe project is documented (currently very sparsely) using Sphinx, and automatically generated inhtmlby ReadTheDocs.TestingThe project is tested using standard Python unit testing practices.
Each commit is automatically tested with Github Actions on Windows, Mac, Ubuntu 20.04 and Ubuntu 22.04.
The code coverage across platforms is collected on Coveralls.ReleasesWhen a tag is created in the GitHub Repo, Github Actions builds a Python wheel and uploads it to PyPi:https://pypi.org/project/ep-launch/.
The packages can be downloaded using standardpip install energyplus-launchcommands.
Once Pip installed, desktop shortcuts and launchers can be configured using theenergyplus-launch-configurecommand from the same Python environment.DevelopmentBasic development dependencies are installed withpip install -r requirements.txt.
This cross platform GUI application is built around the tkinter framework, so no additional dependencies are needed for the GUI.
The application can be run by executing the module aspython -m eplaunchfile.
To run the unit test suite, simply executenosetests.
Unit test results will appear in the console, and coverage results will be in acoverdirectory.