Saravanan666/pypi-org huggingface dataset:
Package: horriblesubs-downloader
HorribleSubs DownloaderA simple anime torrent downloader.Features:Quickly download anime torrents from HorribleSubs in your terminal.Download the whole season in a single command.Use alias for anime with long name.Note: The downloader doesn't work for older anime that has no torrent link. Support for magnet link will be added in the future.Table of ContentsInstallationUsageLicenseInstallationYou needPython 3.x.xto install and use the downloader.
You also need Google Chrome (Support for Firefox and other browsers will be added in the future).pip install horriblesubs-downloaderDownloadchromedriverand extract out the file inside the ZIP.Type in your terminal:hsd --config driver_path <PATH TO CHROMEDRIVER>Set your download path:hsd --config download_path <PATH>You're ready to download some anime!UsageUsage:
    hsd <name> <episode> [--res <res>] [--to <path>]
    hsd <name> <start> <end> [--res <res>] [--to <path>]
    hsd <name> --batch [--res <res>] [--to <path>]
    hsd --alias [<alias>] [<real>]
    hsd --config [<key>] [<value>]

Options:
    -h --help           Show this screen.
    -b --batch          Download multiple torrents.
    -r --res <res>      Set resolution.
    -t --to <path>      Download file to path.
    -a --alias          Display or set alias.
    -c --config         Display or set config.Examples# Download episode 5 of One Punch Man
hsd "One Punch Man" 5

# Download episode 1-3 of KonoSuba
hsd --alias "KonoSuba" "Kono Subarashii Sekai ni Shukufuku wo!"
hsd "KonoSuba" 1 3

# Download the whole season of Steins Gate in 720p
hsd "Steins Gate" --batch --res 720

