Saravanan666/pypi-org huggingface dataset:
Package: hpconfig
HeatPumpA Python module to configure heat-pump systems for sustainable heating.  We intend to include heat pumps, air
and ground sources, solar collectors, solar panels and PV-T, heating and hot tap-water systems, and more.  The
code is being developed by the research group Balanced Energy Systems of the HAN University of Applied
Sciences in Arnhem, the Netherlands and the research group of Sustainable Energy Supply of Saxion University
of Applied Sciences in Deventer, the Netherlands.
Package: hpcparse
hpcparse (HPC Scheduler/resource manager general purpose parser) is a Python library that adds functionality to parse HPC scheduler/Resource manager
infromation like Accounting, users, qos, ..etc. This librarary Fully supports SLURM, partial SGE and more to be added later
Parsers available currently are:AccountingParser “*”Parser that gets a list of jobs based on accounting information “-”Returns a list of job objects “-”AccountsParser “*”Parser that get a list of accounts “-”Returns list of account objects “-”ClusterParser “*”Parser that get a list of clusters and associated information “-”Returns a list of cluster object “-”ConfigParser “*”Parser that reads in the scheduler’s configuration imformation “-”Returns  a configuration options objectReturns a list of node objects “-”Returns a list of partition objects “-”ordering a out put is configuration options, nodes, partitionsQOSParser “*”Parser that gets a list of QOS’s for the cluster “-”Returns a list of qos objects “-”UserParser “*”Parser that gets a list of Users for the HPC “-”Returns a list of user objects “-”Prerequisites
Package: hpc-rocket
🚀 HPC RocketHPC Rocket is a tool to send slurm commands to a remote machine and monitor the job progress. It was primarily written to launch slurm jobs from a CI pipeline.InstallationYou can get the latest version of HPC Rocket on PyPI:python3 -m pip install hpc-rocketAuthenticationHPC Rocket does support authentication via password and private key. Both can be set via environment variables.Slurm configurationCurrently allsbatchconfiguration must happen in the job file.
HPC Rocket does not offer any other way of configuring your batch jobs.Configuration fileHPC Rocket uses a configuration file in YAML format containing credentials to connect to the remote machine. Additionally it allows copying files to the remote machine, copying results back to the local machine (collecting) and eventually cleaning up copied or produced files.
Note that all paths in the configuration file must be relative paths.
On the local machine paths are evaluated from the current working directory, on the remote machine from the user's home directory, unless absolute paths are specified.
If you want to overwrite existing files on the remote machine, make sure to specify theoverwriteinstruction for each file you would like to overwrite.
HPC Rocket will evaluate environment variables on theLOCALmachine in the form of${VAR}and$VARwhen parsing the config file.host:cluster.example.comuser:myuserprivate_keyfile:~/.ssh/id_rsaproxyjumps:-host:myproxy.example.comuser:myproxy-userprivate_keyfile:~/.ssh/proxy_keyfilecopy:-from:jobs/slurm.jobto:slurm.joboverwrite:true-from:bin/myexecutableto:myexecutablecollect:-from:remote_slurmresult.outto:local_slurmresult.outoverwrite:trueclean:-slurm.job-myexecutablesbatch:slurm.jobUsageLaunching a job on the remote machineUse thelaunchcommand to launch a job on the remote machine. You must provide a configuration file. The optional--watchflag makeshpc-rocketwait until your job is finished (defaults tofalse). The collection and cleaning steps in the configuration file are only executed if--watchis set.hpc-rocketlaunch--watchconfig.ymlChecking a job's statusIf a job was launched without--watchyou can still check its status using thestatuscommand.
You will need to provide a configuration file with connection data and a job ID to check.hpc-rocketstatusconfig.yml12345Monitoring a job until it finishesSimilar to thestatuscommand,hpc-rocketalso provides thewatchcommand to monitor a job's status continuously by entering a config file and a job id.hpc-rocketwatchconfig.yml12345Canceling a running jobJobs may also be canceled using thecancelcommand. Like the previous commands it accepts a config file and the id of a running job.hpc-rocketcancelconfig.yml12345
Package: hpc-scheduler
hpc-schedulerPython code to interact with an HPC scheduler.Free software: MIT licenseDocumentation:https://hpc-scheduler.readthedocs.io.Featurescreate jobscripts from templates with python (only SLURM right now)interact with the job scheduler (submit and check jobs, check accounting, group jobs)CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-09-24)First release on PyPI.
Package: hpc-sdk
hpc-sdksdk for hpc app of EU Materials-MarketPlaceInteracte with HPC through MarketPlace proxyUse/integrate HPC Gateway app by SDKThis repository provide SDK for using or integrating the HPC gateway app into other MarketPlace app.First, create ahpcinstance with:pythonfrom marketplace_hpc import HpcGatewayApp

