Saravanan666/pypi-org huggingface dataset:
Package: hasami
HasamiHasami is a tool to perform sentence segmentation on japanese text.In addition to simply splitting on sentence-ending markers like！？。it will treat runs of sentence-ending characters as a single sentence ending.It will not split enclosed sentences, i.e. those in quotes or parentheses.It can be configured with custom sentence-ending markers and enclosures
in case the defaults don't cover your needs.You can define exceptions for when not to split sentences.InstallationpipinstallhasamiUsageA simple command line interface is provided to use the functionality
without having to write your own script. Input is read fromstdinor from a file.$echo"これが最初の文。これは二番目の文。これが最後の文。"|teeinput.txt|hasami
これが最初の文。
これは二番目の文。
これが最後の文。

$hasamiinput.txt
これが最初の文。
これは二番目の文。
これが最後の文。To use in your code:importhasamihasami.segment_sentences('これが最初の文。これは二番目の文。これが最後の文。')# => ['これが最初の文。', 'これは二番目の文。', 'これが最後の文。']More complex examples will follow soon, please refer to the test cases in the meantime.LicenseLicensed under the BSD-3-Clause License
Package: hasanasha
----[Module-Install]----pip install hasanasha----[Normal-Color-Use]----hasanasha.R = print Red Color
hasanasha.G = print Green Color
hasanasha.Y = print Yellow Color
hasanasha.B = print Blue Color
hasanasha.P = print Pink Color
hasanasha.C = print Cyan Color
hasanasha.W = print White Color
hasanasha.BL = print Black Color----[Baground-Color-Use]----hasanasha.BG_R = print Baground Red Color
hasanasha.BG_G = print Baground Green Color
hasanasha.BG_Y = print Baground Yellow Color
hasanasha.BG_B = print Baground Blue Color
hasanasha.BG_P = print Baground Pink Color
hasanasha.BG_C = print Bagrount Cyan Color
hasanasha.BG_W = print Baground White Color----[Resset-Color]----hasanasha.N = Bagrount Color End----[Use-Mix-8-Color]----hasanasha.mix_color = print mix 8 color----[Advance-Option]----hasanasha.os = os.system
hasanasha.ts = time.sleep
hasanasha.rc = hasanasha
hasanasha.rr = random.randint
hasanasha.op = open
hasanasha.pr = print
hasanasha.rqg = requests.get
hasanasha.rqp = requests.post
hasanasha.seg = session.get
hasanasha.sep = session.post
hasanasha.syw = sys.stdout.write
hasanasha.syf = sys.stdout.flush----[Logo-Use]----hasanasha.logo1 = main logo print
hasanasha.logo2 = logo details ptint----[Line-Use]----hasanasha.linex1 = face down line print
hasanasha.linex2 = face up line print
hasanasha.linex3 = normaly line print
Package: hasattrs
HasAttrsA pure python package used to check if objects have the same attrs as
collections.abc types.DescriptionUse HasAttrs to check if objects have the same attributes as the
classes in collections.abs, such as Mapping and MutableSequence.
HasAttrs has no dependencies outside Python.Getting StartedDependenciesPython>=3.6Installingpip install hasattrsExecuting programHow to run the programStep-by-step bulletsfrom collections.abc import Mapping
from hasattrs import has_mapping_attrs
from hasattrs import has_abc_attrs

class Map:
    def __getitem__(self, key): ...
    def __iter__(self): ...
    def __len__(self): ...
    def __contains__(self, value): ...
    def keys(self): ...
    def items(self): ...
    def values(self): ...
    def get(self, key): ...
    def __eq__(self, other): ...
    def __ne__(self, other): ...

# isinstance does not work for Mapping
isinstance(Map(), Mapping) -> False

# but hasattrs has_mapping_attrs does work
has_mapping_attrs(Map()) -> True

