Saravanan666/pypi-org huggingface dataset:
Package: py-hd-wallet
py_hdwallet** A multi crypto-currencies HD wallet implemented by Python. **BIP32 (or HD for “hierarchical deterministic”) wallets allow you to create
child wallets which can only generate public keys and don’t expose a
private key to an insecure server.
The implementation is based on the proposal BIP32, BIP39 and is currently in audit mode.
Please do not use in production yet. Testing welcome.This library simplify the process of creating new wallets for the
BTC, BTG, BCH, ETH, LTC, DASH, DOGE, ZEC, XRP, ZCASH and XLM.Most of the code here is copied from:Ran Aroussi’spywallet <https://github.com/ranaroussi/pywallet>Devrandom’spymultiwallet <https://github.com/devrandom/pymultiwallet>Reverbel’sseed-phrases-for-stellar <https://github.com/reverbel/seed-phrases-for-stellar>I simply added support for a few more crypto-currencies.InstallationInstall via PiP:$sudopipinstallpy_hd_walletExample code:Create HD WalletThe following code creates a new Bitcoin HD wallet:# create_btc_wallet.pyfrompy_hd_walletimportwallet# generate 12 word mnemonic seedseed=wallet.generate_mnemonic()# create bitcoin walletw=wallet.create_wallet(network="bitcoin",seed=seed,children=1)print(w)# wallets = wallet.create_wallet(network="BTC", seed=seed, children=1)# wallets = wallet.create_wallet(network="ETH", seed=seed, children=1)# wallets = wallet.create_wallet(network="XRP", seed=seed, children=1)# wallets = wallet.create_wallet(network="ZCASH", seed=seed, children=1)# wallets = wallet.create_wallet(network="XLM", seed=seed, children=1)# wallets = wallet.create_wallet(network="stellar_testnet", seed=seed, children=1)Output looks like this:$pythoncreate_btc_wallet.py{"coin":"BTC","seed":"guess tiny intact poet process segment pelican bright assume avocado view lazy","address":"1HwPm2tcdakwkTTWU286crWQqTnbEkD7av","xprivate_key":"xprv9s21ZrQH143K2Dizn667UCo9oYPdTPSMWq7D5t929aXf1kfnmW79CryavzBxqbWfrYzw8jbyTKvsiuFNwr1JL2qfrUy2Kbwq4WbBPfxYGbg","xpublic_key":"xpub661MyMwAqRbcEhoTt7d7qLjtMaE7rrACt42otGYdhv4dtYzwK3RPkfJ4nEjpFQDdT8JjT3VwQ3ZKjJaeuEdpWmyw16sY9SsoY68PoXaJvfU","wif":"L1EnVJviG6jR2oovFbfxZoMp1JknTACKLzsTKqDNUwATCWpY1Fp4","children":[{"address":"1nDWAr2v1wNv6ZkjQ3GJCZq1HUHCHm1wZ","address":"1nDWAr2v1wNv6ZkjQ3GJCZq1HUHCHm1wZ","path":"m/0","wif":"KysRDiwJNkS9VPzy1UH76DrCDizsWKtEooSzikich792RVzcUaJP"}]}* Valid options fornetworkare: BTC, BTG, BCH, LTC, DASH, DOGE, XRP, ZCASH and XLM
Package: pyhdx
PyHDXPyHDX is python project which can be used to derive Gibbs free energy from HDX-MS data.PyHDX stable documentationPyHDX on YouTubeInstallationInstallation of the latest stable beta withpip:$pipinstallpyhdxInstallation with web interface extra:$pipinstallpyhdx[web]Conda install (includes web interface extra):$condainstallpyhdxRun PyHDXMost up-to-date code examples are in the directorypyhdx/templatesTo run the web server:$pyhdxservePlease refer to thedocsfor more details on how to run PyHDX.Web ApplicationThe PyHDX web application is currently hosted at:http://pyhdx.jhsmit.orgA test file can be downloaded fromhereandhere(right click, save as).A beta version might be available at:http://pyhdx-beta.jhsmit.orgThe latest beta docs are foundherePublicationOur Analytical Chemistry Publication describing PyHDX can be foundhereThe latest version (v2) of our biorxiv paper:https://doi.org/10.1101/2020.09.30.320887Python code for analysis and generation the figures in the paper are here:https://github.com/Jhsmit/PyHDX-paperOtherHDX MS datasets repository and format (alpha):https://github.com/Jhsmit/HDX-MS-datasetsHDXMS datasets python bindings:https://github.com/Jhsmit/hdxms-datasets
Package: pyheapdump
Pyheapdump allows post-mortem debugging for Python programs.It writes all relevant objects into a file and can later load
it in a Python debugger.Works best with Pydevd but also with the built-in pdb and with
other popular debuggers.This version requires Python 2.7. Unfortunately, there is currently no
Python 3 version.Git repository: git://github.com/akruis/pyheapdump.git
Package: pyheartex
pyheartexPython interface for running ML backend server and using it for active learning & prelabeling & prediction withinHeartex platformInstallationFirst make sure you haveRedis serverrunning (otherwise you can use only prediction, not active learning).Install Heartex SDK:gitclonehttps://github.com/heartexlabs/pyheartex.gitcdpyheartex/
pipinstall-rrequirements.txt
pipinstall-e.Last thing you should do is to start RQ workers in the background:rqworkerdefaultUsing DockerHere is an example how to start serving image classifier:cdexamples/docker
docker-composeupAll you need to replace with your own model is to change loading, inference and training scripts fromthis file.Quick startQuick start guide provides the usage of the following popular machine learning frameworks within Heartex platform:scikit-learnFastAIScikit-learnLet's servescikit-learnmodel for text classification.You can simply launchpythonexamples/quickstart.pyThis script looks likefromhtx.adapters.sklearnimportservefromsklearn.feature_extraction.textimportTfidfVectorizerfromsklearn.linear_modelimportLogisticRegressionfromsklearn.pipelineimportmake_pipelineif__name__=="__main__":# Creating sklearn-compatible modelmy_model=make_pipeline(TfidfVectorizer(),LogisticRegression())# Start serving this modelserve(my_model)It starts serving athttp://localhost:16118listening for Heartex event.
To connect your model, go to Heartex -> Settings -> Machine learning page and choose "Add custom model".Or you can use Heartex API to activate your model:curl-XPOST-H'Content-Type: application/json'\-H'Authorization: Token <PUT-YOUR-TOKEN-HERE>'\-d'[{"url": "$HOST:$PORT", "name": "my_model", "title": "My model", "description": "My new model deployed on Heartex"}]'\http://go.heartex.net/api/projects/{project-id}/backends/where$HOST:$PORTis your server URL that should be accessible from the outside.FastAIYou can integrateFastAImodels similarly to scikit-learn.
Checkthis exampleto learn how to plug in updateable image classifier.Advanced usageWhen you want to go beyond using sklearn compatible API, you can build your own model, by making manually input/output interface conversion.
You have to subclass Heartex models as follows:fromhtx.base_modelimportBaseModel# This class exposes methods needed to handle model in the runtime (loading into memory, running predictions)classMyModel(BaseModel):defget_input(self,task):"""Extract input from serialized task"""passdefget_output(self,task):"""Extract output from serialized task"""passdefload(self,train_output):"""Loads model into memory. `train_output` dict is actually the output the `train` method (see below)"""passdefpredict(self,tasks):"""Get list of tasks, already processed by `get_input` method, and returns completions in Heartex format"""pass# This method handles model retrainingdeftrain(input_tasks,output_model_dir,**kwargs):""":param input_tasks: list of tasks already processed by `get_input`:param output_model_dir: output directory where you can optionally store model resources:param kwargs: any additional kwargs taken from `train_kwargs`:return: `train_output` dict for consequent model loading"""pass
Package: pyhearthis
pyhearthisA python client for thehearthis.atmusic community APIThe API documentation is availabe athttps://hearthis.at/api-v2Howto use the clientGet some credentials fromhearthis.at(at the moment only the login with hearthis.at credentials is supported)Use the clientimport asyncio
import aiohttp
from pyhearthis.hearthis import HearThis

