Saravanan666/pypi-org huggingface dataset:
Package: hqt
Hierarchical QuadTreeThis library has only one goal: insert circles of varying sizes in the plane, such that collisions can be checked very fast.
Cython package is required.Basic usagefromhqtimportHierarchicalQuadTree,Circle,Rectangle# create a boundary: x=0, y=0, width=100, height=100boundary=Rectangle(0,0,100,100)# define capacity, ie. max number of nodes in a quadtreecapacity=4# create a HierarchicalQuadTreehqt=HierarchicalQuadTree(boundary,capacity)# insert a Circle of radius 5 at position (45, 50)hqt.insert(Circle(x=40,y=50,radius=5))# return circles colliding with a given circle:hqt.find_collisions(Circle(x=50,y=50,radius=6))# >>> [<circle x=45.0 y=50.0 radius=5.0>]hqt.find_collisions(Circle(x=50,y=50,radius=4))# >>> []# faster results: return True if given Circle collides with any item:hqt.does_collide(Circle(x=50,y=50,radius=6))# >>> Truehqt.does_collide(Circle(x=50,y=50,radius=4))# >>> FalseHow does it work?When the first circle is inserted into the HQT, a new quadtree is created. It can only recognize circles of a similar size (radius). Circles of a similar size will be inserted into the same quadtree. This allows for more focused and more efficient querying, as the rectangle selection has a size proportional to the size of the largest circle in the quadtree. When a larger circle is inserted, one that does not fit in the previous quadtree, a new quadtree is created. This new quadtree will only record large circles of a similar size, and will then have a wider selection when querying. Hence, when querying for collisions, each quadtree returns the circles it may collide with by searching its space with an adapted rectangle selection, thus allowing for fast and efficient search.AuthorsMaixent Chenebaux
Package: hqueue
========Overview========``asyncio.Queue`` with history::Objects put on a ``HistoryQueue`` are gathered in tuples,with the first element being the next item on the queue,followed by items add previously.``HistoryQueue`` can also be thought of as as asynchronous ``collections.deque``,with ``put`` analogous to ``deque.appendleft``and ``get`` returning the entire deque (as a tuple).>>> from hqueue import HistoryQueue>>> hq = HistoryQueue(history_size=2)>>> hq.put_nowait(0)>>> hq.put_nowait(1)>>> hq.get_nowait()(0,)>>> hq.get_nowait()(1, 0)>>> hq.put_nowait(2)>>> hq.put_nowait(3)>>> hq.put_nowait(4)>>> hq.get_nowait()(2, 1, 0)>>> hq.get_nowait()(3, 2, 1)For ease of illustration, in the above examples we use ``put_nowait`` and ``get_nowait``,the synchronous counterparts of ``put`` and ``wait``, respectively.In a coroutine, ``await put()`` could be used to block until the queue is not full,and ``await get()`` to block until there is an item in the queue.See Also--------``asyncio.Queue````collections.deque``Changelog=========0.1.0 (2016-06-28)------------------* First prototype.0.2.0 (2016-07-01)------------------* First release on PyPI.
Package: hqvfx
HQ VFX PIPELINEBase Libraries Packages for VFX PipelineBase libraries for visual effects content production pipeline
Copyright (C) 2021  HQ VFX TECHNOLOGIES
Website: www.hqvfx.com
Email: contact@hqvfx.com
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
Package: hqx
hqx(high quality scale)is a family of pixel art scaling algorithms that work
by detecting differences between pixels in theYUVcolorspace.hq2xscales an image by 2x,hq3xby 3x, andhq4xby 4x.This is a Python port of hqx, unoptimized.It is not intended to be used for videos or scenarios where low latency is required.
Right now, it only supports RGB, not RGBA(no transparency support).Table of contents📦 Installation🛠 Usage📰 Changelog📜 License📦 Installationhqxis available on PyPi.
It requires a Python version ofat least 3.10.0.It depends onPillow.To installhqxwith pip, run:python-mpipinstallhqx🛠 UsageYou can either usehqx.hqx_scale,hqx.hq2x,hqx.hq3x, orhqx.hq4x.importhqximportPIL.Imageimage:PIL.Image.Image=PIL.Image.open(...)x2:PIL.Image.Image=hqx.hq2x(image)x3:PIL.Image.Image=hqx.hq3x(image)x4:PIL.Image.Image=hqx.hq4x(image)# x2 == hqx.hqx_scale(image, 2))# x3 == hqx.hqx_scale(image, 3))# x4 == hqx.hqx_scale(image, 4))📰 ChangelogThe changelog is atCHANGELOG.md.📜 Licensehqx (python) is licensed under theLesser GNU Public License v2.1 (LGPL-2.1).
Package: hra-etl
Python ETL Base CodeThis project has the etl jupyter file for kick starting any new development, .whl file which has all the inbuilt etl functionality and boiler plate structure for any new integration.hra_etl library has following functionsBaseTable.decrypt (config file path,filename,path of the curretnt script,DSN name, flag)flag = 0 (no addition of as of date and file would be in GF temp folder)flag = 1 (as of date added and file will be in decypted folder)from hra_etl import BaseTable
import os
import sys