# has_abc_attrs also works by passing in collections.abc classes
has_abc_attrs(Map(), Mapping) -> TrueAuthorsContributors names and contact infoOdos Matthews:odosmatthews@gmail.comLicenseThis project is licensed under the MIT License - see the LICENSE.md file for details
Package: hasemoji
Has EmojiCheck whether a string or character has any emojiScreenshotInstall$ pip install hasemojiUsageimporthasemojiprint(hasemoji.char('😃'))#=> Trueprint(hasemoji.string('I 💖 emoji'))#=> Trueprint(hasemoji.char('I'))#=> Falseprint(hasemoji.string('I love emoji'))#=> FalseLicenseMITYoginth
Package: has-flag
has-flagCheck if argv has a specific flag.This is a port of the Node.js packagehas-flagto Python.Installpython3 -m pip install -U has-flag(That strange-looking setup command is because I've found it to be the most reliable. Thepipcommand often aliases to python 2, andpip3often installs to the wrong Python package directory.)Usagefromhas_flagimporthas_flaghas_flag('unicorn');#>>> Truehas_flag('--unicorn');#>>> Truehas_flag('f');#>>> Truehas_flag('-f');#>>> Truehas_flag('foo=bar');#>>> Truehas_flag('foo');#>>> Falsehas_flag('rainbow');#>>> False$ python3 foo.py -f --unicorn --foo=bar -- --rainbowLicenseMITContactA library byShawn Presser. If you found it useful, please considerjoining my patreon!My Twitter DMs are always open; you shouldsend me one! It's the best way to reach me, and I'm always happy to hear from you.Twitter:@theshawwnPatreon:https://www.patreon.com/shawwnHN:sillysaurusxWebsite:shawwn.com
Package: hashable_collections
AboutThis library enables dictionaries and lists to be used as keys inside a
dictionary. In other words, it makes them hashable.While mutable objects (lists, dictionaries) should not be made hashable
in general, the programmer is trusted not to abuse this power (youdotest your code before shipping into production, don’t you?). An
extension option to explicitly make the resulting hashable object
immutable is provided below for convenience.There are certain use cases - e.g. when trying to pass seemingly
identical keys toNetworkXas different
nodes, or when you want to query an object’s properties in place while
making a mapping instead of calling a complicated identification
function - where these may be useful and reduce boilerplate code.Usage>>> from hashable_collections.hashable_collections import hashable_dict
>>> hashed_dict = hashable_dict({'name':'foo'})
>>> from hashable_collections.hashable_collections import hashable_list
>>> hashed_list = hashable_list(['bar',1])
>>> output = {hashed_dict:0,hashed_list:1}
>>> output
{{'name':'foo'}: 0, ['bar', 1]: 1}These hashable objects still retain mutability - in other words, it is
still possible to assignhashed_dict['squiggle']= 'squiggle'and
have it execute without an issue. The hash will change correspondingly,
effectively making it a different object from before.Alternatively, one can subclass the objects defined here and override
the__setitem__method to make sure the resulting hashable
dictionary/list is immutable:class immutable_hashable_dict(hashable_dict):

    def __setitem__(self,key,value):
        raise ValueError('Immutable hashable dicts do not let you change values inside your dictionary.')

class immutable_hashable_list(hashable_list):

    def __setitem__(self,key,value):
        raise ValueError('Immutable hashable lists do not let you change valus inside your list.')CaveatsThe following is a list of known issues that may crop up with this
technology.Creating a copy: Ifsis ahashable_dict, and one doesm = sand then changesm[0], the corresponding value ofs[0]is changed as well.Neverassign an existing
hashable_dict or hashable_list to another object unless you are
sure the second object is not going to change.Installationpip install hashable_collections
Package: hashable-df
hashable_dfIf you have ever tried to use native python objects in Pandas DataFrames,
you may have run into an issue similar to this:df=pd.DataFrame({"A":[1,2,3,4],"B":["a","b","c","d"],"C":[[1,2,3],[1,2],[1,2,3],4],"D":[{1:1,2:2},{1:1,3:3},{1:1,4:4},{1:1,2:2}],"E":[[{1:{2:2}},{2:{3:3}}],[{1:{2:2}},{2:{3:3}}],[{1:{2:2}},{2:{3:3}}],[{1:{2:2}},{2:{3:3}}]]})df['C'].unique()TypeError: unhashable type: 'list'This is caused by unhashable values in the DataFrame cells.This small library helps to resolve that making this possible:fromhashable_dfimporthashable_dfhashable_df(df)['E'].unique()returningarray([[{1: {2: 2}}, {2: {3: 3}}]], dtype=object)
Package: hashback
⚠️ Project Status ⚠️⚠️ Hashback is still in ALPHA. ⚠️⚠️ Do NOT use this for critical backups! ⚠️HashbackHashback is a backup system.It's designed to take snapshot backups of multiple devices (eg: multiple servers) Using only the storage you might
expect for incremental backups.Hashback indexes files and directories by the sha256 hash of their content.  Metadata data such as file ownership and
file names are stored in the directory listings, not the file backups allowing files to be moved around and renamed
without duplicating the file content, even when moving across devices.Configure your serverYou can install with either:Docker (instructions)Python (instructions)Configure your clientThe client can be run through docker-compose as well.  Just remember to bind mount your data directory in so that it can
be backed up.See the output from authorizing your client for these values:# See installing server instructions for credentials

hashback configure \
    --client-id 3bed0c4f-a1c9-4f37-b2b5-8b393c190a40 \
    --database-url https://example.com/ \
    --credentials '{
        "auth_type": "basic", 
        "username": "3bed0c4f-a1c9-4f37-b2b5-8b393c190a40", 
        "password": "fa72112f-a9a8-4be2-b293-124bf875f86c"
      }'This repo includeshashback(client) command line toolThis is the backup client intended for taking frequent snapshots systems as well as restoring backups.hashback can be used to backup to a local database without using a server or it can backup to a remote server.hashback-db-adminadmin commandline toolThis is used to create and manage backup databases.  This is initially required to setup a device in the database before