async def do_some_queries():

    async with aiohttp.ClientSession() as session:
        hearthis = HearThis(session)
        user = await hearthis.login("mylogin", "mypassword")

        # Search for music
        search_result = await hearthis.search(user, "MySearchQuery")
        for track in search_result:
            print(track)

        # Create a playlist
        playlist = await hearthis.create_playlist(user, "MyNewPlaylist")

        # Add a track to the playlist
        await hearthis.add_track_to_playlist(user, search_result[0], playlist)
Package: pyheartlib
PyheartlibPyheartlibis a Python package for processing electrocardiogram (ECG) recordings. This software facilitates working with signals for tasks such as heartbeat detection, heartbeat classification, and arrhythmia classification. Utilizing it, researchers can focus on these tasks without the burden of designing data processing modules. The package transforms original data into processed signal excerpts and their computed features in order to be used for training various machine learning models including advanced deep learning models, which can be trained by taking advantage of Keras and Tensorflow libraries.DocumentationDocumentation is available at the link below.pyheartlib.readthedocs.io.RequirementsCurrent version of the package was tested on:Ubuntu: 20.04 | 22.04 & Python: 3.10 | 3.11 & Processor: x86_64macOS: 12.6.9 | 13.6 & Python: 3.10 | 3.11 & Processor: x86_64However, it may also be compatible with other systems.InstallationThe package can be installed with pip:$pipinstallpyheartlibExamplesExamples can be found in theexamples sectionof the documentation and also in the GitHub repository (examples).ContributingFeedback and contributions are appreciated. The guidelines for contributing are providedhere.Discussions & SupportFor any questions, discussions, or problems with this software, please join us onDiscord. An alternative option is to open a GitHub issue. (Issues,New issue)LicensePyheartlibis released under theAGPL-3.0License.
Package: py-heart-locker
py-heart-lockerpython 进程锁定器，避免同一时间重复执行相同的脚本运行环境使用说明安装:python -m pip install py-heart-locker在代码中使用：fromlockimportlockerdefmain():iflocker.islocked():returnlocker.lock()core()defcore():# 业务核心代码if__name__=='__main__':main()
Package: py-heat
Profilers are extremely helpful tools. They help us dig deep into code,
find and understand performance bottlenecks. But sometimes we just want
to lay back, relax and still get a gist of the hot zones in our code.A picture is worth a thousand words.So, instead of presenting the data in tabular form, if presented as a
heatmap visualization, it makes comprehending the time distribution in
the given program much easier and quicker. That is exactly what is being
done here !DemoScroll DemoFeaturesSimple CLI interface.No complicated setup.Heatmap visualization to view hot zones in code.Ability to export the heatmap as an image file.Ability to scroll, to help view heatmap of large py files.SetupUsing pippipinstallpy-heatDirectly from the repositorygitclonehttps://github.com/csurfer/pyheat.gitpythonpyheat/setup.pyinstallUsageAs a command# To view the heatmap.pyheat<path_to_python_file># To output the heatmap as a file.pyheat<path_to_python_file>--outimage_file.pngpyheat--helpAs a modulefrompyheatimportPyHeatph=PyHeat(<file_path>)ph.create_heatmap()# To view the heatmap.ph.show_heatmap()# To output the heatmap as a file.ph.show_heatmap('image_file.png')ContributingBug Reports and Feature RequestsPlease useissue trackerfor reporting bugs or feature requests.DevelopmentPull requests are most welcome.Buy the developer a cup of coffee!If you found the utility helpful you can buy me a cup of coffee using
Package: pyheatintegration
pyheatintegrationヒートインテグレーションを支援します。グランドコンポジットカーブ、TQ線図の作成に対応しています。グランドコンポジットカーブTQ線図TQ線図(流体ごとに分割)TQ線図(流体ごとに分割。最小接近温度差を満たす。)TQ線図(結合可能な熱交換器を結合。)RequirementsPython >= 3.9InstallationpipinstallpyheatintegrationExamplessimple exampleDocumentationhttps://pyheatintegration.readthedocs.io/ja/latest/LicenseMIT
Package: py-heat-magic
IPython magic command to profile and view your python code as a heat map
usingpy-heat.DemoIn case the demo was too fast, here is asnapshotof the last step of the
demo for deeper contemplation :)What is the magic command?%%heatSetupUsing pippipinstallpy-heat-magicDirectly from the repositorygitclonehttps://github.com/csurfer/pyheatmagic.gitpythonpyheatmagic/setup.pyinstallLoad Extension in IPython%load_extheatUsage# To view the heatmap%%heat# To save the heatmap as a file%%heat-ofile.pngContributingBug Reports and Feature RequestsPlease useissue trackerfor reporting bugs or feature requests.DevelopmentPull requests are most welcome.Buy the developer a cup of coffee!If you found the utility helpful you can buy me a cup of coffee using
Package: pyheavydb
pyheavydbA pythonDB APIcompliant
interface forHeavyDB(formerly OmniSci and MapD).Regenerate thrift filesYou need to installthriftcompiler. Then
you can do:make thriftReleaseUpdate first the version numbers and make sure thrift files are up-to-date.
Releasing on PyPi assume you have a PyPi token in your environment.# this will generate thrift files, make a distribution and upload on PyPi
make publish
Package: pyheck
pyheckPyHeck is a case conversion library (for converting strings to snake_case, camelCase etc). It is a thin wrapper around the Rust libraryheck.Read the documentation.Installationpip install pyheckNote: requires Python >= 3.7.Example>>>frompyheckimportsnake>>>snake("We carry a new world here, in our hearts.")'we_carry_a_new_world_here_in_our_hearts'DevelopmentSetupInstallpoetryInstall dev dependencies:poetry installActivate the poetry shell:poetryshellTestingRunmaturin developto compile the Rust code.Runmake fmt,make lint, andmake test.
Package: pyhector
pyhectoris a Python interface for the simple global climate
carbon-cycle modelHector.pyhectormakes the simple climate model Hector easily installable
and usable from Python and can for example be used in the analysis of
mitigation scenarios, in integrated assessment models, complex climate
model emulation, and uncertainty analyses.Hectoris written in C++ and
developed at thePacific Northwest National Laboratory. The model description is published inHartin, C. A., Patel, P., Schwarber, A., Link, R. P., and
Bond-Lamberty, B. P.: A simple object-oriented and open-source
model for scientific and policy analyses of the global climate
system – Hector v1.0, Geosci. Model Dev., 8, 939-955,doi:10.5194/gmd-8-939-2015, 2015.See the Hectorrepositoryandwikifor further
information.The Python interfacepyhectoris developed bySven WillnerandRobert Gieseke.Pyhector usespybind11to wrap
Hector’s API. The version of Hector used can be read using Pyhector’s__hector_version__field.InstallationPrerequisitesHectorrequiresBoost, so to install and usepyhectoryou need
to have the filesystem and system modules ofBoostversion
1.52 or later installed (see also theHector build
instructions).On Ubuntu/Debian these can be installed by invokingsudoapt-getinstalllibboost-filesystem-devlibboost-system-devOn macOSBoostis available through the Homebrew package manager, it
might be advisable to use a Homebrew installed Python for installingpyhector:brewinstallboostWindows is (as Hector) in principle supported but not yet tested forpyhector. Pull request with installation notes for Windows are
welcome.Install using pipYou can simply installpyhectorfromPyPIby invokingpipinstallpyhectorUsageThis repository also contains aJupyter Notebookyou canrun
liveand
experiment with, courtesy of theBinderproject. The notebook can be viewed as astatic versionusing nbviewer.Basic exampleimportpyhectoroutput=pyhector.run(pyhector.rcp26)Advanced exampleimportpyhectorfrompyhectorimportrcp26,rcp45,rcp60,rcp85importmatplotlib.pyplotaspltforrcpin[rcp26,rcp45,rcp60,rcp85]:output=pyhector.run(rcp,{"core":{"endDate":2100}})temp=output["temperature.Tgav"]# Adjust to 1850 - 1900 reference periodtemp=temp.loc[1850:]-temp.loc[1850:1900].mean()temp.plot(label=rcp.name.split("_")[0])plt.title("Global mean temperature")plt.ylabel("°C over pre-industrial (1850-1900 mean)")plt.legend(loc="best")plt.show()DevelopmentFor local development you can clone the repository, update the
dependencies and install in a virtual environment withpip.gitclonehttps://github.com/openclimatedata/pyhector.git--recursivecdpyhectorpython3-mvenvvenv./venv/bin/pipinstall--editable.To updatepyhectorand all submodules you can rungitpull--recurse-submodulesgitsubmoduleupdate--init--recursive./venv/bin/pipinstall--editable.Tests can be run locally withpython setup.py test
Package: pyHed---Python-desktop-framework
pyHed it’s a open-source framework to create desktop applications. It has a lot
of useful tool’s that make a develop of a desktop application very simple and fast.
pyHed uses PyQt4, SQLAlchemy and ReportLab to create GUI forms, to connect with
many databases and to make report’s.
pyHed was designed to make the task of create applications a very easy work.
Take a look on the pyHed site (http://www.pyhed.com/index_us.html) to a full
description of all features.
Package: pyhedrals
PyHedralsA library for evaluating tabletop dice roll expressions.Used in the Mastodon botDiceCat, and the IRC botDesertBotUsage OverviewSample usage:5d6!>4 + (5d(2d10)dl - d10) * (d20 / 2) # for an unnecessarily complicated rollSample output:84 for an unnecessarily complicated rollThere is also a verbose mode that outputs every individual die roll, that output looks like this:[2d10: 2,5 (7) | 5d7: -1-,6,2,4,5 (17) | 1d10: 3 (3) | 1d20: 9 (9) | 5d6: 2,2,3,*5*,*5*,2,*5*,4 (28)] 84 for an unnecessarily complicated rollSupported OperatorsArithmetic:+-*/%^()(addition, subtraction, multiplication, division, modulus, exponent, parentheses)Dice:#d#(eg,3d6,d20)Rolls the left number of dice with the right number of sides.3d6rolls 3 six-sided diceThe first number is optional and defaults to 1 if omittedDice modifiers:Keep/Drop Highest/Lowest:kh#kl#dh#dl#Keeps/Drops only the # highest/lowest dice rolls. Any that are either not kept or dropped are removed from the totalThe number is optional and defaults to 1 if omittedExploding:!!#!>#!>=#!<#!<=#Each die that rolls maximum (!), or a specific number (!#), or over/under a threshold (!>#!>=#!<#!<=#), adds an additional die to the poolThis repeats for each die added to the poolReroll:rr#r>#r>=#r<#r<=#Drops and rerolls each die that rolls minimum (r), or a specific number (r#), or over/under a threshold (r>#r>=#r<#r<=#)This repeats for each die rerolled. You can make it only reroll each die once withroinstead ofrCount:cc#c>#c>=#c<#c<=#Counts the number of dice that roll maximum (c), or a specific number (c#), or over/under a threshold (c>#c>=#c<#c<=#)Sorting:ssasdSorts the dice rolls in ascending (ssa) or descending (sd) orderThis still applies in non-verbose mode but you won't see any visible effectComments:# your comment hereAdds a comment to the end of the output, so you can describe what the roll is for. eg:d20+5 # for initiativeThe#is a literal hash, not a number this time :)If you have more ideas for operators, suggestions and pull requests are welcome!
Package: pyhedron
There are a lot if implementations of Polyhedrons available.
Most of them are implemented in C++ because of efficiency reason.
Sometimes they offer a Python API and maybe a pip installation package.But:Because these Packages are implemented in C++,
they are often difficult to install and offer a API that is not very Pythish or even ugly.This implementation wants to solve these problems:Pyhedron is implemented in pure PythonThere is a standard pip installation Package that is easy to install.It only depends on NumpyIt is easy to use, understand and maintain
Package: py-heideltime
Python HeidelTimepy_heideltimeis a python wrapper for the multilingual temporal tagger HeidelTime originally developed
byJorge MendesandRicardo Campos.
This repo is a gross simplification of the original work that reduces the interface and the outputs of theheideltimefunction. Please do checkout the originalrepowhich provides a much more comprehensive overview of the library.Installationpipinstallpy_heildetimeInstall External ResourcesIn order to use py_heideltime you must have java JDK and perl installed in your machine for heideltime dependencies.Windows usersTo install java JDK begin by downloading ithere.
Once it is installed don't forget to add the path to the environment variables. Onuser variables for Administratoradd theJAVA_HOMEas theVariable name:, and the path (e.g.,C:\Program Files\Java\jdk-12.0.2\bin) as the Variable
value. Then onSystem variablesedit thePathvariable and add (e.g.,;C:\Program Files\Java\jdk-12.0.2\bin) at
the end of thevariable value.For Perl, we recommend to download and install the followingdistribution. Once it is
installed don't forget to restart your PC. Note that perl doesn't need to be installed if you are using Anaconda instead
of pure Python distribution.Linux usersPerl usually comes with Linux, thus you don't need to install it.To installJAVA:sudoaptinstalldefault-jdkHow to usefrompy_heideltimeimportheideltimetext="Thurs August 31st - News today that they are beginning to evacuate the London children tomorrow. Percy is a billeting officer. I can't see that they will be much safer here."timexs=heideltime(text,language='English',document_type='news',dct='1939-08-31')print(timexs)Output[{"text":"August 31st","tid":"t2","type":"DATE","value":"1939-08-31","span":[6,17]},{"text":"today","tid":"t3","type":"DATE","value":"1939-08-31","span":[25,30]},{"text":"tomorrow","tid":"t4","type":"DATE","value":"1939-09-01","span":[87,95]}]We highly recommend you to use thispython notebookif you are interested in playing
withpy_heideltimewhen using the standalone version.Supported languagesThis GitHub package is prepared to work with the following languages: English, Portuguese, Spanish, German, Dutch,
Italian, French.To usepy_heideltimewith other languages proceed as follows:Download fromTreeTaggerthe parameter filesgunzip <downloaded_file>Copy the extracted file to the module folder/py_heideltime/HeidelTime/TreeTagger<your_system>/lib/PublicationsPlease cite the appropriate paper when usingpy_heideltime. In general, this would be:Strötgen, Gertz: Multilingual and Cross-domain Temporal Tagging. Language Resources and Evaluation, 2013.pdfbibtexOther related papers may be foundhere.
Package: py-heiko
heikoheikois a lightweight load balancer that uses SSH to manage servers running on
low-end hardware such as Raspberry Pis or even mobile phones.The name heiko is derived from the Japanese term forequilibrium.heiko uses a smart scheduler to run a program on one node from a set of nodes. It is
very robust to node failures and switches to a different node as soon as the current node
fails. The node to run is intelligently selected based on multiple factors such as CPU power,
memory capacity, free memory, current CPU load, past failures and others.Installation and UsageInstallation using pippip install py-heikoInstallation from sourcegit clone https://github.com/psiayn/heiko.git
cd heiko
pip install .Check if the installation succeededheiko --helpCheck out thequickstartsection of the documentation.Licenseheiko usesApache License 2.0
Package: py-heimdallr-client
This module is a Python API forHeimdallr.Installationpip installpy-heimdallr-clientContributingPlease use a linter to help follow PEP8 style guidelines. We use Vincent
Driessen’sgit-flowso please make pull requests to the develop branch. For any new features
you might add please add the corresponding documentation and tests. To
setup the project for development you needvirtualenv. Once you have
virtualenv installed and setup can run:mkvirtualenv py-heimdallr-client
workon py-heimdallr-client
git clone git@github.com:Layer3DLab/py-heimdallr-client.git
cd py-heimdallr-client
git checkout develop
npm install
pip install -r dev_requirements.txtNOTE: if you’re on OSX and cryptography fails to install you may need to
follow thesedirections.Adding DocumentationWe useSphinxwith
the autodoc and napoleon extensions to generate the documentation for
this module. So to add documentation simply add Python docstrings to
whatever classes, methods, etc. that you add. We use Google style
docstrings (exampleshere).
To build the docs run the following from the project directory:cd docs
make htmlAdding TestsWe useunittestfor our testing suite. To run the tests you can just callpython setup.py testfrom the project directory. To run them
directly you can just callpython tests/__init__.pyTo run coverage
tests and generate an HTML report run:coverage  run --source="./heimdallr_client" --branch -m unittest tests
coverage html