if __name__ == '__main__':
    path = os.path.dirname(os.path.realpath(__file__))
    filename = sys.argv[1]
    BaseTable.BaseTable.decrypt(path+"\\"+filename+".config",filename,path,'HRA','1')BaseTable.BaseTable.setup(path)where path is the location where the folders and files would be generated. Below are the folders and files it would generate on calling this functionControl fileIt has 5 files WF(overall workflow control file), stg, base, base-audit, pkg.Error_logIt would hold all teh error logs.Unittest_logto have all the logs for unittestingbkp.txtto store the bkp creation date.from hra_etl import BaseTable
import os
import sys

if __name__ == '__main__':
    path = os.path.dirname(os.path.realpath(__file__))
    BaseTable.BaseTable.setup(path)
Package: hrbot
The hrbotThe hrbot is a wrapper on top of theHighRise Python Bot SDKthat makes it easy to create bots inHighRise.Install the library:pipinstallhrbotFeatures:Quick and easy creation of an unlimited number of handlers for any eventFSM (finite state machine). Available storage in memory and RedisLarge number of available conditions in handlersWeb API supportUnreleased features:Spam blocking bypass. Allows you to send an unlimited number of identical messagesExample:fromhrbotimportBot,Dispatcherfromhrbot.types.hrimportUserdp=Dispatcher()bot=Bot(api_key='',room_id='',dispatcher=dp)@dp.on_user_join()asyncdefuser_join(user:User):"""Triggers when a player joins a room"""awaitbot.highrise.chat(f'Hi,{user.username}')@dp.on_user_leave()asyncdefuser_leave(user:User):"""Triggers when a player leaves the room"""awaitbot.highrise.chat(f'Goodbye,{user.username}')@dp.on_chat(command='help',case_ignore=True,prefix='.!')asyncdefhelp_command(user:User,message:str):"""Works for .help and !help messages. Not case-sensitive"""awaitbot.highrise.chat("Some text for help command")@dp.on_chat()asyncdefecho(user:User,message:str):"""Works for all chat messages"""awaitbot.highrise.chat(message)if__name__=='__main__':bot.start()
Package: hrbrthemes
Ref:https://dailyfinds.hrbrmstr.dev/p/drop-385-2023-12-08-weekend-project$python3-mpipinstallgit+https://gitlab.com/hrbrmstr/hrbrthemes-p9fromhrbrthemesimport*fromplotnineimport*fromplotnine.dataimportmtcars(ggplot(mtcars,aes("wt","mpg",color="factor(gear)"))+geom_point()+labs(title="hrbrmstr's Fav Example Plot",x="Weight (tons)",y="Miles-per-gallon")+theme_ipsum())
Package: hrcl-jobs
Hierarchical Python Jobs (hrcl_jobs)Installationpipinstallhrcl-jobsNOTEif you are using macos, you might need to do the following to install with pipbrewinstallmpich
sudofind/-namempiccAnd then run the pip install with the path to your mpiccenvMPICC=/yourpath/mpiccpip3installhrcl-jobs
Package: hrdns
hrdns is shortcut from h(etzner)r(obot)dns. I chosen shorter version because of possible license/trademark issues.Hetzner.de provides great hosting services in western europe. As their client, I wanted to automate someparts of our(me & my current company) infrastracture.This tool covers dns-management in Hetzner's Robot panel.Installation============You need access to pstats module from python's standard library. On ubuntu itcan be installed by following command:sudo apt-get installl python-profilerThen you can install hrdns by typing:easy_install hrdnsExamples of commandline usage=============================List of maintaned domains:hrobot_dns.py list -u<user> -p<password>Add new domain:hrobot_dns.py add -u<user> -p<password> -d domain.com -i 8.8.8.8Delete domain:hrobot_dns.py delete -u<user> -p<password> -d domain.comDump dns records:hrobot_dns.py show -u<user> -p<password> -d domain.comUpdating dns recods (from file):hrobot_dns.py update -u<user> -p<password> -d domain.com -f dnsrecords.txt== Storing username and password in safe way ==There 3 ways to pass username/password to script:1. Passing it through params which is unsafe.2. Environment variables HRDNS_USER, HRDNS_PASSWORD like this:export HRDNS_USER=<user>export HRDNS_PASSWORD=<password>hrobot_dns.py list3. By creating file ~/.hrdnsrc with source like this:[hrdns]user=<user>password=<password>FAQ===Q: I've deleted domain but it's still in `hrobot_dns.py list`!A: It's caused by delay of Hetzner's panel. I didn't find better solution than just wait.License notes=============If you aren't monkey, horse, goat or any other extraterrestrial lifeform - use X11/BSD.I'm not affiliated with the hetzner.de as a employee and i'm not representing them in any way.Use this library/tool at your own risk. Don't be evil.
Package: hrefs
Reada blog post from the library authordiscussing why this library exists.In a typical web application relationships between resources are modeled by
primary and foreign keys in a database (integers, UUIDs, etc.). The most natural
way to represent relationships in REST APIs is by URLs to the related resources
(explained inthis blog).hrefsmakes it easy to add hyperlinks betweenpydanticmodels in a declarative way. Just
declare aHreffield and the library will automatically convert between keys
and URLs:fromhrefsimportHref,BaseReferrableModelfrompydanticimportBaseModelclassBook(BaseReferrableModel):id:intclassConfig:details_view="get_book"classLibrary(BaseModel):books:list[Href[Book]]@app.get("/books/{id}")defget_book(id:int)->Book:returnBook(id=id)@app.get("/library")defget_library()->Library:"""
    Will serialize into:
    {"books":["https://example.com/books/1","https://example.com/books/2","https://example.com/books/3"]}
    """returnLibrary(books=[1,2,3])@app.post("/library")defpost_library(library:Library):"""
    Assuming the request contains
    {"books":["https://example.com/books/1","https://example.com/books/2","https://example.com/books/3"]}
    Will deserialize into: [1,2,3]
    """write_to_database([href.keyforhrefinlibrary.books])hrefswas written especially withFastAPIin mind, but integrates into any application or framework using pydantic to
