Saravanan666/pypi-org huggingface dataset:
Package: wordsworth
Wordsworth CWGeorge Allison K1IG described a methodology "head copy" morse
code. High-speed operators who copy in their heads at a speed greater
than 40 WPM have learned to process CW by hearing entire words.The Wordsworth method is a variant of the Farnsworth method, which
sends individual letters at high speed. Wordsworth's method sends
words at your target speed with long spacing between each word. You
reduce the number of spaces as your proficiency increases.For more information, you can read George's article, published on theQST magazineon his method.You can also watch George's presentation atQSO TodayInstallationYou can install this program from the source located on mygithubaccount. If you already have your Python environment set up, the
easiest way is by usingpipwith the following command:$ pip install wordsworthIf you set the environment variableCALL_SIGNwith your call sign,
wordworth will use it in the sequences of words generated. Set that
variable permanently to your.bashrcor.zshrcfile depending on
the type of shell you are using.$ export CALL_SIGN=W6BSDUsageIf you are running this program on macOS, it will automatically copy
the sequence of words into your clipboard buffer. You simply need to
paste it intofldigi.Example:$ wordworth --repeat 4 --spaces 10 --dataset abbrevsIt is possible to run this program as anfldigimacro. Every time
you click on the macro. The CW exercise will automatically appear in
your fldigi transmit window.Example of fldigi macro:<TX>
<EXEC>/usr/local/bin/wordworth --repeat 4 --spaces 5</EXEC>
<RX>DatasetsThe datasets are:"abbrevs"      abbreviations used in CW"alpha"        alphabet [A-Z]"combination"  most Frequent letters combinations"connectives"  connective words"names"        common first names"numbers"      numbers from 0 - 99"pro_codes"    ham radio pro-codes , , , , etc"punctuation"  all the punctuation used in Morse"words"        most common wordsTo use a specific dataset use the argument--datasetfollowed by the
names of the dataset you want to learn.Example$ wordworth --nb-words 50 --repeat 3 --dataset alpha numbers abbrevsIn this example the program will chose 50 words from the 3 datasets
alpha, numbers, abbrevs. Each word will be repeated 3 times.
Package: word-text-counter
word_text_counterCalculate word counts in a text file!Installation$pipinstallword_text_counterUsagefromword_text_counterimportcount_wordsfile_path="data/test.txt"#a path to your text filecounts=count_words(file_path)ContributingInterested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.Licenseword_text_counterwas created by Sumbono. It is licensed under the terms of the MIT license.Creditsword_text_counterwas created withcookiecutterand thepy-pkgs-cookiecuttertemplate.
Package: wordtm
An NLP package for topic modeling on the Holy Scripture and other text
from low-code to pro-codeInstallation$pipinstallwordtmUsagewordtmcan be used to perform some NLP pre-processing tasks, text
exploration, including Chinese one, text visualization (word cloud), and
topic modeling (BERTopic, LDA and NMF) as follows:fromwordtmimportmeta,util,ta,tm,viz,pivot,quotversion SubmoduleProvides some version information.importwordtmprint(wordtm.__version__)meta SubmoduleProvides extracting source code ofwordtmmodule and adding timing and code-showing features
to all functions of the module.print(meta.get_module_info())print(meta.get_module_info(detailed=True))meta.addin_all()quot SubmoduleProvides functions to extract the quotation source Scripture in OT based on the presribed NT Scripture.cdf=util.load_word('cuv.csv')crom8=util.extract2(cdf,'Rom 8')quot.show_quot(crom8,lang='chi')pivot SubmoduleProvides a pivot table of the prescribed text.cdf=util.load_word('cuv.csv')pivot.stat(cdf,chi=True)ta SubmoduleProvides text analytics functions, including extracting the summarization of the prescribed text.cdf=util.load_word('cuv.csv')crom8=util.extract2(cdf,'Rom 8')ta.summary(rom8,code=True)tm SubmoduleProvides text modeling functions, including LDA, NMF and BERTopics modeling.lda=tm.lda_process("cuv.csv",chi=True,eval=True,timing=True)nmf=tm.nmf_process("cuv.csv",chi=True,eval=True,code=1)btm=tm.btm_process("cuv.csv",chi=True,cat='nt',eval=True)util SubmoduleProvides loading text and text preprocessing functions.df=util.load_word()cdf=util.load_word('cuv.csv')df.head()cdf.head()rom8=util.extract2(df,'Rom 8')crom8=util.extract2(cdf,'Rom 8')viz SubmoduleWordcloud plotting from the prescribed text.cdf=util.load_word('cuv.csv')viz.chi_wordcloud(cdf)ContributingInterested in contributing? Check out the contributing guidelines.
Please note that this project is released with a Code of Conduct. By
contributing to this project, you agree to abide by its terms.Licensewordtmwas created by Johnny Cheng. It is licensed under the terms
of the MIT license.Creditswordtmwas created under the guidance of Jehovah, the Lord.
Package: wordtodigits
WordToDigits PackageAuthor: Abhishek RawatThis package is used to convert the numbers present in word form in an input passage to the traditional numeric (digits) form. The word representation of numbers could be anywhere in the passage. It works from zero to nine hundred and ninety nine million nine  hundred and ninety nine thousand and nine hundred and ninety nine. It also takes care of the decimal part, if present.An example on how to use the package is shown below:-import wordtodigitstext1 = 'A car accelerates for five point two one seconds for a distance of one hundred and ten meters.'print(wordtodigits.convert(text1))#A car accelerates for 5.21 seconds for a distance of 110 meters.text2 = 'three thousand and fifty three point five is the final score'print(wordtodigits.convert(text2))#3053.5 is the final scoreIf you find any bugs, or have any suggestions for improvement, contact me atabhishek18.official@gmail.com
Package: word-tools
word_toolsUtilities for performing actions on words, or collections of words. This is a slowly
expanding library of functions, conversions, and lookups added to as I see fit.
Mostly intended for fun, or convenience. Not sure what it will grow into, but it's
a nice laid back project.Installation & UseRecommended to install into a virtual environment of your desired flavor. I currently
recommendvirtualenvwrapper, but am using the stockvenvmodule in the example
below for simplicity. Save the user on configuring a dependency if they don't have to# Clone the repogitclonehttps://github.com/ncdulo/word_tools.gitcdword_tools# Create a new virtual environment, and enable itpython-mvenv.envsource.env/bin/activate# Update Pip & friends. Optional, but recommendedpipinstall--upgradepip# Install dependencies and create executablepipinstall.# If you receive errors about "No module named 'word_tools'", try thispipinstall--editable.# With venv active, the path will already be in path# Otherwise, the path to executables will be# .env/bin/wt.{urban,merriam,wikipedia}wt.urbanWORD[LIMIT=0]wt.merriamhacker2wt.wikipediapython1# Deactivate the virtual environment when finisheddeactivate
Package: word-to-pronunciation
word-to-pronunciationPython library to help with looking up words that contain punctuation and hyphens.Installationpipinstallword-to-pronunciationUsage>>>fromcollectionsimportOrderedDict>>>frompronunciation_dictionaryimportPronunciations,Word>>>fromword_to_pronunciationimportOptions,get_cached_lookup,get_pronunciations_from_word>>>deflookup(word:Word)->Pronunciations:...print(f"Trying to lookup: '{word}' ...")...ifword=="test":...result=OrderedDict((...(("T","E0","S","T"),0.7),...(("T","E1","S","T"),0.3),...))...print("Found pronunciations!")...returnresult...print("Found no pronunciations!")...returnOrderedDict()>>>options=Options(...trim_symbols="\".",...split_on_hyphen=True,...try_without_trimming=True,...try_without_splitting=True,...default_weight=1.0...)>>>cache={}>>>lookup_method=get_cached_lookup(lookup,cache)>>>word="\"test-test\".">>>result=get_pronunciations_from_word(word,lookup_method,options)Tryingtolookup:'"test-test".'...Foundnopronunciations!Tryingtolookup:'test-test'...Foundnopronunciations!Tryingtolookup:'test'...Foundpronunciations!>>>forpronunciation,weightinresult.items():...print(f"{word}=> /{'|'.join(pronunciation)}/{weight}")"test-test".=>/"|T|E0|S|T|-|T|E0|S|T|"|./0.48999999999999994"test-test".=>/"|T|E0|S|T|-|T|E1|S|T|"|./0.21"test-test".=>/"|T|E1|S|T|-|T|E0|S|T|"|./0.21"test-test".=>/"|T|E1|S|T|-|T|E1|S|T|"|./0.09>>>print(cache){'"test-test".':OrderedDict(),'test-test':OrderedDict(),'test':OrderedDict([(('T','E0','S','T'),0.7),(('T','E1','S','T'),0.3)])}
Package: word-tree
Word TreeEfficient lookup of next possible character(s) given a starting word fragment.This is intended for use in word game strategies (Boggle, Scrabble, Anagram).Usage:>>> import word_tree
>>> with open('words.lst') as wl:
...   wt = word_tree.make_word_tree([w.strip() for w in wl])
...
>>> word_tree.next_char(wt, 'do')
['c', 'e', 'd', 'g', 'i', 'm', 'l', 'o', 'n', 'p', 's', 'r', 'u', 't', 'w', 'v', 'z', None]
Package: wordtrie
WordTrieExampleCreate a new trie:from wordtrie import WordTrie
trie = WordTrie()Words and their values are added to the trie with theadd()method:trie.add("She", 1)
trie.add("sea", 2)Exact matches in the trie are found with thematch()method:print(trie.match("She"))
# 1
print(trie.match("sells"))
# None
print(trie.match("She sells"))
# NoneAll matches in a stream of words can be found with thesearch()method:print(trie.search("She sells sea shells by the sea shore."))
# [1, 2, 2]Phrases can be added too and will be split into a list of words:trie.add("sea shells", 3)
# same as trie.add(["sea", "shells"], 3)Matching is greedy and will match the maximal length phrase:print(trie.match("sea shells"))
# 3
print(trie.search("She sells sea shells by the sea shore."))
# [1, 3, 2]In addition to the values, you can return the trie nodes that were
matched withreturn_nodes=True:print(trie.search("She sells sea shells by the sea shore.", return_nodes=True))
# [(['She'], 1), (['sea', 'shells'], 3), (['sea'], 2)]The trie can be written to a JSON file with:trie.to_json("sea.json")
# {
#   "She": {
#     "#": 1
#   },
#   "sea": {
#     "#": 2,
#     "shells": {
#       "#": 3
#     }
#   }
# }Or restored from a JSON file with:trie.from_json("sea.json")
print(trie.match("sea"))
# 2The reserved key#is used to store the value in the JSON structure. You can still add a word that starts with#to the trie, and it will be protected with an additional prepended#:trie.add("#She", 4)
trie.to_json("sea.json")
# {
#    "##She": {
# ...
print(trie.match("#She"))
# 4When a node does not yet exist in the trie, the value specified in theadd()method is used as the initial value. If the node already exists, then an aggregator function can be called to modify the value based on the old and new values. The default aggregator is to replace the old value with the new value. However, a custom aggregator can be defined as a function with signatureaggregator(old, new)and passed to theadd()call:def sum_aggregator(old, new):
    return old + new
