Saravanan666/pypi-org huggingface dataset:
Package: abatools
Android Boot Animation ToolsSimple command line utility for working with Android Boot AnimationsThis utility is made to simplify the process of creating Android-ready bootanimation.zip filesTo install:Clone this git repository, and from the top-level directory (where setup.py is):pip3 install .Alternatively, you can get the package from PyPi using:pip3 install abatoolsOnce installed, the abatools utility should be available from the command line.  Example:abatools -a bootanimation.zipHelp is available from the command line with the -h or --help option, but basic usage is as follows:-a [filename.zip]     zip all files/folders in current directory totarget [filename.zip]
-g [[gif file] [filename] [[gif file] [filename] ...]]
creates a boot animation from a target .gif and saves it to [filename.zip]Questions or comments can be directed tothreadreaper@gmail.com.  Pull requests are welcome if you discover any issues.Copyright [2020] [Michael Podrybau]

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 
implied.  See the License for the specific language governing 
permissions and limitations under the License.
Package: abattlemetrics
abattlemetricsAn asyncio wrapper for the battlemetrics API.InstallationTo install the latest release from PyPI (requires Python 3.8 or above):pipinstallabattlemetricsTo install the development version from GitHub (requires Git):pipinstallgit+https://github.com/thegamecracks/abattlemetricsNoticeI am currently not maintaining this project as this wrapper has
been sufficient for my needs. Many endpoints have not been implemented,
but I will still accept PRs following thecontributing guide.LicenseThis project uses theMITlicense.
Package: abaxai-speech-client
Project descriptionThis is the speech client python package built by Abax.AIIt allows use to use speech to text services in both manners: offline and onlineOnline streaming will take audio stream in realtime, and return the transcripts on the flyOffline transcribing will read your audio file, transcribe and return the transcripts in different formats.ExamplesStream your audio file with python3import io
from abaxai_sdk import streaming

accessToken = 'YOUR_ACCESS_TOKEN'


def get_wav_data(wavfile):
    for block in iter(lambda: wavfile.read(1280), b""):
        yield generate_block(block)

def generate_block(block):
    return block

def abaxai_streaming(stream_file):
    """Streams transcription of the given audio file."""

    client = streaming.SpeechClient()

    config = streaming.RecognitionConfig(
        encoding=streaming.AudioEncoding.LINEAR16,
        sample_rate_hertz=16000,
        language_code="en-US",
        model="basic_english",
    )

    streaming_config = streaming.StreamingRecognitionConfig(config, accessToken)

    # In practice, stream should be a generator yielding chunks of audio data.
    with io.open(stream_file, 'rb') as audiostream:
        data = get_wav_data(audiostream)
        requests = (
            streaming.StreamingRecognizeRequest(audio_content=chunk) for chunk in data
        )

        responses = client.streaming_recognize(
                        config=streaming_config,
                        requests=requests,
                )
        
        print("\n\nFinal transcripts: \n")
        for response in responses:
            print(response)


audio_file = "your_audio_file.wav"

print("Streaming the audio file")
abaxai_streaming(audio_file)Transcribe your audio file with python3from abaxai_sdk import transcribing

accessToken = 'YOUR_ACCESS_TOKEN'

def abaxai_transcribe(audio_filepath):
    """Streams transcription of the given audio file."""

    client = transcribing.SpeechClient()

    config = transcribing.RecognitionConfig(
        encoding=transcribing.AudioEncoding.LINEAR16,
        sample_rate_hertz=16000,
        language_code="en-US",
        model="wenet-english",
    )
    
    transcribing_config = transcribing.TranscribeConfig(config, accessToken)

    client.recognize(config=transcribing_config,
                        audiofilepath=audio_filepath,)
    
    # speechid = "<your_speech_id>"
    # client.get_transcription(speechid, accessToken)

    print("Done.")


audio_file = "your_audio_file.wav"