that device can begin to backup.hashback-basic-servera simple http backup serverThis is intended as an MVP server.  It only supports http auth type basic.  It is highly recommended to sit this behind
https reverse gateway such asTraefik.Copyright 2021 Philip CoulingPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Package: hashboard
IntroductionHatsya Hashboardis a tool for estimating the profitability of bitcoin
mining ASICs.The core of Hashboard is amodel-based simulator, which rolls out many
(1250 by default) independent stochastic simulations of relevant variables
(including hashrate, difficulty, price, and block rewards) to obtain more
accurate estimates of the profitability of an ASIC.This is used to updatethis pagelisting the available ASICs fromCompass Miningordered in descending order of estimated probability of being profitable
over a five-year horizon.MethodologyThe salient ways in which Hashboard's methodology differs from other mining
calculators are summarised below:Uncertainty estimates: predicting the future with certainty is
impossible. By running many simulations, Hashboard obtains a distribution
of outcomes instead of a single outcome, reflecting the uncertainty
in the model.Joint distribution modelling: it is often said that price drives
hashrate, and hashrate drives price. Hashboard uses avector
autoregressive (VAR)model which jointly simulates these variables
(and others such as transaction fees) together, rather than in isolation,
for a more realistic simulation.Expressive model: the VAR model is strictly more general than
many approaches to modelling bitcoin's behaviour, including S2F(X),
geometric Brownian motion, models with diminishing returns, and
simple models based on technical and fundamental (on-chain) data. The
model is trained on historic data (from Block 120960 to present) and
minimises overfitting by incorporating a regularisation penalty that
is optimised by cross-validation.Block time: the simulator internally uses block height instead of
wall-clock time, enabling the more accurate simulation of block subsidy
halvings, difficulty adjustments, and computation of mining rewards.
The simulator advances by steps of 48 blocks (an average of 8 hours)
and treats wall-clock time as a dependent variable.Moreover, Hashboard is free open-source software (MIT licenced), which
means that you can read and modify the source code. It is designed to
be modular and extensible, allowing you to add new data sources (such as
custom on-chain data) and customise the models.
Package: hashbrown
hashbrownA Runge-Kutta 4th order solver program for initial value differential equationsDeveloped, Documented and Managed by Hyungho ChoiDesigned Specifically for Students in Korea Science Academy of KAISTFor installation, simply open command prompt and type:pip install hashbrownNOTE: you need tkinter for plotting and animation. It should be installed as default, but if it isn't, more infohereif something goes wrong, try the manual installation.For manual Installation, download the Latest ZIP releasehereand follow theManual Installation GuideDocumentationslistedhere+ demo & tutorial source codeshereIf you run into problems, maybe theDeveloper Troubleshooting Guidemight help (simple bug fixes are frequently updated here). If this doesn't work, contact one of the developers (shown in the github repository).Find the github repositoryhere(for previous versions with patch notes)For KSA Students, Best of luck on your exams. And say hi to YDK for me please.
Package: hash-calc
DescriptionCalculates MD5 and SHA256 hashes for a given fileInstallationpip install hash_calcUsageFrom command line:python -m hash_calc [-h] --path PATHOptionShortTypeDefaultDescription--path-pString-Path of the file to be hashedProgrammatically:fromhash_calc.HashCalcimportHashCalc# 1.) Hash a filepathToFile="/path/to/file/test.txthashCalc=HashCalc(pathToFile)print(hashCalc.md5)print(hashCalc.sha256)# 2.) Hash bytesh=HashCalc.fromBytes(b"\x01\x02\x03")print(h.sha256)print(h.md5)Examplepython -m hash_calc -p test.txtCreates the follwing result:##############################################################################################

