Saravanan666/pypi-org huggingface dataset:
Package: health-tracking
Health TrackingThis repository provides somenotebooksto analyze theApple Health Appdata export dump as well as visualizations.DescriptionAdd the exported dump (see here for information), usally namedexport.zip, into the directorydata/raw/export.zip. TheAppleHealthParseris able to unzip and parse it.Install the package as shown in theinstallationsection. Or simply use:pipinstallhealth-trackingInstallationIn order to set up the necessary environment:create an environmenthealth-trackingwith the help ofconda,conda env create -f environment.yamlactivate the new environment withconda activate health-trackinginstallhealth-trackingwith:python setup.py install # or `develop`Optional and needed only once aftergit clone:install severalpre-commitgit hooks with:pre-commit installand checkout the configuration under.pre-commit-config.yaml.
The-n, --no-verifyflag ofgit commitcan be used to deactivate pre-commit hooks temporarily.installnbstripoutgit hooks to remove the output cells of committed notebooks with:nbstripout --install --attributes notebooks/.gitattributesThis is useful to avoid large diffs due to plots in your notebooks.
A simplenbstripout --uninstallwill revert these changes.Then take a look into thescriptsandnotebooksfolders.Dependency Management & ReproducibilityAlways keep your abstract (unpinned) dependencies updated inenvironment.yamland eventually
insetup.cfgif you want to ship and install your package viapiplater on.Create concrete dependencies asenvironment.lock.yamlfor the exact reproduction of your
environment with:conda env export -n health-tracking -f environment.lock.yamlFor multi-OS development, consider using--no-buildsduring the export.Update your current environment with respect to a newenvironment.lock.yamlusing:conda env update -f environment.lock.yaml --pruneNoteThis project has been set up using PyScaffold 3.2.3. For details and usage
information on PyScaffold seehttps://pyscaffold.org/.
Package: healthuniverse
Health Universe Python ClientThis Python package provides a simple way to interact with the healthuniverse.com API. Specifically, it allows you to add applications to HealthUniverse through a simple python interface.InstallationYou can install the package via pip:pip install healthuniverseQuick Startfrom healthuniverse.client import HealthUniverseClient

client = HealthUniverseClient()
response_status, response_data = client.create_app(
    app_name='My App', 
    app_desc='An awesome app', 
    app_category='0', 
    app_sdk='SL', 
    gh_account='<github_account>', 
    gh_repo='<github_repo>', 
    main_file='main.py'
    )DocumentationHealthUniverseClientclient = HealthUniverseClient(base_url='https://healthuniverse.com/')This creates a new HealthUniverse client. The base_url parameter is optional and defaults to 'https://healthuniverse.com/'.create_appstatus, response = client.create_app(
    app_name, 
    app_desc, 
    app_category, 
    app_sdk, 
    gh_account, 
    gh_repo, 
    main_file)This sends a POST request to the HealthUniverse API to add a new app. Returns the HTTP status code and the JSON response.Parameters:app_name (str): The name of the app.app_desc (str): The description of the app.app_category (str): The category of the app. (0-10)app_sdk (str): The SDK version used by the app: 'SL' or 'FA' are acceptable.gh_account (str): The GitHub account where the app's source code is hosted.gh_repo (str): The GitHub repository where the app's source code is hosted.main_file (str): The main file of the app in the repository.ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
Package: healthy
healthy checks the health of a Python package from its pypi listingThe package is given a score, based on this formula:Starting score                      = 0
Has license                         + 20
Has release files                   + 30
Has homepage                        + 10
Updated in last 6 months            + 15
Has summary                         + 15
Has description                     + 30
Has author name or email            + 10
Has Python classifiers              + 15Results are color coded, based on the scoreUsageThe simplest command you can run ishealthy FlaskThis will check the latest version of Flask, and give you back its score.To check a specific version of a package with verbose outputhealthy Flask 0.8 -vThere are 3 optional parameterspackage_version     : positional, to check the health of a specific version of a package
-v, --verbose       : show reasons for the health scores the packages were given
-n, --no-output     : print no output to the terminal, useful for integrating healthy with other packagesSample Outputhealthy Django 1.2.1 -v