trie.add("She", 100, aggregator=sum_aggregator)
print(trie.search("She sells sea shells by the sea shore."))
# [101, 3, 2]TestingRun the example above as a basic regression test with:# grep "^    " README.md | sed 's/    //' | python
Package: wordtriepy
WordTriePyThis is a small Python package that implements a trie filled with words from several languages (English - en, German - de , French - fr, Spanish - es, Portuguese - pt) implemented as nested dictionaries.Installpip install wordtriepyUsageTo find all characters that could follow the partial word "chair" in the English language, use theget_next_chars()method:fromwordtriepyimportWordTriet=WordTrie()print(t.get_next_chars("chair"))# outputs: ['_end', 'b', 'e', '-', 'i', 'l', 'm', 'p', 's', 'w']The_endtoken tells us that "chair" itself is a valid word and there are 4 other characters ('b', 'e', '-', 'i', 'l', 'm', 'p', 's', 'w') that could follow the word "chair" in the English language that could form new valid words.To get a list of words that can be formed by the partial word "salz" in the German language, use theget_next_words()method:fromwordtriepyimportWordTriet=WordTrie(language="de")print(t.get_next_words("salz",topn=5))# outputs: ['salz', 'salze', 'salzt', 'salzen', 'salzes']This returns the top 5 words after a breadth-first-search in the German word trie.
Package: word-unscrambler
Word UnscramblerThis Python module,word_unscrambler, is a versatile and user-friendly tool designed to find all word combinations from a set of letters. This module provides a reliable way to find these combinations, handling various scenarios, including input validation and error handling.Table of ContentsInstallationUsageDocumentationFeaturesContributingLicenseInstallationTo use theword_unscramblermodule, you can simply install it using pip from the command line. Make sure to installword_unscramblerto the right python version (3.x), otherwise it will not work. There is no need to install other modules, as the required modules will be install when you install it using pip.pipinstallword_unscramblerUsageYou can use theunscramblefunction provided by theword_unscramblemodule to discover which words can be made from any combination of characters. Here's a basic example:importword_unscrambleraswresult=w.unscramble('enam')print(result)# Output: ['name', 'amen', 'mean', 'mane']DocumentationTheword_unscramblermodule includes detailed documentation in the form of docstrings. These docstrings provide information about the module's purpose, function arguments, return values, and usage examples. You can access this documentation using Python's built-inhelp()function or by viewing the docstrings directly in your code editor.importword_unscrambleraswhelp(w.unscramble)FeaturesInput Validation: The module ensures that input is all in the same case.Error Handling: If an invalid input is provided, the function will not break and will still return None.Interactive Mode: When run as a script, the module enters an interactive mode, allowing users to unscramble any word of their choice.Documentation: The module includes docstrings that provide information about its purpose, usage, and examples, making it easy for users to understand and use.ContributingContributions to this project are welcome! If you'd like to improve the module, fix a bug, or add a new feature, please follow these steps:Fork the repository.Create a new branch for your feature or bug fix.Make your changes and test them thoroughly.Commit your changes and push them to your fork.Open a pull request against the original repository.LicenseThis project is licensed under the MIT License - see theLICENSEfile for details.
Package: wordweaver
WordWeaverCreating RESTful morphology web services for Iroquoian languages:warning: :construction: This repo is currentlyunder construction:construction: :warning:Please visit thedocsfor more information!Table of ContentsWordWeaverTable of ContentsBackgroundInstallUsageMaintainersContributingLicenseBackgroundWordWeaver is a Python library for turning an FST made withFomainto a RESTful API.
It combines with the WordWeaver GUI to create an interactive web application for the data as well.
WordWeaver was initially built forKanyen’kéhabut with all Iroquoian languages in mind.
It will likely work for similar polysynthetic languages and Foma FSTs that model inflectional verbal morphology,
but non-Iroquoian languages will likely have to modify the source in order to work.InstallThe best thing to do is install with pippip install wordweaver.Otherwise, clone the repo and pip install it locally.$gitclonehttps://github.com/nrc-cnrc/wordweaver.git
$cdwordweaver
$pipinstall-e.UsagePlease visit the docs for more information.Maintainers@roedoejet.@anna-ka.ContributingFeel free to dive in!Open an issueor submit PRs.This repo follows theContributor CovenantCode of Conduct.LicenseMIT
Package: wordwise
WordWise| |     / /___  _________/ / |     / (_)_______ 
| | /| / / __ \/ ___/ __  /| | /| / / / ___/ _ \
| |/ |/ / /_/ / /  / /_/ / | |/ |/ / (__  )  __/
|__/|__/\____/_/   \__,_/  |__/|__/_/____/\___/WordWise is a minimal keyword extraction library that uses quality contextual embeddings generated by Sentence-BERT to extract keywords from blocks of text.InstallationWordWise is available on PyPI.pip install wordwiseTo clone this repository, rungit clone https://github.com/jaketae/wordwise.gitQuickstartAt the core of WordWise is theExtractorclass, which can be configured to generate keywords from some given text. TheExtractorcan be initialized and used out-of-the-box with minimal configuration as follows.fromwordwiseimportExtractorextractor=Extractor()keywords=extractor.generate(text)For advanced users, theExtractorclass, as well as the.generate()method, can be configured in a more granular fashion to induce specific behaviors. For instance, the underlying spaCy backend can be specified.extractor=Extractor(spacy_model="en_core_web_lg")By default, theExtractorwill only generate the top 5 most relevant keywords. This behavior can be changed as follows.# generate 10 keywordskeywords=extractor.generate(text,top_k=10)DemoBelow is an example text adapted from theWikipedia article on supervised learning.text="""Supervised learning is the machine learning task oflearning a function that maps an input to an output basedon example input-output pairs.[1] It infers a functionfrom labeled training data consisting of a set oftraining examples.[2] In supervised learning, eachexample is a pair consisting of an input object(typically a vector) and a desired output value (alsocalled the supervisory signal). A supervised learningalgorithm analyzes the training data and produces aninferred function, which can be used for mapping newexamples. An optimal scenario will allow for the algorithmto correctly determine the class labels for unseeninstances. This requires the learning algorithm togeneralize from the training data to unseen situationsin a 'reasonable' way (see inductive bias)."""The extractor selects the three most relevant keywords from the block of text.>>>fromwordwiseimportExtractor>>>extractor=Extractor()>>>keywords=extractor.generate(text,3)>>>print(keywords)['algorithm','learning','supervised learning']How it WorksUsing spaCy, theExtractorobject generates n-gram candidate noun phrases from the provided block of text. By default, it only considers uni-grams or bi-grams, since only rarely are keywords go beyond three words. Then, using a BERT model, it generates contextual embeddings for both the provided text and the n-gram keywords. Using cosine similarity as a distance function, it extracts thetop_kcandidate keywords that are most similar to the embedding of the inputted text.For a more detailed write-up, please refer to my blog posthere.CreditWordWise was largely inspired byKeyBERT, a library that similarly uses sentence embeddings for keyword extraction. WordWise also relies on NLP libraries, such asspaCyandHuggingFace transformers, without which its development would not have been possible.LicenseReleased under the MIT License.
Package: wordybin
WordyBinWhat the world needs is yet another word-based encoding system for
binary data. In this case, a 16-bit encoding system, with one of 512
5-letter words standing in for the first 9 bits, and one of 128
3-letter words standing in for the next 7 bits.Why?Because the words are fixed length, the encoded string length has a
stepwise linear relationship to the source data. This can be
advantageous for humans who are trying to eyeball something, and
stands in contrast to encodings like BIP39.Each word can have its accent on the first syllable, to make
reading out loud easier.Each word can be pronounced uniquely, such that there is reduced
ambiguity when restricted to the built-in list of English words. A
lot of effort has been put into making 'hearing' these words read
be as unambigous as possible.Caveats:It is not possible to ensure strong phonetic difference across
this many words, but we've attempted to provide as much
phonetic difference as possible.Future versions could redo the wordlist to improve this at the
cost of backward-incompatibility; suggestions backed up byjellyfishare welcomed since this concept is still in its
early stages.The words are built on prior art; mostly, this is theBIP39 English wordlist,
filtered to 5 and 3-letter words, then filtered again for various
words that don't fit the above restrictions or that I felt like
dropping for no particular reason. Since this leaves less than 512
words, I added some 4-letter words from the BIPS wordlist that have
can have an adjectival version ending iny, plus a couple of
others. There were not enough 3-letter words, and many of them
diverged from the given criteria, so I added quite a few of those to
get to 128.Why would I actually use this?There are a lot of cases where we want to represent something
determinstically and uniquely. One of the common cases is to provide a
unique, unopinionated, compressed reference to it. This is sometimes
called ahash.Hashes have really nice properties, but they also have some not-nice
properties, and perhaps the main one is that they are just a jumble of
characters. For instance, here is a shortened, 8-character hash of a
commit from the BIP39 repo:ce1862ac. That hash contains 32 bits of
entropy, which is sufficient in most cases to uniquely identify a
moment in time in the life of your repository.What itisn'tis memorable, or easy to communicate. But 32 bits is
very easy to communicate using WordyBin, because you can use 4 words
to represent those three bytes.ce1862ac(in hexadecimal) isSprayCowHandyFeein WordyBin. I bet you can remember that for long
enough to switch browser tabs!Installation/Usagepip install wordybinencode:cat <file> | python -m wordybinpython -m wordybin --input-file <file>decode:echo "DirtyGumCycleGetCrossFoxCrazyFog" | python -m wordybin -d > output.bpython -m wordybin -d --input-file input.b --output-file output.b
Package: worek
IntroductionA logical database backup tool.Create full binary backups of a PostgreSQL databaseRestore a text or binary backup of a PostgreSQL databaseCan restore a database over the top of an existing database (clears all data
first) meaning you don’t need a super user to restore a database.UsageCreate a backup with the contents going to a file$ worek backup -d database_name -f ./backup.binCreate a backup with the contents going to STDOUT$ worek backup -d database_name \
    | openssl enc -aes-256-cbc -pass file:password.txt -md sha256 -d -out backup.bak.encRestore a backup from STDIN. Note you have to use the-Fproperty to specify
the type of backup you are handing. This is not required when using-fand
specifying the file path.$ openssl enc -aes-256-cbc -pass file:password.txt -md sha256 -d -in backup.bak.enc  \
    |  worek restore -h localhost -d database_name -F cSupports standardPG environment variables$ PGPORT=5432 worek backup -d database_name -f ./backup.binWorek makes use of Postgres client utilities internally to create/restore backups.
If multiple versions of the utilities are present, by default Worek will attempt to match the
version of the utilities to the database server version. You may also specify a particular version
of the client utilities to use via the–versionor-voption. This feature requirespg_wrapperto be installed on the system.$ worek backup -d database_name -f ./backup.bin -v 11Changelog0.1.1 released 2021-02-01Allow PG client executable version to be specified (abff603)0.1.0 released 2019-04-03Cleanup Piping Mechanism (da86b5b)Setup CI for PG9.6 and PG10 (002640b)Cleanup API and add tests (e5371da)Update Readme (0697703)Add init for packages (78e6ec2)Setup a Postgres Backup Tool (be27b46)