Hash Calc by 5f0
Calculates MD5 and SHA256 hashes for a given file

Current working directory: /path/to/hash_calc
        Investigated file: test.txt

                 MD5 Hash: 265e08df10ed62d756e5e0bb6fadd69c
              SHA256 Hash: 1675aa3766017a42980e686132eff094ba789bc3dc44de3e53f2fb05a7a513ff

                 Datetime: 01/01/1970 10:20:30

##############################################################################################

Execution Time: 0.003022 secLicenseMIT
Package: hashcat-beta
NoteThis project is not in any way officially endorsed by the hashcat team.This project is my attempt to make installing and using hashcat easier. Specifically, it solves the following:No need to browse to hashcat and downloadNo need to download all the separate processors (see their github)The tools are automatically in your path, no need to cd into hashcat directoryhashcat doesn’t officially support running it from a separate directory. this library has it’s own fix built in to allow this.Easy to update or fully removeInstall$pipinstallhashcat-betaRunningRun it as if you were running hashcat normally. It exposes multiple utilities as well.$hashcat-h$pp64-h$cap2hccapx-h$kwp-hCLI MenuFor a cli menu to hashcat, seehttps://pypi.org/project/hashcrack/
Package: hashcercle
HashchainIntroductionhashchainis a Python package developed to join the ease of use of Python with the security of blockchain to certify that your important records haven't been tampered with.The core module creates a hash chain, attesting that no record can be tempered with, once saved. The blockchain module save a proof of your hashchain permanentely in the most secured way. Then, it's impossible to alter the haschain without causing a discrepancy with the blockchain.No need for third party certification anymore. No more single point of failure nor certification costs.DisclaimerThe package is still 'work in progress' Do not use it before the official beta release. All the features are still subject to changes without any advertisement and can broke previously running scriptsInstallationThis python package is available on PyPi package manager. I recommend installing it in avirtual environment.Open a terminal and run the following command :pip install hashchainImport the package in you script withimport hashchainThis package is tested against Python 3.5.7 and 3.7.1 versionsHow to start using haschain?The documentation lives onReadTheDocsI wrote an article on Medium to show a simple example of this package utilization:https://medium.com/@svandegar/certify-data-on-blockchain-with-python-and-no-prior-blockchain-experience-f09b7e3deb30ContributeI would be happy to hear from you if you have any comments, suggestions or requests to share with me.Changelog1.0.0Beta release
Package: hashchain
HashchainIntroductionhashchainis a Python package developed to join the ease of use of Python with the security of blockchain to certify that your important records haven't been tampered with.The core module creates a hash chain, attesting that no record can be tempered with, once saved. The blockchain module save a proof of your hashchain permanentely in the most secured way. Then, it's impossible to alter the haschain without causing a discrepancy with the blockchain.No need for third party certification anymore. No more single point of failure nor certification costs.DisclaimerThe package is still 'work in progress' Do not use it before the official beta release. All the features are still subject to changes without any advertisement and can broke previously running scriptsInstallationThis python package is available on PyPi package manager. I recommend installing it in avirtual environment.Open a terminal and run the following command :pip install hashchainImport the package in you script withimport hashchainThis package is tested against Python 3.5.7 and 3.7.1 versionsHow to start using haschain?The documentation lives onReadTheDocsContributeI would be happy to hear from you if you have any comments, suggestions or requests to share with me.Changelog1.0.0Beta release
Package: hashchecker
HashcheckerWhat is Hashchecker?Hashchecker is a command-line tool to calculatechecksum,verify the
integrity, and find duplicate files.Why Hashchecker?Based on pure Python:Hashchecker is based on the pythonhashliblibrary, and is thus extremely efficient.Built to be CLI:Hashchecker does not require a sophisticated GUI to get the job done.
Why summon a fancy application, when you can simply open up the terminal and summon Hashchecker in a split of a second? :wink:State-of-the-art duplicate file detector:Hashchecker uses a BST (Binary Search Tree) under the hood to quickly go
through directories with a huge number of files. Duplicates are confirmed via
comparing their cryptographic hashes.InstallationYou can install Hashchecker usingpip:$ pip3 install --upgrade hashcheckerAdditionally, you may consider using the--useroption.RequirementsClick: Command line parsing.Colorama: Coloring text wherever necessary.Tabulate: Displaying results in tabular format.Get involvedHave ideas to make Hashchecker better? Fork us!
Package: hash-chunker
Python Hash ChunkerGenerator that yields hash chunks for distributed data processing.TLDR# pip install hash-chunker
from hash_chunker import HashChunker