Django v1.2.1
-----
score: 85/145 58%
Description missing
Python classifiers missing
Package not updated in 180 daysUse Casehealthycan be used when you are trying to choose a package from a number of options. Withhealthyyou can
quickly gauge the risk and benefit of one package over the other and make your decision easier.Installationpip install healthySupports Python 2.7, 3.2, 3.3Python <=2.6, 3.0 and 3.1 are not supported, they don’t have argparse
Package: healthy-django
Simple Re Usable tool for Django HealthchecksDocumentationQuickstartInstall healthy_django:pip install healthy_djangoAdd it to yourINSTALLED_APPS:INSTALLED_APPS=(...'healthy_django',...)Add healthy_django’s URL patterns:urlpatterns=[...path("health/",include("healthy_django.urls",namespace="healthy_django")),...]Add list of healthcheck plugins the currently supported plugins along with their specDjango Database Health CheckChecks if a Database defined in Django is up and runningDjango Cache Health CheckChecks if a Cache defined in Django is up and runningRedis based Celery Queue Health CheckChecks if a Celery queue backlog is within given limitsAWS SQS Queue Health CheckChecks if an AWS SQS queue backlog is within given limitsFeaturesNon ORM Based Database TestsRabbitMQ Queue Length TestS3 file testCreditsMade with Love by SecurityAdvisorHistory0.0.1 (2021-09-15)First release on PyPI.
Package: healthyhouse-api
healthyhouse-apiA wrapper of the rest API available for a healthyhouse installation.The full API includes the following routes/api/v1/auth/check-token//api/v1/auth/login//api/v1/auth/logout//api/v1/data-import/apps//api/v1/data-import/orders//api/v1/dosimeters/<pk>//api/v1/dosimeters/set-results//api/v1/dosimeters/set-status//api/v1/municipality-radon-risk//api/v1/orders//api/v1/orders/<pk>//api/v1/orders/<pk>/approve//api/v1/orders/<pk>/change_status//api/v1/orders/<pk>/generate_pdf_report//api/v1/orders/<pk>/send_report//api/v1/orders/default-products//api/v1/orders/default-products/<pk>//api/v1/orders/dosimeters//api/v1/orders/dosimeters/<pk>//api/v1/orders/generate_invoices_pdf/?order_number={order_number}/api/v1/orders/generate_reports_pdf/?order_number={order_number}/api/v1/profile/dosimeters/<pk>//api/v1/profile/orders/Only a subset of these are available for usage in this implementation. In time hope fully all will be added.This software can be easily installed from pypi using$ pip install healthyhouse_apiFree software: MIT licenseDocumentation:https://healthyhouse-api.readthedocs.io.FeaturesTODOCreditsHistory0.1.0 (2018-02-17)First release on PyPI.
Package: healthywork
# HealthyWork生活不止有屏幕上的代码,还有诗和远方.这是一款基于Python语言和PyQt图形化框架编写的桌面应用，用来提醒正在电脑前工作的人们注意休息，以保障身体健康。## Features- 防颈椎病- 防腰间盘突出- 防痔疮- 防心脏病- 自定义壁纸- 自定义时间- 本地音乐播放- 全屏显示，窗口置顶- 界面简约（编不下去了）- 你值得拥有![截图](https://github.com/1zlab/HealthyWork/blob/master/Screenshot.png)![截图](https://github.com/1zlab/HealthyWork/blob/master/Screenshot_2.png)## Dependence- python3- PyQt5## Install```shpip install healthywork```## How to work```shhealthywork```## Custom初次运行会在用户目录下的.config文件夹中创建healthywork.json文件，存储程序基本的配置，你可以自行修改一下的所有选项：```pythoDEFALUT_CONFIG = {'label_stylesheet': "color: rgb(255, 0, 127);font: 30pt \"WenQuanYi Micro Hei Mono\";",'button_stylesheet': "background-color: rgba(182, 176, 171, 90);color: rgb(255, 0, 127);font: 30pt \"WenQuanYi Micro Hei Mono\";",'message': "喝杯水休息一下吧",'count': "        ",'time_work': "1800000",'time_rest': "300000",'wallpapers_dir': "./wallpapers",'music_dir': "./music",'with_music': "1"}```- label_stylesheet： 界面上标签的样式- button_stylesheet：界面上按钮的样式- message：提醒的文字- count：给倒计时标签占位用的，方便计算label的位置- time_work: 工作时间间隔，单位毫秒，默认半小时- time_rest: 休息时间间隔，单位毫秒，默认五分钟- wallpapers_dir: 存放壁纸的目录，默认为当前的wallpapers目录- music_dir: 存放音频的目录，默认为当前的music目录- with_music: 休息时是否播放音乐，1为播放，0为不播放。默认播放。
Package: heamon7-tushare
easy to use as most of the data returned are pandas DataFrame objectscan be easily saved as csv, excel or json filescan be inserted into MySQL or MongodbTarget Usersfinancial market analyst of Chinalearners of financial data analysis with pandas/NumPypeople who are interested in China financial dataInstallationpip install tushareUpgradepip install tushare –upgradeQuick Startimport tushare as ts