# Display all aliases and config
hsd --alias
hsd --configLicenseMIT License
Package: hors
Horshors- это модуль python для распознавания даты и времени в естественной речи на русском языке. Умеет понимать сложные
конструкции с абсолютными и относительными датой и временем. В том числе временные периоды.Хорс— это славянский бог солнцаОригинальная версия библиотеки написана Денисом Пешехоновым на C# и доступна наgithubпод лицензией MIT. Изменения логики минимальныУстановкаpipinstallhorsИспользование>>>importhors>>>r=hors.process_phrase('Утром 3 сентября 2059 года мы слушали Шуфутинского')>>>r.dates[0].type<DateTimeTokenType.FIXED:1>>>>r.dates[0].date_fromdatetime.datetime(2059,9,3,9,0)>>>r=hors.process_phrase('Полёт Гагарина длился с 9 утра 12 апреля 1961 года до 11 утра')>>>r.dates[0].type<DateTimeTokenType.PERIOD:2>>>>r.dates[0].date_fromdatetime.datetime(1961,4,12,9,0)>>>r.dates[0].date_todatetime.datetime(1961,4,12,11,0)Тестированиеpython-munittestdiscovertests
Package: horseman
Horseman is a toolkit to build WSGI applications.
It is heavily tested and uses Cython powered libraries.The philosophy is : “you pay for what you eat”.The code is very minimal and tries to provide key components to build
upon and create a vastly more complex application.It conforms to the WSGI standards and allows you to use WSGI middlewares.ExampleBelow is an example of a barebone API, handling a GET request on ‘/’
and returning a JSON response.importloggingfrombjoernimportrunfromhorseman.metaimportSentryNode,Overhead,APIViewfromhorseman.responseimportResponseclassRequest(Overhead):data=Nonedef__init__(self,environ):self.environ=environdefextract(self):self.data='somedata'classView(APIView):defGET(self,overhead):returnResponse.to_json(200,{"Result":"OK"})VIEWS={"/":View()}classRootNode(SentryNode):defresolve(self,path_info,environ):ifview:=VIEWS.get(path_info):request=Request(environ)returnview(request)defhandle_exception(self,exc_info,environ):logging.error(exc_info)run(host="0.0.0.0",port=8080,reuse_port=True,wsgi_app=RootNode(),)CHANGES0.6 (2022-08-25)Major update.Simplified the parsingDataclass by dropping the attempts at
mimickingMultiDict. Parsing no longer separate files from form
data and values are stored as a list of tuples containing (name, value).FormData,TypeCastingDictandQueryclasses were removed.0.5 (2022-05-31)Multipart parser no longer adds empty values to the form multidict.0.4 (2022-04-06)FixedFormData.to_dictto handle empty or false values.0.3 (2022-04-05)PATH_INFO is no longer expected to be there in the environ.
Some WSGI Servers do NOT provide it if empty.Added path normalization in the Node__call__to avoid malformed
path info.0.2 (2021-10-08)First upload on pypi. Stable 0.2.0.1 (2021-10-08)Initial release.
Package: horseshit
horseshithorseshitis an easy-to-use command line program that blocks
websites known to distract us from our work, which is forked fromleftnode/get-shit-done.Available in Python 2.x/3.x, horseshit is also a PyPI package that can
be easily installed and updated viapip.Project homepage:http://www.soimort.org/horseshitInstallation1. Using the PyPI package:Install the PyPI package:$ [sudo] pip install horseshitor:$ [sudo] easy_install horseshit2. Using Git:Clone the Git repository:$ git clone git://github.com/soimort/horseshit.git
$ [sudo] python setup.py installUsage1. Configurationhorseshitsis a no-brainer plain text file contains a load of
horseshits that may distract you from work, line by line.twitter.com
plus.google.com
reddit.comOn *nix systems, put yourhorseshitsinto:/etc/horseshitsOr: (recommended!)~/.config/horseshitsOn Windows, put it into your user directory:.config/horseshits2. To get-shit-doneExecute it as root because it modifies your hosts file and restarts your
network daemon.$ sudo get-shit-done work3. To no longer get-shit-done$ sudo get-shit-done playAdditional TipsYou can, of course, useget-shit-donewith yourcrontab, to
control your work time and play time during the day. Whatever, I should
say self-control is always the best.AcknowledgementThanks to Vic Cherubini, the original author ofget-shit-done.Changelog0.0.2Date: 2013-01-14Initial release.
Package: horsql
horsqlAn experimental SQL ORM that operates with Pandas DataFrames, offering the flexibility of dynamic querying without the need for model or schema definitions.Install$pipinstallhorsqlConnectdb=horsql.connect(database="mydb",host="localhost",port=5432,user="dev",password="dev",dialect="postgresql",# or "mysql"echo=False,pool_size=5,# defaults to 5)Queryingimporthorsql.operatorsaso# Get all usersdf=db.public.users.get()# Get some columns of the users that are +18df=db.public.users.get(columns=["user_name","age"],age=o.EqualsOrGreaterThan(18))# (Aggregation) get the average age by city from Brazildf=db.public.users.get(columns=["city"],avg=["age"],country="Brazil")# Distinct columnsdf=db.public.users.get(distinct=["last_name"])# get users that were born between those datesdf=db.public.users.get(birth_date=o.Between(["1998-01-01","2000-01-01"]))# get users that it's last_name is Silva or Machadodf=db.public.users.get(last_name=["Silva","Machado"])# get users that it's last_name is not Silva or Machadodf=db.public.users.get(last_name=o.Not(["Silva","Machado"]))# get users from Brazil or those that have "Silva" as last_namedf=db.public.users.get(where=o.Or(country="Brazil",last_name="Silva"))# get users from United States OR those that have "Smith" as last_name# OR (first_name is "Wilian" AND last_name is "Silva")df=db.public.users.get(where=o.Or(country="United States",last_name="Smith",o.And(first_name="Wilian",last_name="Silva")))# Orderingdf=db.public.users.order_by("age",ascending=True).get()df=db.public.users.order_by(["age","country"],ascending=[True,False]).get()# Limitdf=db.public.users.limit(limit=10).get()df=db.public.users.order_by("age",ascending=True).limit(limit=10).get()# Paginationdf=db.public.users.paginate(page=1,page_size=10).get()df=db.public.users.order_by("age",ascending=True).paginate(page=1,page_size=10).get()Creating/Updating records in the databasenew_user=pd.DataFrame([{"user_name":"WilianZilv","first_name":"Wilian","last_name":"Silva"}])# Create new records based on a dataframedb.public.users.create(new_user)# Upsertdb.public.users.create(new_user,on_conflict=["user_name"],update=["city","country"])# Updating recordsnew_user["city"]="Curitiba"new_user["country"]="Brazil"db.public.users.update(new_user,on_conflict=["user_name"],update=["city","country"])# Delete recordsdb.public.users.delete(user_name="WilianZilv")Function definitionsColumns=Union[str,List[str]]# Functions available in the Table objectdefget(self,columns:Optional[Columns]=None,distinct:Optional[Columns]=None,min:Optional[Columns]=None,max:Optional[Columns]=None,sum:Optional[Columns]=None,avg:Optional[Columns]=None,count:Optional[Columns]=None,where:Optional[Union[And,Or]]=None,**and_where,):...defcreate(self,df:pd.DataFrame,on_conflict:Optional[Columns]=None,update:Optional[Columns]=None,commit:bool=True,):...defupdate(self,df:pd.DataFrame,on_conflict:Columns,update:Columns,commit:bool=True,):...deflimit(self,limit:int):...defpaginate(self,page:int,page_size:int):...deforder_by(self,columns:Union[List[str],str],ascending:Union[List[bool],bool]=[]):...
Package: horst
horst makes it more easy to handle many depending SQL statements in a SQL script or SQL procedure.
The main support of horst is: Identical field lists in SELECT, INSERT, JOIN, WHERE, GROUP are managed
at ONE code line.I created horst to manage the beast of data transformation with a chain of SQL statements in SQL procedures.
In these procedures we use temporary tables to collect records, transform these records and write the results
into the target table. Each additional new information aka field was a pain in the ass as we have to investigate
where to add these new field.
With horst it became a nice task.supported SQL languages.Google BigQueryExtended BNF of horststatement = table_declaration| clone_table| drop tables| list_fields| join_fields| commenttable_declaration = create table table_name field_listclone_table = clone table ID as ID {add field_list | without field_names}list_fields = table_name {as table_alias} fields {with type} {without field_names}join_fields = table_name {as table_alias} on table_name {as table_alias} {(with | without) field_names}comment = -- *field_list = field_definition {, field_definition}field_definition = field_name field_typefield_type = BOOL | INTEGER | STRING | TIMESTAMPfield_names = field_name {, field_name}field_name = IDtable_name = IDtable_alias = IDID = RegEx([a-zA-Z_][a-zA-Z0-9_]*)  \code example$ python horst.py this_horst_scriptfile with horst code: horst.this_horst_script.sqlresult sql file: this_horst_script.sql
Package: horton-grid
HORTON-GRIDThe Grid used inHelpfulOpen-sourceResearchTOol forN-fermion systems.OverviewHORTON-GRID is an integral grid that was initially implemented in Horton 2. This updated version now supports Python 3.10 and above.HORTON-GRID is an essential tool used in computational chemistry. It provides functionalities for creating and manipulating molecular grids which are used in various scientific computations.For more information, visit HORTON's website:http://theochem.github.io/horton/latest:warning: The new API ofgridinHortonhas been changed athttps://github.com/theochem/grid. The code is now purely Python and has been refactored since then. Its API has been updated to be more robust, flexible, and user-friendly, resulting in higher quality code. It is (to be) distributed undercondaandpip. If you are thinking of doing active development in grid, I highly encourage you to do so athttps://github.com/theochem/grid.Key FeaturesMolecular grids for computational chemistry.Implemented in Python 3.10 for broad compatibility with scientific computing packages.Adheres to strict code formatting standards, using tools such as Black and Ruff.Built with a focus on scientific research and education.InstallationFor Userspip install horton-gridFor DevelopersClone the repository:gitclonegit@github.com:yingxingcheng/horton-grid.gitNavigate to the horton-grid directory:cdhorton-gridInstall the package:pipinstall-e.DependenciesThe horton-grid project depends on the following Python packages:NumPypre-commitpytestnoseThese dependencies will be automatically installed when you install horton-grid.
Package: horton-part
HORTON-PARTAboutThis package implements various partitioning schemes described inthis paper.The methods included in this library are:Becke methodMulliken methodHirshfeld partitioning schemeIterative Hirshfeld (Hirshfeld-I) partitioning schemeIterative stockholder approach (ISA)Gaussian iterative stockholder approach (GISA)Minimal Basis Iterative Stockholder (MBIS)Linear approximation of the ISA (L-ISA) methodLicensehorton-partis distributed under GPL License version 3 (GPLv3).DependenciesThe following dependencies will be necessary forhorton-partto build properly,Python >= 3.10:http://www.python.org/SciPy :http://www.scipy.org/NumPy :http://www.numpy.org/Nosetests :http://readthedocs.org/docs/nose/en/latest/pytest :https://docs.pytest.org/en/7.3.x/contents.htmlmatplotlib :https://matplotlib.org/quadprog>=0.1.11 :https://github.com/quadprog/quadprogcvxopt>=1.3.1 :https://github.com/cvxopt/cvxoptqc-iodata :https://github.com/theochem/iodatahorton-grid :https://github.com/yingxingcheng/horton-gridpep517 :https://peps.python.org/pep-0517/(for developers)pre-commit :https://pre-commit.com/(for developers)horton-grid :http://github.com/yingxingcheng/horton-gridIn order to use horton-grid, the following libraries with latest version should be installed manually.gbasis :https://github.com/theochem/gbasis(for running examples only)To fix the error and install the required libraries, follow these steps:Go to the gbasis GitHub repository:https://github.com/theochem/gbasisFollow the installation instructions provided in the repository's README file.The dependence onhorton-gridis only because of thegridmodule. This will be replaced byqcgridsin
the near future.InstallationTo installhorton-part:gitclonehttp://github.com/yingxingcheng/horton-partcdhorton-part
pipinstall.[--user]For developers:pipinstall-e.TestingTo run tests:gitclonehttp://github.com/yingxingcheng/horton-part
pytesthorton-part
Package: horus-compile
This is the compiler for the Horus formal verification tool. See themain
repositoryfor full
documentation.DisclaimerKindly note, Horus is a tool consisting of two separate components: Horus-Check, released under the AGPLv3 license, and Horus-Compile, released under the Cairo Toolkit License. When "Horus" is referenced, the reference is to the two components jointly.Horus is currently in the alpha stage and no guarantee is being given as to the accuracy and/or completeness of any of the outputs the tool may generate. The tool is provided on an 'as is' basis, without warranties or conditions of any kind, either express or implied, including without limitation as to the outputs of the verification process and the security of any system verified using Horus. As per the relevant licenses, to the fullest extent permitted by the law, Nethermind disclaims any liability in connection with your use of Horus and/or any of its outputs.Please also note that the terminology used by Horus, including but not limited to words such as 'guarantee', should be interpreted strictly within the remit of formal verification terminology. These words are not intended to, and shall not be construed as having legal significance of any kind.For the avoidance of doubt, the outputs generated by Horus and/or your usage thereof shall not be considered or relied upon as any form of financial, investment, tax, legal, regulatory, or other advice.Horus-Check is licensed under AGPLv3 (Copyright (C) 2023 Nethermind). For more information on the dependencies, please seehere.Horus-Compile is licensed under the Cairo Toolkit License (Copyright (C) 2023 Nethermind), pursuant to an exception granted to Nethermind by Starkware Industries Ltd. For more information on the dependencies please seehere.
Package: horus-media-client
Horus Media Server ClientInstall latest releaseExample toolsInteractive examples: they require access to the horus test playground to run.Spherical cameraThis example shows how a seriesminimum of 3of geo referenced pixelsGeoReferencedPixelobtained from a spherical image are used to calculate an accurate GeographicLocation for a specific label.python -m horus_media_examples.spherical_camera --helpRecordings toolThis example can be used to list published recordings.python -m horus_media_examples.recordings_tool --helpExport sphericalThis example can be used to export spherical views from a set of recordings.python -m horus_media_examples.export_spherical --helpExport orthographicThis example can be used to export orthographic views from a set of recordings.python -m horus_media_examples.export_orthographic --helpTriangulation examplesThese examples require to manually install these modules:pip install pandas pandera fiona geopandasRun these examples in order.python -m horus_media_examples.spherical_camera_single_measurement --helppython -m horus_media_examples.single_measurement_clusteringpython -m horus_media_examples.triangulate_spherical_camera_single_measurement_clusterspython -m horus_media_examples.clustering_analyticsRun the example strategypython3 -m horus_media_examples.example_strategy --help
Package: horuz
Horuz!. Save and query your recon data on ElasticSearch.InstallingInstall and setting up ElasticSearchhttps://www.elastic.co/guide/en/elasticsearch/reference/current/install-elasticsearch.htmlInstall and setting up Horuz$pip3installhoruz$hzconfigserver:addhttp://yourelasticsearchendpoint:9200Usage$hz--help$hzconfigserver:statusElasticSearch is connected to http://localhost:9200 successfully!Collect dataCustom JSON filesIn this example, we have an httprobe.txt file, then it will be transformed to JSON file.$ cat httprobe.txt | jq -Rnc '[inputs|split("\n")|{("host"):.[0]}]' > httprobe.jsonThen, upload it to ES.$ hz collect -p example.com -f httprobe.json
⠦ Collecting...
Session name: gallant_satoshi_8455236

Results: 1366

$ hz search -p example.com -q "session:gallant_satoshi_8455236" -oJ -f time,host -s 2Query searchSearch by range dates:$hzsearch-pexample.com-q"time:[2020-04-15 TO 2020-05-20]"Search by wildcard in the field$hzsearch-pexample.com-q"result.html:*key*"-oJ-fhtmlPipe the result to other commands$hzsearch-pexample.com-q"session:*"-oJ-f_id,session,time|jq".[].session"|sort-
Package: hoshi
This package provides primitives and highly opinionated infrastructure to
setup and manage i18n and i10n efforts for python projects. It is a thin
wrapper aroundbabel, which you can
and probably should use directly if you are comfortable with it.Package InformationThe latest version of the documentation, including installation, usage, and
API/developer notes can be found atReadTheDocs.The latest version of the sources can be found atGitHub. Please use
GitHub’s features to report bugs, request features, or submit pull/merge requests.The principle author forhoshiis Chintalagiri Shashank. The
author can be contacted if necessary via the information on theauthor’s github profile. See the AUTHORS file
for a full list of collaborators and/or contributing authors, if any.hoshiis distributed under the terms of theMIT License.
A copy of the text of the license is included along with the sources.
Package: hoshrust
hoshrust (seehoshfor the implementation of the current specification)Fast cryptographic 22-digit hash and operators for Rust and Python.
This is based on the Symmetric group, which is not robust to many repetitions (seehoshfor a robust 40-digit version).Python installationfrom package# Set up a virtualenv.python3-mvenvvenvsourcevenv/bin/activate# Install from PyPIpipinstallhoshrustfrom sourcecdmy-project
gitclonehttps://github.com/davips/hoshrust../hoshrust
pipinstall-e../hoshrustExamplesBasic operationsfromhoshrustimportHash# Hashes can be multiplied.a=Hash(blob=b"Some large binary content...")b=Hash(blob=b"Some other binary content. Might be, e.g., an action or another large content.")c=a*bprint(f"{a}*{b}={c}")"""0v58YxIhaae5NfYuXsoC1i * 04orKjYHAZraYORILOVwos = 3yT1A5oLlW2HpjSkgzo2yg"""# Multiplication can be reverted by the inverse hash. Zero is the identity hash.print(f"{b}*{~b}={b*~b}= 0")"""04orKjYHAZraYORILOVwos * 211eErwhEiGnit0beo4tjo = 0000000000000000000000 = 0"""print(f"{c}*{~b}={c*~b}={a}= a")"""3yT1A5oLlW2HpjSkgzo2yg * 211eErwhEiGnit0beo4tjo = 0v58YxIhaae5NfYuXsoC1i = 0v58YxIhaae5NfYuXsoC1i = a"""print(f"{~a}*{c}={~a*c}={b}= b")"""4q4X1jczNK2eKCV4uxEPNk * 3yT1A5oLlW2HpjSkgzo2yg = 04orKjYHAZraYORILOVwos = 04orKjYHAZraYORILOVwos = b"""# Division is shorthand for reversion.print(f"{c}/{b}={c/b}= a")"""3yT1A5oLlW2HpjSkgzo2yg / 04orKjYHAZraYORILOVwos = 0v58YxIhaae5NfYuXsoC1i = a"""# Hash multiplication is not expected to be commutative.print(f"{a*b}!={b*a}")"""3yT1A5oLlW2HpjSkgzo2yg != 4AvOF9Fbhakd26mosfuuvR"""# Hash multiplication is associative.print(f"{a*(b*c)}={(a*b)*c}")"""51UdYbEAGI5mVogE4aFFKe = 51UdYbEAGI5mVogE4aFFKe"""Features
Package: hospital
hospitalis a Python framework to write health checks, smoke tests or
diagnoses around applications or services.AbstractHealth checks are kind of tests, applied to running applications and services:write healtchecks just as you would write tests, using assertions;collect and run healthchecks with test runners;use healthchecks to validate deployments;plug healthchecks in supervision and monitoring tools;in case of incidents, use healthchecks to diagnose problems.ExampleIn your project’s root package, have ahealthcheckspackage or module,
where you assert your (running) application or service is ok:importunittestimporthospital@hospital.healthcheckclassDocumentationHealthCheck(unittest.TestCase):deftest_http_200(self):url='http://hospital.readthedocs.org/en/0.6/'hospital.assert_http_response(url,status_code=200)Then you can collect and run the healthchecks with command line or web
service. Here is an example with command line:$hospital-cli<YOUR-PACKAGE>.healthchecksProject statushospitalis not full-featured yet. Some important features are in theroadmap. See alsovision.Of course, any ideas, feedback or help are welcome :)ResourcesDocumentation:https://hospital.readthedocs.orgIRC:#python-hospitalon freenodeMailing-list:pythonhospital@librelist.com,
see archives athttp://librelist.com/browser/pythonhospital/PyPI page:https://pypi.python.org/pypi/hospitalCode repository:https://github.com/python-hospital/hospitalContinuous integration:https://travis-ci.org/python-hospital/hospitalBugs & feature requests:https://github.com/python-hospital/hospital/issuesChangelog:https://hospital.readthedocs.org/en/latest/about/changelog.htmlRoadmap:https://github.com/python-hospital/hospital/milestones
Package: hoss
This is Python agent for Hoss. Hoss tracks and manages 3rd party API. It lets developers quickly add best practices
in integrating with 3rd party API, for example: logging, alerting, auto retry, request queuing and moreSign up athttps://hoss.comfor a free accountInstallhoss is available on PyPI and thus can be installed with pip on most platforms.:$ pip install hossDocumentationSee the documentation athttps://docs.hoss.com/docs/python-agent