Saravanan666/pypi-org huggingface dataset:
Package: pyhelayers
HElayers SDK for homomorphic encryptionIBM HElayers is software development kit (SDK) for the practical and efficient
execution of encrypted workloads using fully homomorphic encrypted data.
HElayers is designed to enable application developers and data scientists to
seamlessly apply advanced privacy preserving techniques without requiring
specialized skills in cryptography.This package is provided under a community edition license for non-commercial
use; seelicense.
For commercial deployments and access to the source code, please contactchamliam@ie.ibm.comfor the Premium Edition
license.
Package: pyhelayerslite
HElayers SDK for homomorphic encryptionIBM HElayers is software development kit (SDK) for the practical and efficient
execution of encrypted workloads using fully homomorphic encrypted data.
HElayers is designed to enable application developers and data scientists to
seamlessly apply advanced privacy preserving techniques without requiring
specialized skills in cryptography.This package is provided under a community edition license for non-commercial
use; seelicense.
For commercial deployments and access to the source code, please contactchamliam@ie.ibm.comfor the Premium Edition
license.
Package: pyHelialux
pyHelialuxPython library to control (and get information from) Juwel's Helialux Smart Controller.Suppored featuresGet current state of the controllercurrentProfilecurrentWhitecurrentBluecurrentGreencurrentRedmanualColorSimulationEanbledmanualDaytimeSimulationEnableddeviceTimeEnable and disable manual color simulationSet the brightness of the channels manuallyExample codeimport helialux
from time import sleep

c = helialux.Controller(url="http://192.168.1.100")
print(c.get_status())

print("Start manual")
c.start_manual_color_simulation(duration=5) # enable it for 5 minutes (defaults to 60)

sleep(2)
print("just blue")
c.set_manual_color(white=0, blue=100, green=0, red = 0)

sleep(2)
print("just white")
c.set_manual_color(white=100, blue=0, green=0, red = 0)