ts.get_hist_data('600848')return:open    high   close     low     volume    p_change  ma5
date
2012-01-11   6.880   7.380   7.060   6.880   14129.96     2.62   7.060
2012-01-12   7.050   7.100   6.980   6.900    7895.19    -1.13   7.020
2012-01-13   6.950   7.000   6.700   6.690    6611.87    -4.01   6.913
2012-01-16   6.680   6.750   6.510   6.480    2941.63    -2.84   6.813
2012-01-17   6.660   6.880   6.860   6.460    8642.57     5.38   6.822
2012-01-18   7.000   7.300   6.890   6.880   13075.40     0.44   6.788
2012-01-19   6.690   6.950   6.890   6.680    6117.32     0.00   6.770
2012-01-20   6.870   7.080   7.010   6.870    6813.09     1.74   6.832
Package: heamy
A set of useful tools for competitive data science.InstallationTo install Heamy, simply:$pipinstall-UheamyFeaturesAutomatic caching (data preprocessing, predictions from models)Ensemble learning (stacking, blending, weighted average, etc.).DocumentationDocumentation:http://heamy.readthedocs.io/en/latest/Examples:https://github.com/rushter/heamy/tree/master/examples
Package: heaobject
HEA Object LibraryResearch Informatics Shared Resource,Huntsman Cancer Institute, Salt Lake City, UTThe HEA Object Library contains data and other classes that are passed into and out of HEA REST APIs.Version 1.0.1Performance improvements converting from a HEAObject to a dictionary.Version 1Initial release.Runtime requirementsPython 3.10 or 3.11.Development environmentBuild requirementsAny development environment is fine.On Windows, you also will need:Build Tools for Visual Studio 2019, found athttps://visualstudio.microsoft.com/downloads/. Select the C++ tools.git, found athttps://git-scm.com/download/win.On Mac, Xcode or the command line developer tools is required, found in the Apple Store app.Python 3.10 or 3.11: Download and install Python 3.10 fromhttps://www.python.org, and select the options to install
for all users and add Python to your environment variables. The install for all users option will help keep you from
accidentally installing packages into your Python installation's site-packages directory instead of to your virtualenv
environment, described below.Create a virtualenv environment using thepython -m venv <venv_directory>command, substituting<venv_directory>with the directory name of your virtual environment. Runsource <venv_directory>/bin/activate(or<venv_directory>/Scripts/activateon Windows) to activate the virtual
environment. You will need to activate the virtualenv every time before starting work, or your IDE may be able to do
this for you automatically.Note that PyCharm will do this for you, but you have to create a new Terminal panel
after you newly configure a project with your virtualenv.From the project's root directory, and using the activated virtualenv, runpip install wheelfollowed bypip install -r requirements_dev.txt.Do NOT runpython setup.py develop. It will break your environment.Running unit testsRun tests with thepytestcommand from the project root directory.Packaging and releasing this projectSee theRELEASING.mdfile for details.
Package: heap-class
heap_classlist-like implementation of heap/PriorityQueue in PythonUsage>>>fromheap_classimportHeap>>>h=Heap([3,1,9,20],max=True)>>>h.pop()20>>>h.peek()# same as h[0]9>>>h.push(17)# or h.append(17)>>>h[0]# same as h.peek()17>>>h[1]# inefficient, but works9>>>y=reversed(h)>>>y.peek()1>>>y# repr is inefficient, but correctHeap([1,3,9,17],max=False)>>>9inyTrue>>>y.raw()# heap structure[1,3,17,9]>>>set(y.raw())# raw helpful for fast casting{1,3,17,9}Complexentriesand*argscreationsupported.>>>h=Heap((6,4),(6,9),(10,2),max=True)>>>h.pop()(10,2)>>>h.pop()(6,9)Thisisratherhardinheapqbecauseofthedifferentformsofnegation.Easyhere.>>>h=Heap(('aa',4),('aa',5),('zz',2),('zz',1),max=True)>>>h.pop()('zz',2)Customkeysaresupported:>>>vals=[('Adam','Smith'),('Zeta','Jones')]>>>h=Heap(vals,key=lambdaname:name[1])>>>h.peek()# Jones comes before Smith('Zeta','Jones')>>>h.push(('Aaron','Allen'))>>>h.peek()('Aaron','Allen')Replacethetopitemwithanewone.Orderchanges.>>>h.replace(('Annie','Sun'))('Aaron','Allen')>>>forordered_nameinh:...print(ordered_name)('Zeta','Jones')('Adam','Smith')('Annie','Sun')Theheapisnotchanged:>>>h.peek()('Zeta','Jones')NotethatifyouplantoiteratethroughthewholeHeap,sortingwiththesamekeyismoreefficient:>>>forordered_nameinsorted(h.raw(),key=lambdaname:name[1]):...print(ordered_name)('Zeta','Jones')('Adam','Smith')('Annie','Sun')CreditCopyright (c) 2022 Michael Scott Asato CuthbertLicenseMIT
Package: heapprof
heapprof: A Logging Heap Profilerheapprof is a logging, sampling heap profiler for Python 3.7+."Logging" means that as the program runs, it steadily generates a log of memory allocation and
release events. This means that you can easily look at memory usage as a function of time."Sampling" means that it can record only a statistically random sample of memory events. This
improves performance dramatically while writing logs, and (with the right parameters) sacrifices
almost no accuracy.It comes with a suite of visualization and analysis tools (including time plots, flame graphs, and
flow graphs), as well as an API for doing your own analyses of the results.heapprof is complementary totracemalloc,
which is a snapshotting heap profiler. The difference is that tracemalloc keeps track of live memory
internally, and only writes snapshots when its snapshot() function is called; this means it has
slightly lower overhead, but you have to know the moments at which you'll want a snapshot before the
program starts. This makes it particularly useful for finding leaks (from the snapshot at program
exit), but not as good for understanding events like memory spikes.You can install heapprof withpip install heapprof. heapprof is released under theMIT License.You can read all the documentation athumu.github.io/heapprof.Navigating the RepositoryIf you're trying to find something in the GitHub repository, here's a brief directory (since, like
most Python packages, this is a maze of twisty subdirectories, all different):heapprofcontains the Python package itself. (The API and visualization logic)_heapprofcontains the C/C++ package. (The core profiling logic)docs_srccontains the sources for the documentation, mostly as.mdand.rstfiles.docscontains the compiled HTML version ofdocs_src, created withtools/docs.pyand checked
in.toolscontains tools useful when modifying heapprof itself.And then there are the configuration files for all the tools:setup.pyis the master build configuration for the PIP package..flake8and.pylintrcare the configuration for Python linting.CPPLINT.cfgis the configuration for C/C++ linting.mypy.iniis the configuration for Python type checking.Gemfileis for setting up Jekyll for documentation hosting._config.ymlis the configuration for Jekyll serving.docs/Makefileanddocs/conf.pyare the configuration for building the HTML docs image via
Sphinx..circleciis the configuration for continuous integration testing.pyproject.tomland the rootrequirements.txtmakesetuptoolshappy.Additional directories which are .gitignored but which show up during use:buildcontains C/C++ dependencies and their compiled images; it's managed bysetup.py._sitecontains the final Jekyll site which is served for documentation; it's created if you
runbundle exec jekyll serveto run the docs web server locally.
Package: heapq_max
DescriptionA maxHeap version of heapq module for Python. Similar to heapq, c
implementation is used when available to ensure performance.DependenciesPython 2 or 3Installationpip install heapq_maxUsagetl;dr: same as heapq module except adding ‘_max’ to all functions.from heapq_max import *