chunks = list(HashChunker().get_chunks(chunk_size=1000, all_items_count=2000))
assert chunks == [("", "8000000000"), ("8000000000", "ffffffffff")]

# or
hash_chunker = HashChunker(chunk_hash_length=3)
chunks = list(hash_chunker.get_chunks(500, 1500))
assert chunks == [('', '555'), ('555', 'aaa'), ('aaa', 'fff')]

# or
chunks = list(HashChunker().get_fixed_chunks(2))
assert chunks == [("", "8000000000"), ("8000000000", "ffffffffff")]

# use chunks as tasks for multiprocessing
query_part = "hash > :from_hash AND hash <= :to_hash"
params = {"from_hash": chunk[0], "to_hash": chunk[1]}DescriptionImagine a situation when you need to process huge amount data rows in parallel.
Each data row has a hash field and the task is to use it for chunking.Possible reasons for using hash field and not int id field:No auto increment id field.Field id has many blank lines (1,2,3, 100500, 100501, 1000000).Chunking by id will break data that must be in one chunk to different chunks
(in user behavioral analytics id can be autoincrement for all users actions and
user_session hash is linked to concrete user, so if we chunk by id one user session may
not be in one chunk).InstallationRecommend way to install Hash Chunker is pip.pip install hash-chunkerUsageImport Hash Chunker.from hash_chunker import HashChunkerCreate class instance.hash_chunker = HashChunker()

# or use chunk_hash_length key word arguments to limit generated hashes length
hash_chunker = HashChunker(chunk_hash_length=3)Get chunks by providing chunk_size and all_items_count.chunks = list(hash_chunker.get_chunks(chunk_size=500, all_items_count=1500))

# or skip positional arguments names
chunks = list(hash_chunker.get_chunks(500, 1500))

# or use yielded chunks in loop
for chunk in hash_chunker.get_chunks(500, 1500):
    print(chunk)SupportYou may report bugs, ask for help, and discuss various other issues
on thebug tracker.