hpc = HpcGatewayApp(
    client_id=<app_id>, # This is the HPC gateway app.
    access_token=<your_access_token>,
)The following capabilities are supported and can be called by using the SDK.Check the availability of system:hpc.heartbeat()Create a new calculation:hpc.new_job(), the resourceid will returned to list files on remote workdir, upload/downlead/delete files and the launch/delete job.Upload file:hpc.upload_file(resourceid=<resourceid>, source_path=<file_local_path>.Download file:hpc.download_file(resourceid=<resourceid>, filename=<filename>.Delete file:hpc.delete_file(resourceid=resourceid, filename=<filename>)List jobs (only CSCS deployment):hpc.list_jobs().Launch job:hpc.run_job(resourceid=<resourceid>)Delete job:hpc.delete_job(resourceid=resourceid)You can find example athttps://github.com/materials-marketplace/hpc-sdk/blob/main/hpc_api.ipynbMaterials Cloud (CSCS) deploymentThe correspond HPC-Gateway app ishttps://www.materials-marketplace.eu/app/hpc-app(ID:5fd66c68-50e9-474a-b55d-148777ae3efd) deployed on production server.Since it deployed using Materials Cloud CSCS resources provided by EPFL, it is only for test purpose and MarketPlace users who what to use it need to contact Jusong Yu @unkpcz (jusong.yu@epfl.ch) to add your MarketPlace account to the whitelist and then register your account by:curl -X POST \
   -H "Authorization:Bearer <put_your_token_here>" \
   'https://mp-hpc.herokuapp.com/user'IWM deploymentThe correspond HPC-Gateway app isHPC gateway (broker)(ID:dc67d85e-7945-49fa-bf85-3159a8358f85) deployed on staging server since RPC broker server needed.For maintainersTo create a new release, clone the repository, install development dependencies withpip install '.[dev]', and then executebumpver update.
This will:Create a tagged release with bumped version and push it to the repository.Trigger a GitHub actions workflow that creates a GitHub release.Additional notes:Use the--dryoption to preview the release change.The release tag (e.g. a/b/rc) is determined from the last release.
Use the--tagoption to switch the release tag.AcknowledgementsThis work is supported by the
the MARKETPLACE project funded byHorizon 2020under the H2020-NMBP-25-2017 call (Grant No. 760173),
Package: hpcsubway
SUBWAYSUBmit jobs in your own WAY.Installpip install hpcsubwaypython3 setup.py installor use directly by onlyexport SUBWAY_PATH=/abs/dir/for/binandexport PATH=$SUBWAY_PATH:$PATHas well asexport SUBWAY_PYTHON=python of your choice,
default ispython3.HowtoSimple Slurm ExampleTry:mkdirdemo&&cddemo
subwaydebugsetuprgd
subwayrunDocspipinstallsphnixcddocs
makehtmlThe generated html docs are living insubway/docs/_build/html.Or just check the online doc hosted inreadthedocs.Testspipinstallpytest
pytest# or if you have slurm installedpytest--slurmYou can also test full sets in docker if you don't have slurm configuredbashrun-test.sh
Package: hpc-suite
hpc_suitehpc_suiteis a python package for working with data on high performance computing (HPC) systems.Installation viapipInstallhpc_suiteusingpip(if using a shared machine, add the--userargument afterinstall)pip install hpc_suiteUpdatingUpdate the code usingpip(if using a shared machine, add the--userargument afterinstall)pip install hpc_suite --upgradeInstallation withpipeditable installOnly do this if you are developing (i.e. changing) the code.Clone a copy of this repository, preferably while within a directory called gitmkdir -p git; cd git
git clone https://gitlab.com/chilton-group/hpc_suiteNavigate to the package directorycd hpc_suite/packagesand install the package in editable mode (if using a shared machine, add the--userargument afterinstall)pip install -e .When you're done developing (i.e. your changes have been merged to the master),
or if you just want to use the current release version of the package, uninstall usingpippip uninstall hpc_suiteand follow the Installation viapipinstructions above.Building a.whlfile (Advanced)Only do this if you are told to.To build a copy of thehpc_suite.whlfile, move to thepackagedirectory.Now run./build_binaries.shThen install the.whlfile withpip(if using a shared machine, add the--userargument afterinstall)pip install dist/*.whlDocumentationThedocumentationfor this package is hosted by gitlab, and is automatically generated whenever new code is committed to themainbranch. The automatic generation of this documentation relies on a common layout for comments and docstrings within the code, seecontributingfor more information.DevelopmentBefore making changes to this repository, please follow the steps outlined in theChilton group wiki.BugsIf you believe you have a bug,please check that you are using the most up to date version of the code.If that does not fix the problem, please create an issue on GitLab detailing the following:The commands you enteredThe error messageRemember to simplify the problem as much as possible in order to provide a minimum working example, e.g. an example for a small molecule rather than one with 100000 atoms.Then, look at the code, try and figure out what you think is wrong if possible, and include this in your issue.
Package: hpctoolkit-dataframe
Operate on HPCtoolkit XML database files as pandas DataFrames.ContentsUsageInstallationRequirementsLinksUsagePlease seeexamples.ipynbfor details.InstallationFor simplest installation usepip:pip3installhpctoolkit_dataframeRequirementsPython version 3.6 or later.Python libraries as specified inrequirements.txt.Building and running tests additionally requires packages listed intest_requirements.txt.Tested on Linux, OS X and Windows.LinksHPCtoolkit:http://hpctoolkit.org/pandas.DataFrame:https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.html
Package: hpc-utils
Current release infoNameDownloadsVersionPlatformshpc - Remote Sensing packagehpcis a numpy utility packagehpcMain Featuresindixing numpy arrays in fast manner without using loopsInstalling hpcInstallinghpcfrom theconda-forgechannel can be achieved by:conda install -c conda-forge hpcIt is possible to list all of the versions ofhpcavailable on your platform with:conda search hpc --channel conda-forgeInstall from Githubto install the last development to time you can install the library from githubpip install git+https://github.com/MAfarrag/hpcpipto install the last release you can easly use pippip install hpc-utils==0.1.3Quick start>>> import hpc=======
History0.1.0 (2023-03-30)First release on PyPI.0.1.1 (2023-04-23)get_pixels works with 3d arrays0.1.2 (2023-08-30)Update dependencies0.1.3 (2023-10-31)Update dependencies
Package: hpd20
SynopsisProgram to copy kits around (shared in internet?), modify scales for melodic stuff
create chains, appl modifications on pan, volume, sweep etc.The HPD-20 can not be edited via MIDI (at least there is no SysEx documented).This small program will need backups that you create in the SYS-USB Memory menu to work with. Sorry, there is no other way to make it more interactive.
On the other hand it will help you to manage and exchange your kits with other people, create easily melody based kits
and last but not least to print your settings on some paper so you will have them ready i.e. for live performances and you just forgot some important setting.UsageInstall with pip (sudo pip install hpd20)I removed wx as it is broken on the mac (install manually: sudo pip install wx or similar)Run the program as: hpd20-uiYou need to:Create a Memorydump on a USB stick of the HPD-20 (without user instruments, as that takes too much time).Copy the file to your PC.Load it into the program using the File menu.Make your changesSave the changes it into a file with the same name pattern (from 001-100 i.e. BKUP-002.HS0).Restore on the HPD-20 from that file.Hint: don’t overwrite the original file, just in case to be save.Roadmap(x) = todo
(/) = done(/) read memory dump (BKUP-???.HS0)(/) save all kits into folder(/) load single kit from folder(/) patch simple scales with modes on instrument A(/) patch scales with different layouts (across, around, etc.)(/) retrieve note for melodic pads (instruments 348-433(/) fetch basic information from kit and pad(/) UI the whole stuff (tkinter?)patch scales on instrument Bcopy or swap kitspublish on various musician sitesedit MFX stuffMacro operations todo(/) patch scalespan over a pad-setswap left right (M1 <-> M2, M3 <-> M4, S1 <-> S8 etc…)Generic todoget more pitches from some instruments that are for now presumed in C (i.e. Roto Toms, Cowbell)
Package: hpd-20
SynopsisProgram to copy kits around (shared in internet?), modify scales for melodic stuff
create chains, appl modifications on pan, volume, sweep etc.The HPD-20 can not be edited via MIDI.
This small program will need backups that you create in the SYS-USB Memory menu to work with. Sorry, there is no other way to make it more interactive.
On the other hand it will help you to manage and exchange your kits with other people, create easily melody based kits
and last but not least to print your settings on some paper so you will have them ready i.e. for live performances and you just forgot some important setting.Roadmap(/) read memory dump (BKUP-???.HS0)(/) save all kits into folder(/) load single kit from folder(/) patch simple scales with modes on instrument A(/) patch scales with different layouts (across, around, etc.)(/) retrieve note for melodic pads (instruments 348-433fetch basic information from kit and padpatch scales on instrument Bcopy kits aroundUI the whole stuff (tkinter?)publish on various musician sitesMacro operations todopatch scalespan over a pad-setswap left right (M1 <-> M2, M3 <-> M4, S1 <-> S8 etc…)Generic todoget more pitches from some instruments that are for now presumed in C (i.e. Roto Toms, Cowbell)add unit-tests for the inplace memory manipulations
Package: hpdag
hpdagUsage:fromhpdagimportDAG,Node,Branchdataset=Node("dataset")lr=Node("lr")withDAG()asdag:datasets=Branch(dataset("the_pile")>>lr(0.001),#for example, one dataset might require specific settings than the othersdataset("c4")>>lr(0.01),)ablations=Branch(#do a type of ablation on each datasetNode("use_glu")(True,False),#run the experiment with and without the gluNode("positional_enc")("alibi","rotary"),#run the experiment with two different positional encodings)sizes=Node("size")("7b","3b")#run the experiment with two different sizesdatasets>>ablations>>sizesprint(dag)Output:Task(dataset=the_pile, lr=0.001, use_glu=True, size=7b)
Task(dataset=the_pile, lr=0.001, use_glu=True, size=3b)
Task(dataset=the_pile, lr=0.001, use_glu=False, size=7b)
Task(dataset=the_pile, lr=0.001, use_glu=False, size=3b)
Task(dataset=the_pile, lr=0.001, positional_enc=alibi, size=7b)
Task(dataset=the_pile, lr=0.001, positional_enc=alibi, size=3b)
Task(dataset=the_pile, lr=0.001, positional_enc=rotary, size=7b)
Task(dataset=the_pile, lr=0.001, positional_enc=rotary, size=3b)
Task(dataset=c4, lr=0.01, use_glu=True, size=7b)
Task(dataset=c4, lr=0.01, use_glu=True, size=3b)
Task(dataset=c4, lr=0.01, use_glu=False, size=7b)
Task(dataset=c4, lr=0.01, use_glu=False, size=3b)
Task(dataset=c4, lr=0.01, positional_enc=alibi, size=7b)
Task(dataset=c4, lr=0.01, positional_enc=alibi, size=3b)
Task(dataset=c4, lr=0.01, positional_enc=rotary, size=7b)
Task(dataset=c4, lr=0.01, positional_enc=rotary, size=3b)
Package: hpdb
HPDBCurrent version: 4.0.7dbClassinstallationpython -m pip install hpdbusagesettings.ini[database]
dbhost = myhost.mydomain.com
dbname = database_name
dbuser = database_user
dbpass = secret123Initializing from ini filefromhpdbimportdbClassdb=dbClass.from_inifile('settings.ini')Initializing directlydb=dbClass(host,dbname,user,passwd)SELECTdb.select('users',{'isactive':1})LOOKUP SPECIFIC VALUESdb.lookup('users',{'id':15},['name','active])INSERTdb.insert('users',{'name':'john','isactive':1})id=db.last_insert_id()UPDATEdb.update('users',{'name':'john'},{'active':0})DELETEdb.delete('users',{'name':'john'})QUERYdb.execute('SELECT * FROM users')Don't forget to commit when you have an innodb tabledb.commit()
Package: hpeixoto-letsencrypt-route53
## Route53 plugin for Let's Encrypt client### Before you startIt's expected that the root hosted zone for the domain in question already exists in your account.### Setup1. Create a virtual environment2. Make sure you have libssl-dev (or your regional equivalent) installed.3. Install by adding these to your requirements.txt file:```--no-binary pycparser-e git+https://github.com/certbot/certbot.git#egg=certbot-e git+https://github.com/certbot/certbot.git#egg=acme&subdirectory=acmehpeixoto-letsencrypt-route53```We need DNS01 support in certbot, which is only available in master for now.Additionally, pycparser suffers fromhttps://github.com/eliben/pycparser/issues/148, which is why we need torecompile it, which depends on `libssl-dev`.### How to use itMake sure you have access to AWS's Route53 service, either through IAM roles orvia `.aws/credentials`.To generate a certificate:```letsencrypt certonly \-n --agree-tos --email DEVOPS@COMPANY.COM \-a hpeixoto-letsencrypt-route53:auth \-d MY.DOMAIN.NAME```
Package: hpelm
High Performance toolbox for Extreme Learning Machines.--------Extreme learning machines (ELM) are a particular kind of Artificial Neural Networks,which solve classification and regression problems. Their performance is comparableto a classical Multilayer Perceptron trained with Error Back-Propagation algorithm,but the training time is up to 6 orders of magnitude smaller. (yes, a million times!)ELMs are suitable for processing huge datasets and dealing with Big Data,and this toolbox is created as their fastest and most scalable implementation.Documentation is available here: http://hpelm.readthedocs.org,it uses Numpydocs.NEW: Parallel HP-ELM tutorial! See the documentation: http://hpelm.readthedocs.orgHighlights:- Efficient matrix math implementation without bottlenecks- Efficient data storage (HDF5 file format)- Data size not limited by the available memory- GPU accelerated computations (if you have one)- Regularization and model selection (for in-memory models)Main classes:- hpelm.ELM for in-memory computations (dataset fits into RAM)- hpelm.HPELM for out-of-memory computations (dataset on disk in HDF5 format)Example usage::>>> from hpelm import ELM>>> elm = ELM(X.shape[1], T.shape[1])>>> elm.add_neurons(20, "sigm")>>> elm.add_neurons(10, "rbf_l2")>>> elm.train(X, T, "LOO")>>> Y = elm.predict(X)If you use the toolbox, cite our open access paper "High Performance Extreme Learning Machines: A Complete Toolbox for Big Data Applications" in IEEE Access.http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=7140733&newsearch=true&queryText=High%20Performance%20Extreme%20Learning%20Machines@ARTICLE{7140733,author={Akusok, A. and Bj\"{o}rk, K.-M. and Miche, Y. and Lendasse, A.},journal={Access, IEEE},title={High-Performance Extreme Learning Machines: A Complete Toolbox for Big Data Applications},year={2015},volume={3},pages={1011-1025},doi={10.1109/ACCESS.2015.2450498},ISSN={2169-3536},month={},}
Package: hpestorapi
hpestorapiPackage descriptionhpestorapi is a python library that allows a simple way to use Rest
API services for HPE storage and disk backup devices. Current version
supports:HPE 3PAR StoreServ disk arraysHPE Primera disk arraysHPE XP7 and P9500 (Command View AE Configuration manager is required)HPE StoreOnce G3 disk backup deviceHPE StoreOnce G4 disk backup deviceInstallationRequirementshpestorapi library requires:CPython 3.6+ or PyPy3 interpreterPythonrequests libraryInstallation from PyPITo download and install hpestorapi you can use pip:# pip install hpestorapiInstallation from GitHubGet a copy of source code# git clone https://github.com/HewlettPackard/python-storage-clients.git
# cd python-storage-clientsInstall the package with dependencies:# python setup.py installImport hpestorapi library to your python script:#!/usr/bin/env python3# -*- coding: utf-8 -*-importhpestorapiUsage examplefromhpestorapiimportStoreServwithStoreServ('10.0.0.1','3paruser','3parpass')asarray:array.open()status,data=array.get('system')ifstatus==200:print('Name=%s'%data["name"],'SerialNumber=%s'%data["serialNumber"],'Address=%s'%data["IPv4Addr"])DocumentationThe latest version of the documentation can be found here:htmlIssuesIf you encounter any problems, pleaseopen an issuealong with a detailed
description. Your questions are welcomed ingitter chat.Package Version NumbersThis project followsSemantic Versioning.Unit TestsYou should install docker prior to running tests. To run all unit tests:# pip install -r requirements/development.txt
# docker build -t storeserv test/storeserv
# docker build -t storeonce3 test/storeonce3
# tox
Package: hpfitter
A wrapper for the ObjectiveFuction class and HyperparameterFitter have been made, so the same optimizers and objective functions can be used for the gaussianprocess and the GP-atom.The wrapper for the ObjectiveFuction class is ObjectiveFuctionGPAtom. However, the objective functions need to inherit the ObjectiveFuctionGPAtom class instead of the ObjectiveFuction class.
The wrapper for the HyperparameterFitter class is HyperparameterFitterGPAtom.
Hard coded changes were required for the Educated_guess class (educated.py) due to missing functions in the kernel.
The prior mean from the GP-atom had to be changed, since it used the Cholesky matrix (L), which is not avavilable in the Factorization method. A constant prior mean is used here.