heap_max = []                           # creates an empty heap
heappush_max(heap_max, item)            # pushes a new item on the heap
item = heappop_max(heap_max)            # pops the largest item from the heap
item = heap_max[0]                      # largest item on the heap without popping it
heapify_max(x)                          # transforms list into a heap, in-place, in linear time
item = heapreplace_max(heap_max, item)  # pops and returns largest item, and
                                        # adds new item; the heap size is unchangedLicenseMITHistory0.21Small fix of download URL&README0.2Add Python 2 support0.1 & 0.11First version, only supports Python 3
Package: heapy
An priority queue built with an in-place modifiable binary heap (decrease-key,increase-key).Operations have the following algorithmic complexities:pop-O(log(n))push-O(log(n))(average:O(1))peek-O(1)remove-O(log(n))Useful for:Dijkstra's shortest path algorithmA*Rolling medianInstallpip install heapyExamplesThe following is an example implementation of Dijkstra's algorithm, a method
for finding the shortest path in a weighted graph. The heap-based
priority queue reduces the complexity of the basic algorithm fromO(n^2)toO(m*log(n)), fornnodes andmedges.fromheapyimportpqueuedefdijkstra(G,r):'''Find the shortest paths from a given node in a weighted graphto every other (connected) node.'''todo=pqueue()# this is the heap-based priority queuedistance={}# distances to all nodes on shortest pathsparents={r:None}# parent pointers for all items on known shortest pathstodo.push((r,0))# alternate syntax: todo[r] = 0whiletodo:# automatically checks len(todo) > 0(n,d)=todo.pop()# get the minimum element; O(log(n))distance[n]=d# save shortest distance# update position of children in priority queue, if lesschildren=G.get(n,{})for(c,w)inchildren.items():ifcnotindistanceand(cnotintodoord+w<todo[c]):todo[c]=d+w# add or update distance ~ O(1)parents[c]=n# update parent in minimum path distance spanning treereturndistanceNote thatGis a dictionary of dictionaries.{'a':{'b':2,'c':1},'b':{'a':2,'d':3},'c':{'a':1},'d':{'b':3}}
Package: hear
hearEasy access to audio data.To install:pip install hearExamplesA wav serialization/deserialization transformer.First let's make a very short waveform.>>> from hear import WavSerializationTrans
>>> from numpy import sin, arange, pi
>>> n_samples = 5; sr = 44100;
>>> wf = sin(arange(n_samples) * 2 * pi * 440 / sr)
>>> wf
array([0.        , 0.06264832, 0.12505052, 0.18696144, 0.24813785])An instance ofWavSerializationTranswill allow you to>>> trans = WavSerializationTrans(assert_sr=sr)  # if you want to write data you NEED to specify assert_sr
>>> wav_bytes = trans._data_of_obj(wf)
>>> wav_bytes[:44]  # the header bytes
b'RIFF.\x00\x00\x00WAVEfmt \x10\x00\x00\x00\x01\x00\x01\x00D\xac\x00\x00\x88X\x01\x00\x02\x00\x10\x00data\n\x00\x00\x00'
>>> wav_bytes[44:]  # the data bytes (5 * 2 = 10 bytes)
b'\x00\x00\x04\x08\x01\x10\xee\x17\xc2\x1f'