parse and serialize models.Check out thedocumentationto get started!InstallationInstall the library usingpipor your favorite package management tool:$pipinstallhrefs
Package: hrep
hrepgrepfor binary files.ExamplesTODO add some...Usageusage: hrep [-h] [-x HEX] [-a ASCII] [-e REGEX] [-r] [--chunk-size CHUNK_SIZE]
            [-d] [-X] [-w DUMP_WIDTH] [-s] [-A AFTER] [-B BEFORE] [-C CONTEXT]
            [-I INCLUDE] [-E EXCLUDE] [-L] [-l] [-c] [-m NUM] [-p]
            [--no-color] [--monochrome]
            [HEX] [filename [filename ...]]

Search for binary sequences in files

positional arguments:
  HEX                   Hex encoded binary sequence to search for
  filename              List of files to search in

optional arguments:
  -h, --help            show this help message and exit
  -x HEX, --hex HEX     Search for a hexadecimal pattern('?' matches a single
                        nibble, '*' matches any number of bytes)
  -a ASCII, --ascii ASCII
                        Search for an ASCII string
  -e REGEX, --regex REGEX
                        Search for a regular expression
  -r, --recursive       Recursively search in directories
  --chunk-size CHUNK_SIZE
                        Override default buffer size
  -d, --decimal-offset  Output decimal file offsets (by default prints hex)
  -X, --no-hexdump      Disable hex dump
  -w DUMP_WIDTH, --dump-width DUMP_WIDTH
                        Width of hex dump
  -s, --summary         Print summary at the end
  -A AFTER, --after AFTER
                        Number of additional bytes to display after match
  -B BEFORE, --before BEFORE
                        Number of additional bytes to display before match
  -C CONTEXT, --context CONTEXT
                        Number of additional bytes to display before and after
                        match
  -I INCLUDE, --include INCLUDE
                        Filename pattern to include
  -E EXCLUDE, --exclude EXCLUDE
                        Filename pattern to exclude
  -L, --files-without-match
                        Only output unmatching filenames
  -l, --files-with-match
                        Only output matching filenames
  -c, --count           Only output number of matches for each input file
  -m NUM, --max-count NUM
                        Stop searching after NUM matches.
  -p, --progress        Enable progress display
  --no-color            Disable color output
  --monochrome          Use monochrome color scheme