print("Transcribe the audio file")
abaxai_transcribe(audio_file)ResourcesHomepage:https://abax.ai/
Package: abbr-cli
abbr-cliA command-line tool to look up abbreviations for terms (and the reverse). The abbreviations (or the terms in reverse
lookup) are extracted fromabbreviations.com.$abbrconfiguration(5/5)cfg(4/5)config(-/5)conf(-/5)cnf

$abbr--reversealloc(3/5)Allocation(-/5)AllocateTable of contentInstallationExploring the argumentsA little better than abbreviations.comInstallationPython version 3.6 or greater is required.Install viapipcommand:$pipinstallabbr-cliExploring the arguments$abbrconfiguration(5/5)cfg(4/5)config(-/5)conf(-/5)cnf

$abbrconfiguration--with-category(5/5)cfg~Miscellaneous,Computing(4/5)config~Governmental(-/5)conf~Computing(-/5)cnf~Computing

$abbrconfiguration--only-words
cfg
config
conf
cnf

$abbrconfiguration--min-stars4(5/5)cfg(4/5)config

$abbrconfiguration--limit1(5/5)cfgA little better than abbreviations.comNo duplicates.Abbreviations with a single charater are removed.A single abbreviation (or term in case of--reveriseflag) with multiple cateogries (and sometimes subcategories)
are merged in a single line. Subcategories are removed to avoid clutter. The rating will be the average rating.# instead of getting$abbrcommand--with-category(5/5)cmd~Governmental/NASA(4/5)cmd~Governmental/Military(4/5)cmd~Computing/DOSCommands(5/5)cmd~Computing(-/5)cmd~Miscellaneous/Aircraft
...# you will get$abbrcommand--with-category(4/5)cmd~Governmental,Computing,Miscellaneous
...Abbreviations are normalized to lowercase, while terms are normatlized to title case.# instead of getting$abbraddress(4/5)ADD(3/5)addr
...# you will get$abbraddress(4/5)add(3/5)addr
...
Package: abbrev
🐜abbrev: Expand abbreviations 🐜Expand aSequenceorMappingof string abbreviations.Handy when the user has a choice of commands with long names.Example 1: Use a list of choicesimport abbrev

a = ['one', 'two', 'three']

assert abbrev(a, 'one') == 'one'
assert abbrev(a, 'o') == 'one'
assert abbrev(a, 'tw') == 'two'

abbrev(a, 'four')  # Raises a KeyError: no such key
abbrev(a, 't')  # Raises a KeyError: ambiguous key ('two' or 'three'?)Example 2: Use a dictionary of choicesimport abbrev

d = {'one': 100, 'two': 200, 'three': 300}

assert abbrev(d, 'one') == 100
assert abbrev(d, 'o') == 100
assert abbrev(d, 'tw') == 200Example 3: Make an abbreviator to re-useimport abbrev

d = {'one': 100, 'two': 200, 'three': 300}

abbreviator = abbrev(d)

assert abbreviator('one') == my_abbrevs('o') == 100
assert abbreviator('tw') == 200Example 4: Get all matches, whenmulti=Trueimport abbrev