>>> wf_read_from_bytes = trans._obj_of_data(wav_bytes)
>>> wf_read_from_bytes
array([   0, 2052, 4097, 6126, 8130], dtype=int16)Note that we've serialized floats, but they were deserialized as int16.
This is the default behavior, but is cusomizable through dtype, subtype, etc.
With this default dtype=int16 setting though, if you serialize int16 arrays, you'll recover them exactly.>>> assert all(trans._obj_of_data(trans._data_of_obj(wf_read_from_bytes)) == wf_read_from_bytes)The most common use of WavSerializationTrans through, is to make a class decorator for a store that
provides wav bytes.>>> @WavSerializationTrans.wrapper(assert_sr=sr)
... class MyWavStore(dict):
...     pass
>>> my_wav_store = MyWavStore(just_one=wav_bytes)
>>> my_wav_store['just_one']
array([   0, 2052, 4097, 6126, 8130], dtype=int16)
Package: hearbaseline
HEAR BaselineSeveral baseline audio embeddings that implement thecommon APIrequired by the HEAR Benchmark and 2021 HEAR NeurIPS competition.Includes a simple DSP-based audio embedding consisting of a Mel-frequency spectrogram
followed by a random projection, implemented in PyTorch, TensorFlow, and Keras.Additionally, we wrap several benchmark audio embedding models.
However, many of them are ineffecient because of limiting assumptions
in the original implementation (e.g. only one audio file can be
processed at a time using their high-level API).For the HEAR Benchmark and 2021 NeurIPS evaluation,hearbaseline.wav2vec2andhearbaseline.torchcrepebaseline
embeddings were used.For full details on the HEAR Benchmark please visithttps://hearbenchmark.comInstallationTested with Python 3.7 and 3.8. Python 3.9 is not officially supported
because pip3 installs are very finicky, but it might work.Method 1: pypipipinstallhearbaselineMethod 2: pip local source treeThis is the same method that will be used to by competition organizers when installing
submissions to HEAR 2021.gitclonehttps://github.com/hearbenchmark/hear-baseline.gitpython3-mpipinstall-e./hear-baselineNaive Baseline ModelThe naive baseline model provides an example for implementing the HEAR common API
using DSP-based techniques. It produces log-scaled Mel-frequency spectrograms using a
256-band Mel filter. Each frame of the spectrogram is then projected to 4096
dimensions using a random projection matrix. Weights for the projection matrix were
generated by sampling a normal distribution and are stored in this repository in the
filesaved_models/naive_baseline.pt.Using a random projection is less efficient
than a CNN but is one of the simplest models to implement from a coding perspective.UsageAudio embeddings can be computed using one of two methods: 1)get_scene_embeddings, or 2)get_timestamp_embeddings.get_scene_embeddingsaccepts a batch of audio clips and produces a single embedding
for each audio clip. This can be computed like so:importtorchimporthearbaseline# Load model with weights - located in the root directory of this repomodel=hearbaseline.load_model("saved_models/naive_baseline.pt")# Create a batch of 2 white noise clips that are 2-seconds long# and compute scene embeddings for each clipaudio=torch.rand((2,model.sample_rate*2))embeddings=hearbaseline.get_scene_embeddings(audio,model)Theget_timestamp_embeddingsmethod works exactly the same but returns an array
of embeddings computed every 25ms over the duration of the input audio. An array
of timestamps corresponding to each embedding is also returned.See thecommon APIfor more details.Other Baselineshearbaseline.torchcrepehearbaseline.vggishhearbaseline.vqthearbaseline.wav2vec2hearbaseline.keras.naivehearbaseline.tf.naive
Package: hear-savi
HEAR-SAVIThis module extracts an audio subnetwork from the upstream semantic audio-visual navigation
(savi) model.The embeddings implement thecommon APIfrom HEAR Benchmark.RequirementsInstall habitat-lab v0.2.1 and habitat-sim from commit 80f8e31140.pip install hear-savi@inproceedings{chen20soundspaces,
  title     =     {SoundSpaces: Audio-Visual Navigaton in 3D Environments},
  author    =     {Changan Chen and Unnat Jain and Carl Schissler and Sebastia Vicenc Amengual Gari and Ziad Al-Halah and Vamsi Krishna Ithapu and Philip Robinson and Kristen Grauman},
  booktitle =     {ECCV},
  year      =     {2020}
}
```
Package: heart
HEARTHEART (Health Relationship Trust) Python implementation.Free software: GNU General Public License v3Documentation:https://heart.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-12-15)First release on PyPI. (Just package structure! on register purpose. Not usable at all!)