Unless one of --files-with(out)-match, --count is specified, each output line
corresponds to a match in the format: `<filename>:<offset>:<match>'
Package: hrf_estimation
This is a Python package that implements several methods for the
joint estimation of HRF and activation patterns (aka beta-map) from
fMRI (BOLD) signal.If you use this software, please cite (at least) one of the following papers“Data-driven HRF estimation for encoding and decoding models”,
Fabian Pedregosa, Michael Eickenberg, Philippe Ciuciu, Bertrand Thirion and
Alexandre Gramfort. URL:http://hal.inria.fr/hal-00952554/en“HRF estimation improves sensitivity of fMRI encoding and decoding
models”, Fabian Pedregosa, Michael Eickenberg, Bertrand Thirion and
Alexandre Gramfort. URL:http://hal.inria.fr/hal-00821946/enInstallationhrf_estimation is a pure Python package and can be installed through the Python Package Index (PYPI):pipinstall-Uhrf_estimationYou can also download the source code from thePYPI websiteor get the latest sources fromgithubDocumentationDocumentation and function reference is available athttps://pythonhosted.org/hrf_estimation/DevelopmentThe newest version can alway be grabbed from thegit repository. Feel free to submit
issues or patches.AuthorsFabian Pedregosa<f@bianp.net>Michael Eickenberg <michael.eickenberg@nsup.org>Thanks toYaroslav Halchenko, Bug reports
Package: hrflow
HrFlow.ai Python SDKUnify, Unleash, Automate Talent & Workforce DataHrFlow.aiis the first System of Intelligence for Talent & Workforce Data, enabling leading AI-powered Talent & Workforce experiences. Our suite of APIs provide a suite of AI solutions to unleash clean, structured, normalized, updated and analyzed Talent Data with state-of-the-art seven AI modules.Furthermore, HrFlow.ai breaks data silos and creates a single source of truth (SSOT) for Talent Data. With our API connectors, businesses can sync data between their tools in milliseconds and build customizable workflows that meet their business logic.Our suite of APIs includesParsing API, Tagging API, Embedding API, Searching API, Scoring API, Imaging API, andOEM Widgets. With our Automation Studio and AI Studio, businesses can utilize AI-powered user interfaces andlow-code/no-codeautomations to create advanced custom user experiences.💡 HelpSeedocumentationfor more examples.🛠️ InstallationInstall usingpip install -U hrfloworconda install hrflow -c conda-forge.🪄 Quick startfromhrflowimportHrflowclient=Hrflow(api_secret="YOUR_API_KEY",api_user="YOU_USER_EMAIL")# read file from directory (in binary mode)withopen("path_to_file.pdf","rb")asf:file=f.read()#Parse it using this method without reference:response=client.profile.parsing.add_file(source_key="INSERT_THE_TARGET_SOURCE_KEY",profile_file=file,sync_parsing=1,# This is to invoke real time parsingtags=[{"name":"application_reference","value":"TS_X12345"}],# Attach an application tag to the profile to be parsed)📎 ResourcesSlackfor a speedy exchange of ideas between the Community and the HrFlow.ai teamHrFlow.ai Academyon Youtube for videos on how to get started with HrFlow.aiUpdates pageto keep you informed about our product releasesDocumentationto provide information on HrFlow.ai featuresOur Roadmapto show upcoming features or request new ones
Package: hrflow-importer
HrFlow ImporterDescriptionA python package for batch import of resume attachments to be parsed in HrFlow.hrflow-importeris an open-source project created byHrFlow.aito seamlessly import resume attachments from local folder into HrFlow.🪄 QuickstartWhat I can do?With Hrflow Importer, you canimporta batch of resume attachments in a local directory into HrFlow.ai to beparsed, using a command line directly from your terminal.How to use HrFlow Importer ?Prerequisites✨ Create a Workspace🔑 Get your API KeyCreate a SourceSet up a virtualenv. You can use[virtualenv](https://docs.python.org/3/library/venv.html)pipinstallvirtualenv# if not installedvirtualenv.venv# make sure you use python >3.6 before running this commandsource.venv/bin/activatepip install hrflow-importersetup your .env file. You can do this by running command:catenv.example>>.envAnd then fill the values in the.envfile accordingly.
Or simply :
`datafilesfailures
`exportSTORAGE_DIRECTORY_PATH=/absolute/path/to/data/directoryexportLOCAL_FILES_FOLDER=filesexportLOCAL_FAILURES_FOLDER=failuresRun the commandhrflow_importand fill the prompted values.🐇TADA! You should see a progress bar for the upload.🚀 EnvironmentTo find the list of dependencies, you can look at thepyproject.tomlfile:woman_technologist: ContributionsPlease feel free to contribute to the quality of this content by
submitting PRs for improvements to code, architecture, etc.Any contributions you make to this effort are of course greatly
appreciated.👉To find out more about how to proceed, the rules and conventions to follow, read carefullyCONTRIBUTING.md.🔗 ResourcesOur Developers documentation :https://developers.hrflow.ai/Our API list (Parsing, Revealing, Embedding, Searching, Scoring, Reasoning) :https://www.hrflow.ai/apiOur cool demos labs :https://labs.hrflow.ai:page_with_curl: LicenseSee theLICENSEfile for licensing information.⚙️ Develop HrFlow Importer :git clonegit@github.com:Riminder/hrflow-importer.gitswitch to python >3.6 (i recommend using pyenv as python version manager) pyenv shell 3.6.12install poetry if not installed (link)I recommend installing the virtual env inside the project directory : poetry config virtualenvs.in-project trueInstall the virtual env : poetry install and launch it using : poetry shell
Package: hrf_opt
Optimize hemodynamic response function parameters.A free & open source package for finding best-fitting hemodynamic
response function (HRF) parameters for fMRI data. Optimization takes
place within the framework of population receptive field (pRF)
parameters.The fitting process requires, for every voxel of fMRI data, optimized
pRF parameters. These can be obtained usingpyprf_feature.InstallationFor installation, follow these steps:(Optional) Create conda environmentcondacreate-nenv_hrf_optpython=2.7sourceactivateenv_hrf_optcondainstallpipClone repositorygitclonehttps://github.com/MSchnei/hrf_opt.gitInstall hrf_opt with pippipinstall/path/to/cloned/hrf_optHow to use1. Run pyprf_feature to obtain an initial guess of the pRF parametersSeeherefor more
information on how to use pyprf_feature. In brief, open a terminal and
run:pyprf_feature -config path/to/custom_pRF_config.csv2. Obtain model responses for every voxel for best-fitting pRF modelWhen pyprf_feature is done, run it again with -save_tc and -mdl_rsp
flag. This will save the fitted pRF model time courses and corresponding
neural responses to disk:pyprf_feature -config path/to/custom_pRF_config.csv -save_tc -mdl_rsp3. Adjust the csv file for hrf_optAdjust the information in the config_default.csv file in the hrf_opt
folder, such that the provided information is correct. It is recommended
to make a specific copy of the csv file for every subject.4. Run hrf_optOpen a terminal and run:hrf_opt -config path/to/custom_hrf_opt_config.csvReferencesThis application is based on the following work:Dumoulin, S. O., & Wandell, B. A. (2008). Population receptive field
estimates in human visual cortex. NeuroImage, 39(2), 647–660.https://doi.org/10.1016/j.neuroimage.2007.09.034Harvey, B. M., & Dumoulin, S. O. (2011). The Relationship between
Cortical Magnification Factor and Population Receptive Field Size in
Human Visual Cortex: Constancies in Cortical Architecture. Journal of
Neuroscience, 31(38), 13604–13612.https://doi.org/10.1523/JNEUROSCI.2572-11.2011LicenseThe project is licensed underGNU General Public License Version
3.
Package: hrfparser
Copyright (c) 2023 Sean Yeatts. All rights reserved.A convenience pipeline for working with Human-Readable Formats ( HRFs ) such
as YAML and JSON. It’s designed to easily read / write data between HRFs and
Python dictionaries, both in raw and flattened ( single key-value pairs )
formats.Features:Auto-conversion between different HRF formats based on file extensions.‘Unpacking’ of nested data to flattened, single key-value pairs.Current supported HRFs:YAMLJSONMethods:read() : read raw HRF from filewrite() : write raw HRF to destinationunpack() : read and flatten HRF data from filepack() : fold HRF data and write to destinationflatten() : deconstruct nested data as single key-value pairsfold() : rebuild data as nested key-value pairs
Package: hrid
HRID: Human Readable IdentifierThe Human Readable ID Generator Library For Python3UsageInstallpip3 install hridUse in Python codefromhridimportHRIDhruuid=HRID()uuid=hruuid.generate()print(uuid)Why HRID ?Comapareing to UUID, it's extremely easy to remember, that why this package namedhuman readable, examplered-bird-fly-crazilyversus206dbaab-526b-41cd-aa6f-7febd82e83ab.Over 800 bilions alphabet uuid can be generated by default (or many more if include more element). In the other hand, this library can guarentee that rarely, the uuid will be generated twice .Customizable structure for uuid, eg {adj}{noun} or {number}{adj}{noun}{verb}{adverd} or add whatever you wantprefix,postfixCreditDictionary SourceInspired by Google API DesignLicenseMIT
Package: hriddhiraj-pattern
hriddhiraj_patternThis is a pattern printing programUse the package in your projectInstall the packagepip install hriddhiraj-patternUsing the packageimport hriddhiraj-pattern.pattern as pattern

pattern.pattern_triangle(4)Hriddhiraj sarkar © 2023NoteThis is for a university project. Might not be maintained in future.
Package: hrl-pybullet-envs
Hierarchical Reinforcement envs in pybulletThis package was created because all of the HRL locomotion envs are only available in mujoco. This is an implementation of as many as possible in pybullet.Installpip install pybullet hrl_pybullet_envsThis project requirespybullet-gymwhich must be installed along side this package.Envs:AntGatherBulletEnv-v0AntMazeBulletEnv-v0AntMjBulletEnv-0AntFlagrunBulletEnv-v0PointGatherBulletEnv-v0ExampleAlso seethis notebookimport hrl_pybullet_envs
import gym
import numpy as np

env = gym.make('AntGatherBulletEnv-v0')
env.render()
ob = env.reset()
tot_rew = 0

for i in range(1000):
  # Take random actions
  ob, rew, done, _ = env.step(np.random.uniform(-1, 1, env.action_space.shape))
  tot_rew += rew

  if done: break

print(f'Achieved total reward of: {tot_rew}')