sleep(2)
print("off")
c.set_manual_color(white=0, blue=0, green=0, red = 0)
sleep(2)
print("Stop manual")
c.stop_manual_color_simulation()Buy me a coffee :)
Package: pyhelios
pyhelios: the Helios' toolboxInstallationpipinstallpyheliosContributingThe pyhelios Python package is managed by awesome tools:poetryandtox.Create a virtual environment using poetry.poetryenvuse`whichpython`Build the pyhelios Python package (sdist and wheel).poetrybuildInstall in the previously created virtual environment.poetryinstallRun the tests.poetryrunpython-mtoxPublish to thePython Package IndexpoetrypublishIf necessary,poetrycan bump the version for you.
The new version should be a validsemverstring or a valid bump rule: patch, minor, major, prepatch, preminor, premajor, prerelease.poetryversionpatch[minor,major,prepatch,preminor,premajor,prerelease]
Package: py-helios-node
This is the beta stage of the HeliosProtocol node. It is currently under
active development and is not yet complete.InstallPy-helios-node install instructions:Make sure you have the correct version of python installed. The
version is listed at the top of this document. Caution: do not
upgrade your system python from 2 to 3 as this can cause massive
problems. Instead, we recommend installing a new version of python
usingpyenv. To install pyenv,
use the setup script foundhere. For
completeness, we will summarize the current setup steps here:Install$curl-Lhttps://github.com/pyenv/pyenv-installer/raw/master/bin/pyenv-installer|bashEdit .bashrc$vi~/.bashrcadd the linesexportPATH="~/.pyenv/bin:$PATH"eval"$(pyenvinit-)"eval"$(pyenvvirtualenv-init-)"Reload .bashrc$source~/.bashrcInstall python 3.6$pyenvinstall3.6.5Install git$sudoaptinstallgitor$sudoyuminstallgitClone this repo$gitclonehttps://github.com/Helios-Protocol/py-helios-nodeSet python environment$cdpy-helios-node$pyenvlocal3.6.5Install the Helios Node$pip3install-e.Ensure that the slow version of RLP is uninstalled, and install a
fresh copy of the fast one. This will force all external libraries
that use RLP to switch to the fast one.$pip3uninstallrlp$pip3uninstallrlp-cython$pip3installrlp-cythonConfigureThe Helios Protocol consensus mechanism is partially based on PoS. This
requires that all nodes are associated with a wallet address that has a
non-zero stake in order to run. So at this point, you have to configure
the node software to use your wallet as a source of coins to stake.Create keystore file. This is an encrypted file that stores your
private key. You will be able to create this with our wallet when it
is released. But for now, you can just create a new wallet usingMyEtherWallet, then save the wallet
file. This file will work with Helios Protocol.Place keystore file within the directory helios/keystoreConfigure node to use your keystore file. Copy
helios/helios_config.template.py to helios/helios_config.py. Then
edit the new file and tell it the filename of your keystore file to
use.Open Ports in FirewallThe node software needs to have an open path for communication with
other nodes on the network. If you have firewall software enabled, such
as iptables, then you might have to open some ports to ensure this. The
default installation of Ubuntu and Debian probably already have the
ports open. Other distros such as Centos likely have most ports closed
by default.Debian and Ubuntu$sudoiptables-IINPUT-ptcp-mtcp--dport30303-jACCEPT$sudoiptables-IINPUT-ptcp-mtcp--dport30304-jACCEPT$sudoiptables-saveCentos 7$sudofirewall-cmd--permanent–zone=public--add-port=30303/tcp$sudofirewall-cmd--permanent–zone=public--add-port=30304/tcp$sudofirewall-cmd--reloadStart the node$heliosThen enter your keystore password when prompted. This password is never
saved, it is only used to initially decrypt your keystore file.This document is still a work in progress. More details will come soon.
Package: py-helios-solc
Python wrapper around the Helios ProtocolsolcSolidity compiler.DependencyThis library requires thesolcexecutable to be present.QuickstartInstallationpipinstallpy-helios-solcSee the ethereum solc docs for more details. This is a clone of that
library except for the Helios Protocol version of solc.https://github.com/ethereum/py-solc
Package: py-helium-console-client
py-helium-console-clientAnunofficialPython Client library for theHelium Console API. Please see theAPI Specificationfor full details.InstallationThe package can be installed viapip:pip install py_helium_console_clientUsageTo use the Console API, you will first need to generate an API Key from the 'My Account' tab in theHelium Consoleweb interface. Use this key to initialize theConsoleClientclass. This wrapper exposes any of the methods in the specification (at the time of writing), which includes programmatic access for creating, querying, and deleting devices and labels.Some example commands are shown below. Seeexamples.pyfor full usage.frompy_helium_console_clientimportConsoleClientAPI_KEY='PASTE_API_KEY_HERE'client=ConsoleClient(API_KEY)# list devices on accountdevices=client.get_devices()# search for a device by uuiduuid_device=client.get_device_by_uuid(devices[0].id)# get device eventsevents=client.get_device_events(devices[0].id)# create devicecreated_device=client.create_device(name='python-client-test-device',app_key='850AFDC6F1CF2397D3FEAB8C1850E6E1',app_eui='B21C36EBBDC0D75F',dev_eui='ABA47D469E1021AF')# list labelslabels=client.get_labels()# create labelcreated_label=client.create_label('python-client-test-label')# search for label by idqueried_label=client.search_for_label(created_label.id)# add label to deviceadd_label_result=client.add_device_label(created_device.id,created_label.id)# remove label from deviceremove_label_result=client.remove_device_label(created_device.id,created_label.id)# delete devicedeleted_device_result=client.delete_device(created_device.id)# delete labeldeleted_label_result=client.delete_label(created_label.id)ContributingThis is a small project that I use for developing my own applications on the Helium Network. Please feel free to submit anissueor aPRif you find bugs or have suggestions!
Package: pyhelm
Python bindings for the Helm package managerHow to use PyHelmIn order to install a Helm chart using PyHelm, you can perform the following steps:Loading a chart using ChartBuilderfrompyhelm.chartbuilderimportChartBuilderchart=ChartBuilder({"name":"nginx-ingress","source":{"type":"repo","location":"https://kubernetes-charts.storage.googleapis.com"}})This will cause the chart to cloned locally, and any additional use ofchartwill reference the local copy.
You can also used a local chart by using"type": "directory", as well as cloning from a git repo using"type": "git"Installing a chartfrompyhelm.chartbuilderimportChartBuilderfrompyhelm.tillerimportTillertiller=Tiller(TILLER_HOST)chart=ChartBuilder({"name":"nginx-ingress","source":{"type":"repo","location":"https://kubernetes-charts.storage.googleapis.com"}})tiller.install_release(chart.get_helm_chart(),dry_run=False,namespace='default')This snippet will install thenginx-ingresschart on a Kubernetes cluster where Tiller is installed (assumingTILLER_HOSTpoints to a live Tiller instance). Take note that in most Helm installations Tiller isn’t accessible in such a manner, and you will need to perform a Kubernetes port-forward operation to access Tiller.
TheTillerclass supports other operations other than installation, including release listing, release updating, release uninstallation and getting release contents.Package versionsIn order to support multiple versions of Helm versions, which in turn require different gRPC prototypes, we maintain different PyHelm package versions.Helm versionPyHelm dependency version2.11 (and lower)pyhelm>=2.11,<2.122.14pyhelm>=2.14,<2.15Additional Helm versions can be supported as shown in the following section.Helm gRPCThe helm gRPC libraries are located in the hapi directory.  They were generated with the grpc_tools.protoc utility against Helm 2.14.  Should you wish to re-generate them you can easily do so:gitclonehttps://github.com/kubernetes/helm./helmpython-mgrpc_tools.protoc-Ihelm/_proto--python_out=.--grpc_python_out=._proto/hapi/chart/*python-mgrpc_tools.protoc-Ihelm/_proto--python_out=.--grpc_python_out=._proto/hapi/services/*python-mgrpc_tools.protoc-Ihelm/_proto--python_out=.--grpc_python_out=._proto/hapi/release/*python-mgrpc_tools.protoc-Ihelm/_proto--python_out=.--grpc_python_out=._proto/hapi/version/*
Package: pyhelm3
pyhelm3Python library for managing Helm releases using Helm 3 (i.e. Tiller-less Helm).Installationpyhelm3can be installed directly from GitHub usingpip:pipinstallgit+https://github.com/stackhpc/pyhelm3.gitUsagefrompyhelm3importClient# This will use the Kubernetes configuration from the environmentclient=Client()# Specify the kubeconfig file to useclient=Client(kubeconfig="/path/to/kubeconfig")# Specify a custom Helm executable (by default, we expect 'helm' to be on the PATH)client=Client(executable="/path/to/helm")# List the deployed releasesreleases=awaitclient.list_releases(all=True,all_namespaces=True)forreleaseinreleases:revision=awaitrelease.current_revision()print(release.name,release.namespace,revision.revision,str(revision.status))# Get the current revision for an existing releaserevision=awaitclient.get_current_revision("cert-manager",namespace="cert-manager")chart_metadata=awaitrevision.chart_metadata()print(revision.release.name,revision.release.namespace,revision.revision,str(revision.status),chart_metadata.name,chart_metadata.version)# Fetch a chartchart=awaitclient.get_chart("cert-manager",repo="https://charts.jetstack.io",version="v1.8.x")print(chart.metadata.name,chart.metadata.version)print(awaitchart.readme())# Install or upgrade a releaserevision=awaitclient.install_or_upgrade_release("cert-manager",chart,{"installCRDs":True},atomic=True,wait=True)print(revision.release.name,revision.release.namespace,revision.revision,str(revision.status))# Uninstall a release#   Via the revisionrevision=awaitclient.get_current_revision("cert-manager",namespace="cert-manager")awaitrevision.release.uninstall(wait=True)#   Or directly by nameawaitclient.uninstall_release("cert-manager",namespace="cert-manager",wait=True)
Package: pyhelp
PyHELP is an object oriented Python library providing a set of tools to estimate spatially distributed groundwater recharge and other hydrological components (runoff and evapotranspiration) using the HELP (Hydrologic Evaluation of Landfill Performance) model.PyHELP integrates weather data (from grids or stations), land conditions defined by a series of GIS maps as well as soil and geological material properties into HELP input files. PyHELP also processes HELP simulation results and outputs them as maps and graphs, including comparisons of simulation results with stream hydrographs. PyHELP thus accompanies users through the entire workflow from input file assembly to model calibration and to the documentation of results. This workflow is based on the method originally developed byCroteau et al. (2011)to assess spatially distributed groundwater recharge at the regional scale.
Package: pyhelper-misc
pyhelperPython Library Containing Generic Utilities and Helper FunctionsInstallationpip install pyhelper-miscUses# Example:
>>> from pyhelper.misc import find_all_in_dict
>>> data = {"a": {"b": "c", "d": "e"}, "f": {"g": "h"}}
>>> find_all_in_dict(data,  "d")
['e']Project Setup for DevelopmentRun Cmd:source setup.shUploaded On:https://pypi.org/project/pyhelper-misc/
Package: pyhelpers
PyHelpersPyHelpers is a lightweight open-source Python package designed as a versatile toolkit for simplifying data (pre)processing tasks. It offers a comprehensive range of practical utilities to facilitate common data manipulation operations. These utilities encompass the ability to read and write file-like objects, efficiently handle various data types such as geographical and textual data, and establish streamlined communication with relational databases like PostgreSQL and Microsoft SQL Server.InstallationTo install the latest release of PyHelpers fromPyPIviapip:pipinstall--upgradepyhelpersPlease also refer toInstallationfor more information.Quick startFor a concise guide on how to utilise PyHelpers, we recommend checking out thequick-start tutorial, which features multiple illustrative examples for each of themodules. These examples effectively demonstrate the capabilities of PyHelpers in facilitating data manipulation tasks and streamlining your work processes.DocumentationThe complete PyHelpers documentation: [HTML] [PDF].It is hosted onReadTheDocsand provides a wealth of detailed examples.LicensePyHelpers is licensed underGNU General Public License v3.0or later (GPLv3+).Cite asFu, Q. (2020). PyHelpers: an open-source toolkit for facilitating Python users' data manipulation tasks. Zenodo.doi:10.5281/zenodo.4017438@software{qian_fu_pyhelpers_4017438,author={Qian Fu},title={{PyHelpers: an open-source toolkit for facilitatingPython users' data manipulation tasks}},year=2020,publisher={Zenodo},doi={10.5281/zenodo.4017438},url={https://doi.org/10.5281/zenodo.4017438}}(Please also refer to the export options fromZenodoto reference the specific version of PyHelpers as appropriate.)ContributorsQian Fu🌱💻🧪📖Xiangyong Luo💻
Package: pyheos
pyheosAn async python library for controlling HEOS devices through the HEOS CLI Protocol (version 1.14 for players with firmware 1.505.140 or newer).Installationpipinstallpyheosorpipinstall--use-wheelpyheosGetting StartedTheHeosclass is the implementation providing control to all HEOS compatible devices on the local network through a single network connection.  It is suggested to connect to a device that is hard-wired.pyheos.Heos(host, *, timeout, heart_beat, all_progress_events, dispatcher)host: str: The IP Address or hostname of a HEOS device on the local network. This parameter is required.timeout: float: Number of seconds to wait during connection and issuing commands. Default ispyheos.const.DEFAULT_TIMEOUT = 5.0.  This parameter is required.heart_beat: Optional[float]: Number of seconds since last activity to issue a heart-beat command. Default ispyheos.const.DEFAULT_HEART_BEAT = 60.0.  Set this parameter toNoneto disable heart-beat.all_progress_events: Set toTrueto receive signals for each media play-back progression orFalseto only receive a signal when media state transitions to playing or changes.  Default isTrue.  This parameter is required.dispatcher: Optional[pyheos.Dispatcher]: An instance of dispatcher to use for raising signals.  The default isNonewhich results in use of the default dispatcher implementation.pyheos.Heos.connect(*, auto_reconnect, reconnect_delay)Connect to the specified host.  This method is a coroutine.auto_reconnect: bool: Set toTrueto automatically reconnect to the host upon disconnection.  The default isFalse.reconnect_delay: float: The number of seconds to wait before attempting to reconnect upon a connection failure. The default isDEFAULT_RECONNECT_DELAY = 5.0pyheos.Heos.disconnect()Disconnect from the specified host.  This method is a coroutine.pyheos.Heos.get_players(*, refresh)Retrieve the available players as aDict[int, pyheos.Heos.HeosPlayer]where the key represents theplayer_idand the value theHeosPlayerinstance.  This method is a coroutine.  This method will populate theplayersproperty and will begin tracking changes to the players.refresh: Set toTrueto retrieve the latest available players from the CLI. The default isFalseand will return the previous loaded players.Example:importpyheosheos=Heos('172.16.0.1')awaitheos.connect(auto_reconnect=True)players=awaitheos.get_players()...awaitheos.disconnect()
Package: pyhepmc
A Pythonic wrapper for theHepMC3 C++ library.pyhepmc was formerly known as pyhepmc-ng. The development of pyhepmc-ng continues in the pyhepmc package.HepMC3 has its own Python bindings. Why should you use these?pyhepmc is easy to installThe commandpip install pyhepmcjust works on all common platforms. Since we publish binary wheels, you don’t need to compile anything. Since we include the HepMC3 library, you don’t need to install it separately either.However, building from source is also easy. External software is not required. Just download the repository withgit clone--recursiveand runpip install-v-e..pyhepmc is Pythonic, Numpy-friendy, and Jupyter notebook-friendlypyhepmc is a hand-crafted mapping of C++ code to Python,see documentation for details, while the official HepMC3 bindings are generated by a script. The pyhepmc API has been optimised for safety, usability, and efficiency by a human expert, something that an automatic tool cannot provide. pyhepmc brings these unique features:Python idioms are supported where appropriate.Simple IO withpyhepmc.open.An alternative Numpy API accelerates event processing up to70xcompared to the standard API.The public API is fully documented with Python docstrings.Objects are inspectable in Jupyter notebooks (have usefulreprstrings).Events render as graphs in Jupyter notebooks (see next item).pyhepmc supports visualizations powered by graphvizpyhepmc can optionally visualize events, using the maturegraphvizlibrary as a backend.pyhepmc is actively maintainedpyhepmc is part of the Scikit-HEP project, which aims to provide all tools needed by particle physicists to do data analysis in Python. It is developed in close collaboration with the HepMC3 project.pyhepmc is thoroughly unit testedWe have close to 100% coverage for the Python API.DocumentationDocumentation is available here, and includes some examples (Jupyter notebooks). Furthermore, you can use Python’shelp()browser to learn about the API. The documentation is generated from Python docstrings, which are translated from theHepMC3 library, which is documented here.LicenseThe pyhepmc code is covered by the BSD 3-clause license, but its main functionality comes from bundled software which is released under different licenses. The HepMC3 library is licensed under LGPL-v3 and bundles other software which is released under different licenses. See the filesLICENSEandLICENSE_bundledin the source directory for details.
Package: pyhera
pyheraIntroductionpyherais a lightweight in-memory database management module written in python. An optimized NoSQL database which is fast. Data are stored in JSON format (key-value) thus created databases can be analyzed by other applications in different platforms.FeaturesEase of use.No complicated syntaxFast because ofmultithreading implementationIt's secure.Database is not modifiable from outsideReliable.pyhera automatically takes back-upCapable ofhandling data in any scale(As long as the hardware allows)Easy Installitionpip install pyheraCode samplesA very basic instance:importpyhera# Import pyhera moduleh=pyhera.Pool('mydb')# Create database objecth.set('foo','bar')result=h.get('foo')print(result)# Print 'bar'To compare X and pyhera:#X (a key-value series database)r=connection()r.dset('foo','bar1',1)r.dset('foo','bar2',2)r.dset('foo','bar3',3)d1=r.dget('foo','bar1')d2=r.dget('foo','bar2')d3=r.dget('foo','bar3')print(d1+d2+d3)# 6#pyhera (Above method is also possible in pyhera)h=pyhera.Pool('mydb')h.dmls('foo',{'bar1':1,'bar2':2,'bar3':3})d,sum=h.dmlg('foo'),0fork,vind.items():sum+=vprint(sum)# 6DocumentationDocumentation of pyhera project will be released as soon as possible.Developed byAli Moghimi
Package: pyhere
pyhereA Python 2.x / 3.x equivalent of R'sherepackage, drawing inspiration fromchendaniely'spyprojrootpackage, but more closely mirroring the functionality within R'shere. Relative file referencing has never been easier!InstallationpipYou can install the latest stable version with pip via:pipinstallpyhereAnd if you want to be on the bleeding edge of development, get the latest version from github:pipinstall--editable=git+https://github.com/joshpsawyer/pyhere.git#egg=pyherecondaNot in conda, yet - just install it from pip in your environment.Usagefrompyhereimporthererelative_dirA=here("your","relative","directory","file.txt")relative_dirB=here("your/relative/directory/file.txt")pyhereuses simple heuristics to find a project's root directory. FromPath.cwd(), it traverses upwards, looking for a possibleroot_indicator:root_indicators=[".here","requirements.txt","setup.py",".vscode",# vscode project".idea",# pycharm project".git",".spyderproject",# spyder".spyproject",# spyder".ropeproject"# rope]When found, it joins the arguments passed tohere()to the rootpath and returns as aPathobject. If it reaches the system root, it returns the system root and throws a warning.For a concrete example, imagine the following directory structure:\project\src\script.py
\project\data\data1.csv
\project\.hereIf you calldata=here("data","data1.csv")fromscript.py, you'll get aPathobject representing\project\data\data1.csv.