a = ['one', 'two, 'three'}

multi = abbrev(a, multi=True)  # Make an abbreviator

assert multi('t') == abbrev(d, 't', multi=True) == ('two', three')
assert multi('o') == abbrev(d, 'o', multi=True) == ('one', )

multi('four')  # Still raises a key errorExample 5: Get only the first result, whenunique=Falseimport abbrev

d = {'one': 100, 'two': 200, 'three': 300}

assert abbrev(d, 't', unique=False) == (200, 300)API Documentation
Package: abbreviate
Abbreviate==========This filter attempts to automatically and intelligently abbreviate strings.This library contains a dictionary of known abbreviations. Some words havemultiple abbreviations, e.g. Thursday could be abbreviated as any of Thurs,Thur, Thr, Th, or T depending on context. With no other information, each wordhas a "preferred abbreviation" (Thr), however options can push things one wayor another. For words without known abbreviations, a series of heuristics areapplied to shorten them as needed.The basic `abbreviate` method will only apply preferred abbreviations andno heuristics. For more advanced applications, the library can be given atarget length and effort, and will attempt to generate the best stringpossible. Length can be supplied either as a simple character count, or with acustom length function. The latter is useful in many graphics applicationswithout monospaced fonts or constant kerning. By default, abbreviate will notshorten any exisiting abbreviations (e.g. Thur -> Th), assuming that anyexplicit abbreviation was passed as such for a reason.Issues, updates, pull requests, etc should be directed`to github <https://github.com/ppannuto/python-abbreviate`__.State-----This tool was written to scratch an immediate itch and is thus quiteincomplete, but with extensibility and somewhat grander ideas in mind.Architectural thoughts, radical changes to methodology, or just greaterabbreviations are all welcome.Installation------------The easiest method is to simply use pip:::(sudo) pip install abbreviateUsage-----TODO
Package: abbreviate-names
abbreviate-namesUniquely abbreviate a set of names in a language-appropriate way.
The original intent was to shorten a collection of Latin species names
such that they would fit more nicely into tables and graphs, but other
applications abound!This packages provides botha programmatic API,names.abbreviate.abbreviate()anda command line tool,abbreviate-names.If installed with English or Latin options it also includes dependencies
on natural language modules which enable it to break names up at
syllable boundaries, which produces more readable results:pipinstall'abbreviate-names[Latin,English]'Example outputSpeciesAbbreviation using Latin syllables.. or by characterAgathidium laevigatumAgat.lae.A.l.Agathidium nigrinumAgat.nigrinumA.nigrin.Agathidium nigripenneAgat.nigripen.A.nigrip.Agathidium seminulumAgat.se.A.s.Agonum ericetiAgo.e.A.e.Agonum fuliginosumAgo.fu.A.f.Agonum gracileAgo.gra.A.g.Lithocharis sp.Lit.sp.L.sp.Xylocleptes bispinusXy.bis.X.b.Xylodromus concinnusXy.con.X.c.Xylodromus depressusXy.de.X.d.Xylostiba monilicornisXy.mo.X.m.Zeugophora subspinosaZeu.sub.Z.s.Observe:Several different words above are all shortened to “Xy.” or “X.” —
it's the whole abbreviation that's unique, not the individual words.The already-abbreviated “sp.” is untouched.OnlineGitHub:https://github.com/ConradHughes/abbreviate-namesPyPI:https://pypi.org/project/abbreviate-names/ChangelogAll notable changes to this project will be documented in this file.The format is based onKeep a Changelog,
and this project adheres toSemantic Versioning.[Unreleased][0.1.2] - 2020-08-31AddedInitial version by@ConradHughes, includinglibrary function,command line script,support for Latin and English.
Package: abbreviations-py
abbreviations_pyabbreviations_pyis a Python package that provides a convenient way to abbreviate and normalize text. It offers functionality to clean text by replacing common abbreviations with their full forms, removing punctuations and hashtags.InstallationYou can installabbreviations_pyusingpip:pipinstallabbreviations-pyUsagefromabbreviations_py.textes.abbreviatorimportfix,update_abbreviations# Fix abbreviated textinput_text="I'll txt you when you're back, ttyl! #BonVoyage"result=fix(input_text)print(result)# Output: I will text you when you are back talk to you later# Update abbreviation mappingsnew_mappings={"ttyl":"talk to you later","txt":"text",# Add more mappings here}update_abbreviations(new_mappings)ContributingContributions are welcome! If you encounter any issues or have suggestions for improvements, please feel free to open an issue or submit a pull request.LicenseThis project is licensed under theMIT License.Created byPrajwal Khairnar
Package: abbrfix
abbrfixLibrary for expanding and collapsing abbreviations commonly used in online communication.InstallationTo install the library, use pip:pipinstallabbrfixAlternatively, install the latest directly from the GitHub repository:pipinstallgit+https://github.com/dsymbol/abbrfix.gitUsageExpandfromabbrfiximportexpand_all,expand_one# Example text with abbreviationstext="I'll brb, gtg for lunch, ttyl!"# Expand all abbreviations in the textexpanded_text=expand_all(text)print(expanded_text)# Output: "I'll be right back, got to go for lunch, talk to you later!"# Expand a specific abbreviationexpanded_text=expand_one(text,"brb")print(expanded_text)# Output: "I'll be right back, gtg for lunch, ttyl!"Collapsefromabbrfiximportcollapse_all,collapse_one# Example text with expanded abbreviationstext="I'll be right back, got to go for lunch, talk to you later!"# Collapse all abbreviations in the textcollapsed_text=collapse_all(text)print(collapsed_text)# Output: "I'll brb, gtg for lunch, ttyl!"# Collapse a specific full formcollapsed_text=collapse_one(text,"talk to you later")print(collapsed_text)# Output: "I'll be right back, got to go for lunch, ttyl!"Update and Remove Abbreviationsfromabbrfiximportupdate_abbreviations,remove_abbreviations# Update the abbreviations dictionary with more abbreviationsnew_abbreviations={"lol":"laughing out loud","omg":"oh my god"}update_abbreviations(new_abbreviations)# Remove abbreviations from the dictionaryabbreviations_to_remove=["brb","gtg"]remove_abbreviations(abbreviations_to_remove)
Package: abb-robot-client
abb_robot_clientPython package providing clients for ABB robots using RWS (Robot Web Services) and Externally Guided Motion (EGM).
This package currently supports IRC5 controllers running RobotWare 6.xx. It does not support RobotWare 7+.This package is typically used withabb-motion-program-exec,
which provides a higher level interface to generate motion programs.abb-motion-program-execincludes the ability
to initialize EGM operations, using this package to communicate with EGM.abb_robot_clientincludes three modules:rws,rws_aio, andegm.rwsprovides a synhronous client for Robot
Web Services (RWS) using HTTP REST, and the ability to create subscriptions using websockets.rws_aioprovides
identical functionality torws, but uses asyncio, with each method beingasync.egmprovides an Externally
Guided Motion (EGM) client.Documentation can be found at:https://abb_robot_client.readthedocs.orgInstallationabb-robot-clientis avaliable on PyPi. Use the[aio]option to include support for asyncio:pip install abb-robot-client[aio]ExamplesSee theexamples/directory for examples using the modules.LicenseApache 2.0AcknowledgmentThis work was supported in part by Subaward No. ARM-TEC-21-02-F19 from the Advanced Robotics for Manufacturing ("ARM") Institute under Agreement Number W911NF-17-3-0004 sponsored by the Office of the Secretary of Defense. ARM Project Management was provided by Christopher Adams. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of either ARM or the Office of the Secretary of Defense of the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes, notwithstanding any copyright notation herein.This work was supported in part by the New York State Empire State Development Division of Science, Technology and Innovation (NYSTAR) under contract C160142.
Package: abby
abbyA/B testing for HumanAbby is a A/B testing library package for human. Abby aims to make A/B testing as easy as ABC and accessible to anyone.Installation$pipinstallabbyQuick StartPlease note that your variant name column should be named asvariant_name. Otherwise, the method will raise an error and ask you to adjust the column name accordingly.A/B testing for continuous metricfromabby.datasetsimportload_datasetfromabbyimportcompare_ttestdata=load_dataset('click_impression')compare_ttest(data=data,variants=['control','experiment'],numerator='click')A/B testing for ratio metricfromabby.datasetsimportload_datasetfromabbyimportcompare_deltadata=load_dataset("click_impression")compare_delta(data=data,variants=["control","experiment"],numerator="click",denominator="impression",)A/B testing for ratio metric using bootstrapfromabby.datasetsimportload_datasetfromabbyimportcompare_bootstrap_deltadata=load_dataset("click_impression")compare_bootstrap_delta(data=data,variants=["control","experiment"],numerator="click",denominator="impression",n_bootstrap=10_000,)A/B testing for multiple metricsfromabby.datasetsimportload_datasetfromabbyimportcompare_multiple,Ratiodata=load_dataset("click_impression")result=compare_multiple(data=data,variants=["control","experiment"],metrics=["click",Ratio("click","impression")],)A/B/N testing for multiple metricsfromabby.datasetsimportload_datasetfromabbyimportcompare_multiple,Ratiodata=load_dataset("click_impression_3_variants")result=compare_multiple(data=data,variants=["control","experiment_A","experiment_B"],metrics=["click",Ratio("click","impression")],)
Package: abcai
Principles Of AI LabProject on GithubTo Run the moduefromabcaiimportrunrun()List of AI Lab ExercisesBreadth-First Search (BFS)Depth-First Search (DFS)A* AlgorithmCrypto-Arithmetic ProblemsPredicate LogicSemantic NetworkNaive BayesGame PlayingMin-MaxAlpha-Beta PruningNLP: TokenizationSpell CheckingExpert System
Package: abc-analysis
Performs and visualizes an ABC analysis with automated limit detection.This package is a Python implementation of the R packageABCanalysis.The package is based on “Computed ABC Analysis for rational Selection of most informative Variables in multivariate Data”, PLoS One. Ultsch. A., Lotsch J. (2015)doi:10.1371/journal.pone.0129767.Basic Usagefromabc_analysisimportabc_analysis,abc_plot# Perform an ABC analysis on a numeric vector (without plotting)dctAnalysis=abc_analysis([1,15,25,17,2,3,5,6,2,3,22])# Perform an ABC analysis with plottingdctAnalysis=abc_analysis([1,15,25,17,2,3,5,6,2,3,22],True)# Plot saved results of an ABC analysisabc_plot(dctAnalysis)
Package: abc-annMacroF1withCost
ARTIFICIAL BEE COLONY ALGORITHM WITH LOGISTIC REGRESSION (ABC-LR)ABC-LR is a binary classification method in which the ABC algorithm is used instead of the Gradient Descent algorithm to train the weights in the Logistic Regression classification model. The purpose of the ABC algorithm in the ABC-LR method is to minimize the value of the cost function. The ABC algorithm is a very popular metaheuristic method that can search for solutions both locally and globally in the solution space. In addition, it has been shown in the study that the ABC-LR classification method achieves superior classification success compared to the LR classification method.Although the ABC-LR classification method can handle complex and high-dimensional data, its runtime can be high. Therefore, CPU and GPU parallelized versions of the ABC-LR classification method are presented here, and significant improvements in runtime can be achieved.ABC-LR is written in Python3 and continuously tested with Python 3.7 and 3.10.InstallationInstall ABC-LR via PyPI:pip install abcLROr alternatively, clone the environment:git clone https://github.com/kagandedeturk/ABC-LR.gitCPU Version UsageimportnumpyasnpparallelType=npfromabcLRimportABC_LR_Modelfromsklearn.datasetsimportload_breast_cancerX,y=load_breast_cancer(return_X_y=True)y=y.reshape(-1,1)lb=-16ub=16evaluationNumber=80000# FVS = trainData.shape[1]limit=50P=60MR=0.3L2=0model=ABC_LR_Model(lb=lb,ub=ub,evaluationNumber=evaluationNumber,limit=limit,P=P,MR=MR,L2=L2,parallelType=parallelType)#start_time = dt.datetime.now()model.fit(X,y)#print(f"Run time: {dt.datetime.now()-start_time}")print(f"Result:{model.score(X,y)}")GPU Version UsageimportcupyascpparallelType=cpfromabcLRimportABC_LR_Modelfromsklearn.datasetsimportload_breast_cancerX,y=load_breast_cancer(return_X_y=True)X=parallelType.array(X)y=parallelType.array(y.reshape(-1,1))lb=-16ub=16evaluationNumber=80000# FVS = trainData.shape[1]limit=50P=60MR=0.3L2=0model=ABC_LR_Model(lb=lb,ub=ub,evaluationNumber=evaluationNumber,limit=limit,P=P,MR=MR,L2=L2,parallelType=parallelType)#start_time = dt.datetime.now()model.fit(X,y)#print(f"Run time: {dt.datetime.now()-start_time}")print(f"Result:{model.score(X,y)}")LicenseThis program is free software: you can redistribute it and/or modify
it under the terms of the 3-clause BSD license (please see the LICENSE file).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.You should have received a copy of the 3-clause BSD license
along with this program (see LICENSE file).
If not, seehere.Copyright (c) 2022, Bilge Kagan Dedeturk (kagandedeturk@gmail.com)
Package: abcattrs
abcattrsAbstract class attributes for ABCs.importabcfromabcattrsimportabstractattrs,Abstract@abstractattrsclassA(abc.ABC):foo:Abstract[int]# Abstract subclasses can add more required attributes@abstractattrsclassB(A,abc.ABC):bar:Abstract[str]classC(B):# C must define both of these attributes to not raise an errorfoo=1bar="str"TheAbstractqualifier can be combined with other PEP 593 annotations.fromtypingimportAnnotatedimportabcfromabcattrsimportabstractattrs,Abstract@abstractattrsclassA(abc.ABC):# Combine with other annotationsbar:Annotated[str,Abstract,"other info"]
Package: abc-classification
ABC classification libraryABC classification is an inventory categorisation technique. A typical example of ABC classification is the segmentation of products (entity) based on sales (value). The best-selling products that contribute to up to 70% of the total sales belong to cluster A. The products making up the next 20% of sales are in cluster B, whereas the products representing the last 10% of sales, belong to class C. Hence, the pattern is named after the three clusters (ABC).ExampleInstallationpip install abc-classificationImportfrom abc_classification.abc_classifier import ABCClassifierLet's say we have dataframeproducttotal soldfade cream27000powders24000shadows18000mascara16000lipstick6000concealer5000sculptors4000You can create ABCClasifier object, pass your dataframe
to it and call classify method.abc_clf = ABCClassifier(df)
abc_df = abc_clf.classify('product', 'total sold')This way you'll get new dataframe with classified products.producttotal soldclassfade cream27000Apowders24000Ashadows18000Amascara16000Blipstick6000Bconcealer5000Csculptors4000CYou also can use brief_abc method to get aggregated informationabc_clf.brief_abc(abc_df)classtotal soldA69000B16000C15000You can plot pareto chart.from abc_classification.abc_visualiser import pareto_chart


pareto_chart(abc_df, 'total_sold', 'product')
Package: abc-classroom
Why ABC ClassroomMany educators teaching data science are using GitHub Classroom as a way to teach students
both git and GitHub skills and also potentially collaboration skills that align
with open source software development best practices. However there are many steps
associated with using GitHub classroom to manage a class.Abc-Classroom contains a suite of command-line utilities that make it easier to
manage a class of students using GitHub classroom by:Making it easier to create template assignment directories that are directly connected to your classroom organizationMaking it easier to update those assignments and(still under development) making it easier to clone all student assignments for grading.We are currently using nbgrader in our workflow and are thus building this tool
out to support the use of nbgrader as well.Install abc-classroomabc-classroom is under significant development currently. We are occasionally
pushing releases to pypi and conda-forge.For now, install from PyPi using:$ pip install abc-classroomOr conda-forge:$ conda install -c conda-forge abc-classroomOr to get the most current updates, clone this repo and run:$ pip install -e .to install the development version.Use Abc-classroomBecause this is a command line set of tools, you will need to ensure that abc-classroom
is installed in the active environment that you are using for your class.Active Maintainers / DevelopersHow to ContributeWe welcome contributions to abc-classroom as we are developing it and beyond! Please be sure to check out ourcontributing guidelinesfor more information about submitting pull requests or changes to abc-classroom.License & CitationBSD-3