Saravanan666/pypi-org huggingface dataset:
Package: autoencoder
IntroductionThis repository contains the tools necessary to flexibly build an autoencoder in pytorch. In the future some more investigative tools may be added. The main goal of this toolkit is to enable quick and flexible experimentation with convolutional autoencoders of a variety of architectures.The implementation is such that the architecture of the autoencoder can be altered by passing different arguments. Tunable aspects are:number of layersnumber of residual blocks at each layer of the autoencoderfunctions used for downsampling and upsampling convolutions and convolutions in the residual blocksnumber of channels at each layer of the autoencoderactivation function performed after each convolutionsymmetry (or lack thereof) of the encoder-decoder architectureetcSome usefull wrappers and custom classes, such as ResidualBlock or GeneralConvolution, can be found in model_parts.py.
The file models.py is where the actual autoencoder classes are. It contains one base class as well as two extension for 2d and 3d data.InstallationThe latest stable version can be obtained usingpip install autoencoder.Otherwise, you can download and use the files directly in your projects.UsageThe ConvAE base class expects parameters that specify the overall architecture (see documentation) and one function for the downsampling layer, upsampling layer and residual block.
Conv2dAE and Conv3dAE on the other hand provide an interface to easily create the aforementioned functions from parameters and create the autoencoder from there.
Package: autoevalimg
# autoevalimgThis tool is designed to save time evaluating images in a reference image library with the ARCore image evaluator. This will automate the process onto a folder of images and will output the results to a text file. More information can be found [here](https://developers.google.com/ar/develop/java/augmented-images/arcoreimg).## InstallationInstall the package with pip` pip install autoevalimg `Open a python interpreter in the terminal` python `Import the package` import autoevalimg `Reference the folder of images to evaluate` mng =AutoEvalImgManager("path/to/images/folder")`Run the evaluator` mng.get_results() `Open results.txt for all of the scores of the images
Package: autoexec
Automatically turn python functions into executable scriptsWhenever you have written some code and want to run it on a cluster, the first step is to turn it into an executable. This typically leads to a quick stop over at the docs forargparse, together with a lot of duplicated effort in reproducing the function signature. This can be error-prone and annoying, especially if one edits the function.This script automates this process, using information about types provided either through function annotation, default values in keyword arguments, or type information innumpydoc-style docstrings. Like any shell script, this limits the functions to arguments that can be passed in the terminal, (str, int, float,…).ExampleLet’s say you’ve written the following function inexample.py, which provides all kinds of different type informationdefadd(a:int,b,c=5,d=7.,e=None):"""Some cool addition.

    It's super complicated.
    You know, adding and stuff.

    Parameters
    ----------
    b : int
        This is the second complicated parameter
        super complicated
    e : int, optional
    """ifeisNone:e=0returna+b+c+d+eNow all you have to do to turn this into an executable is add the following code at the bottomif__name__=='__main__':importautoexecres=autoexec.execute_function(add)print(res)and runchmod +x example.py. Now if you run./example.py--helpyou get the following output❯❯❯ ./example.py --help
usage: example.py [-h] --a A --b B [--c C] [--d D] [--e E]

Some cool addition.

It's super complicated.
You know, adding and stuff.

optional arguments:
  -h, --help  show this help message and exit
  --a A       int
  --b B       This is the second complicated parameter
              super complicated
  --c C       int, default: 5
  --d D       float, default: 7.0
  --e E       int, default: NoneAnd you’re ready to call the script from the command line❯❯❯ ./example.py --a 1 --b 2 --c 3
13.0There is type-checking by argparse❯❯❯ ./example.py --a 1 --b stringy
usage: example.py [-h] --a A --b B [--c C] [--d D] [--e E]
example.py: error: argument --b: invalid int value: 'stringy'and it complains about missing arguments❯❯❯ ./example.py --a 1
usage: example.py [-h] --a A --b B [--c C] [--d D] [--e E]
example.py: error: the following arguments are required: --bThere is also support for multiple functions viaautoexec.execute_functions.
Package: autoextract-poet
autoextract-poetcontains common item definitions.
Such items can be extracted automatically usingZyte AutoExtract API(you can usescrapy-poetandscrapy-autoextractfor this).License is BSD 3-clause.Documentation:https://autoextract-poet.readthedocs.io/Source code:https://github.com/scrapinghub/autoextract-poetIssue tracker:https://github.com/scrapinghub/autoextract-poet/issues
Package: auto-faq
AutoFAQAutoFAQ is a sophisticated FAQ dataset mining framework designed as an interactive CLI tool for rapid and efficient data collection. With AutoFAQ, you can compile comprehensive FAQ datasets in just minutes!Process OverviewAutoFAQ's streamlined process follows these steps to generate a complete dataset:Expand Keywords: Provide a few initial keywords, and AutoFAQ will automatically expand the list to generate a comprehensive query list.Web Search: AutoFAQ performs searches using your choice of designated search engines to create a list of relevant webpages.Information Extraction: Once all webpages are downloaded, AutoFAQ extracts QA pairs using the available extractor engines.Data Cleaning: AutoFAQ's cleaning modules allow you to refine the dataset using semantic entailment of QA pairs, titles, or pages.Rendering: Finally, you can render the dataset into your desired format with ease. Success!Getting StartedInstall theautofaqCLI tool using:pipinstallauto-faqUsage:autofaq[OPTIONS]COMMAND[ARGS]...

Options:
--helpShowthismessageandexit.

Commands:
cleanRefinesthedataset
embedComputesvectorembeddingsofthedataset
extractCollectswebpagesandextractsQApairs
initInitiatesanewminingproject
keywordsGeneratesanexpandedlistofkeywords
renderTransformsthedatasetintohuman-readableformats
searchCompilessearchresultsforkeywords
Package: auto-fastapi
auto-fastapiA pythonic functional way to construct FastAPI applications be declaring endpoints in separation of their functional definition, enabeling to separate, replicate, and reuse functions in different APIs at the same time, and also run multiple of them.Installationpip install autl-fastapiexamplefromfastapiimportFastAPIfromauto_fastapiimportMethod,AutoFastAPI,Builder,Server,Configdefstartup()->None:print("startup")deflogin(username:str,password:str)->dict[str,str|dict[str,str]]:return{"response":"success","request":dict(username=username,password=password)}app=FastAPI()auto=AutoFastAPI(app)auto.push((startup,Builder.event("startup")))auto.push((login,Builder.endpoint("/login",[Method.GET])))server=Server(Config(app,host="127.0.0.1",port=5555))server.run()to stop the serverserver.exit()to run againserver.run()
Package: autofeather-dash-ag-grid
Dash AG GridDash AG Grid is a Dash component wrapper for the AG Grid JavaScript package, enabling you to display AG Grid components natively in your Dash app.The underlying AG Grid JavaScript package is a third-party software component developed byAG Grid Ltd. Many features are available for free in the AG GridCommunity version. Some features require a paid subscription to the AG Grid Enterprise version (more info available here). Both the community and enterprise versions are included in this component, but the enterprise features require you to provide a valid AG Grid license key. The demos which use Enterprise features are clearly marked.v2.0.0 ReleaseIf you have tried v2.0.0 alpha releases, release candidates, or our v1.x enterprise package, please see ourMigration Guide(previously hostedhere).Getting Startedpip install dash-ag-gridDocumentationPlease see theDash Documentation.ContributingDash AG Grid welcomes community contributions!If you have identified a bug or have an idea for a new feature, it's best to start with a GitHub issue. First look at existing issues athttps://github.com/plotly/dash-ag-grid/issuesto make sure this is not a duplicate. Then create a new issue. Bug reports should be accompanied by a small example app that someone else can copy and run to reproduce the problem.The docs are under development as well. There are many examples in the official AG Grid docs that have not been included here yet. Please open an issue or do pull requests for edits or to add examples. Or post your question, comments or demo apps on theDash Community Forum.Developing in this repoMake sure you have Dash installed with dev and testing extras:pip install dash[dev,testing]Build the component (from the root of this repo):npm i
npm run buildNow install the component in development mode:$ pip install -e .In development mode, Python uses the files in this directory when you import the package. So you can write a testing app in another folder, and whenever you change some code and rebuild the component here it will update in your testing app.Create a production buildCreate source and wheel distributions in the generateddist/folder, after emptying out any previous builds:rm -rf dist build
python setup.py sdist bdist_wheelSeePyPAfor more information.
Then usetwineto upload these to PyPI:twine upload dist/*We also publish the JavaScript build to NPM, sounpkghas the bundles if users setserve_locally=False. First make a test of the NPM package, verify that its contents are reasonable:npm packThen publish:npm publish
Package: auto-feat-selection
DependenciesMake sure you have install the sklearnsklearn version == 1.0.1Feature Selection using Bregman divergence & Itakura SaitoWhat is Bregman Divergence & Itakura SaitoIn statistics, divergence is a function that finds and measures differences using
the distance between two probability distributions.
Bregman divergence is one of many divergences. It can be calculated with the squared Euclidean distance:###Steps to apply auto_feat_selection#importfrom auto_feat_select_rupakbob import auto_feat_selection#grid_feat_search(dataframe,'taget_column_name', max_divergence(default = 0,max = 10)accepted divergence with the target column)index 0 = BregmanDivergenceSelector, index 1 = ItakuraSaitoSelector
cols_BregmanDivergenceSelector = auto_feat_selection.grid_feat_search(df,'target',5)[0]
cols_ItakuraSaitoSelector = auto_feat_selection.grid_feat_search(df,'target',5)[1]Evaluate if the selected features improves the model###Currently supports Logistic Regression base model with goal to evaluate feature performance#evaluate_grid_feat_search(dataframe,'taget_column_name')auto_feat_selection.evaluate_grid_feat_search(df,cols_BregmanDivergenceSelector,target ='target')
auto_feat_selection.evaluate_grid_feat_search(df,cols_ItakuraSaitoSelector,target ='target')
Package: auto-feature-engineering
IntroThis is a package for automatically feature engineering.Suitable for tabular numerical data and the classification modelling.Installpipinstallauto-feature-engineeringUsagefromautofeimportautofex_train,x_test,y_train,y_test,feature_cols=load_data()afe=autofe.AutoFE('primary_key',feature_cols)afe.fit(x_train,y_train)x_train=afe.transform(x_train)x_test=afe.transform(x_test)finaldf=afe.generator(x_train,x_test,y_train,y_test)ExamplesTo see how the demo for running the package, see thedemo.Contributing@XinlinWangLicenseMITÂ© Xinlin Wang
Package: autofig
autofigHigh-Level Interface to Create Figures/Animations with MatplotlibThis module provides a high-level interface to create figures/animations (currently only in matplotlib).  It was designed to be used withinPHOEBEbut written in a way that it can be used as a standalone package.Read thelatest documentation on readthedocsorbrowse the current documentation.DependenciesmatplotlibnumpyastropySee thetravis reportfor details on the full testing-matrix.Installationautofigis available viapip:pip install autofigAlternatively, to install from source, use the standard python setup.py commands.To install globally:python setup.py build
sudo python setup.py installOr to install locally:python setup.py build
python setup.py install --userBasic Usageautofigis imported as a python module:import autofigRead thelatest documentation on readthedocsorbrowse the current documentation.ContributorsKyle ConroyContributions are welcome!  Feel free to file an issue or fork and create a pull-request.
Package: auto-file
# AUTO_FILE
this is a moudle that can create all required file and folder for creating library
# EXTRA
it can also have extra function like creating a python or html file
# INSTALLATION
you can install it via running this command in your terminalpip install auto_file# HOW-TO-USEimport auto_fileauto-file.mklib("tutorial")# PYTHON-AND-HTML-FILEimport auto_fileauto-file.pyfile("test.py")auto_file.html("test.html")# CUSTOM-EXTENSION FILE
you can create custom extension file easily for exampleimport auto_fileauto_file.custom("test.css")auto_file.custom("test.js")# NOTE
MORE Documentation will be aviable soon
Package: auto-file-flow
project-templateAn event system for file operations to execute commands for file events.Installationpip install auto-file-flowexamplefromfile_flow.eventsimportFileSystemEventfromfile_flow.ioimportTextIO,IOContainerfromfile_flow.pipelineimportPipelinefromfile_flow.operationimportOperatorfromfile_flow.watcherimportWatcherfromfile_flow.handlerimportPatternHandlerhandler=PatternHandler(patterns={"*.txt":IOContainer(TextIO(),TextIO())},pipelines={FileSystemEvent:[Pipeline([Operator(lambdadata:print(data))])]})watcher=Watcher(root="demo",handler=handler)watcher.run()
Package: auto-files-identifier
Automatic File IdentifierA simple program written to identify a file using the extension or using file signatures.Failing to do either, implies that the file might be a text file with no signature or extension.It is not intended to be a final solution that finds everything about a file.i.e. the purpose is to provide mimes for popular identifiable formats.It is to be integrated with another project called Advanced Pattern Finder.Installingpipinstallauto-files-identifierOr, clone the repository athttps://github.com/supratikchatterjee16/afi, andpipinstall.UsingThere is a signature downloader, which is tailored to download and store information found onFile Signatures.This creates a python file named signatures.py, which needs to be in the same folder as the program.The program imports this and makes use of it.importafilist_mime_tuples=afi.identify(path_to_resource)#can be a folder or file path# The above gives you a list of tuples which contain the mimes for each identified file# It identifies using both extension and signaturesHowever, there is a second way of making use of it as well.afi/path/to/file/or/folderAuthorSupratik ChatterjeeIssuesThere are some(quite a lot I suspect) popular file extensions and signatures missing.I believe there are way more than 650 extensions.Should one find something missing, kindly do let me know.Downloadingmkdiraficd./afi
gitinit
gitremoteaddoriginhttps://github.com/supratikchatterjee16/afi.git
gitpulloriginmaster
pipinstall.
Package: autofill
AutofillAutofill is a Python library for dealing with auto-completion of words.InstallationUse the package managerpipto install autofill.pipinstallautofillUsagefromautofillimportautofill# register list of 'words' into autofill systemwords=["mobile","mouse","moneypot","monitor","mousepad"]autofill.register_words(words)# prefix searchautofill.search('mou')# returns ['mouse', 'mousepad']# Find top k words from previous search matchesautofill.find_top_k_matches(k=4)# returns [('mouse', 1), ('mousepad', 1), ('mobile', 0), ('moneypot', 0)]ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Fork it (https://github.com/yourname/yourproject/fork)Create your feature branch (git checkout -b feature/fooBar)Commit your changes (git commit -am 'Add some fooBar')Push to the branch (git push origin feature/fooBar)Create a new Pull RequestLicenseMIT=======
History0.1.0 (2021-08-01)First release on PyPI.
Package: autoFillMaskWithCandi
autoFillMaskWithCandidatesUnder construction! Not ready for use yet! Currently experimenting and planning!Developed by Elatot (c) 2024PyTorch and TransformersThis Python package provides advanced text processing functionalities utilizing PyTorch and Hugging Face's Transformers library. It includes capabilities for setting up a tokenizer and model from Hugging Face, automatically masking differing words in sentences, calculating the probability of candidate words, and more.FeaturesInitialize tokenizer and model from Hugging Face's Transformer library.Automatically mask differing words in a set of input sentences.Calculate the probability of a candidate word.Show masked inputs and provide scores for candidate words.Replace masked words with the most probable candidates.InstallationTo use this package, you need to have Python installed on your system, along with PyTorch and the Transformers library. If you haven't installed these dependencies yet, you can do so using pip:pipinstalltorchtransformers
pipinstallautoFillMaskWithCandi==0.0.3Examples of UsagefromautoFillMaskWithCandiimportsetTokenModel,show_mask_fill,mask_fill_replaced# Set the model for tokenizermodel_name="Your-Model-Name-Here"setTokenModel(model_name)# Example sentencesinput_sentences=["maling hindi maligo","maling hindi malego"]# Show masked input and scores for candidate wordsshow_mask_fill(input_sentences)# Print the sentence with masked words replacedprint(mask_fill_replaced(input_sentences))Replace "Your-Model-Name-Here" with the model name you want to use from Hugging Face.
Package: autoFillMaskWithCandy
autoFillMaskWithCandyUnder construction! Not ready for use yet! Currently experimenting and planning!Developed by Elatot (c) 2024PyTorch and TransformersThis Python package provides advanced text processing functionalities utilizing PyTorch and Hugging Face's Transformers library. It includes capabilities for setting up a tokenizer and model from Hugging Face, automatically masking differing words in sentences, calculating the probability of candidate words, and more.FeaturesInitialize tokenizer and model from Hugging Face's Transformer library.Automatically mask differing words in a set of input sentences.Calculate the probability of a candidate word.Show masked inputs and provide scores for candidate words.Replace masked words with the most probable candidates.LimitationsMay not be compatible with model using  inference key like roBerta LLM. This algorithm uses [CLS] and [SEP] which are compatible with Bert and electra.InstallationTo use this package, you need to have Python installed on your system, along with PyTorch and the Transformers library. If you haven't installed these dependencies yet, you can do so using pip:pipinstalltorchtransformers
pipinstallautoFillMaskWithCandy==0.0.4Examples of UsagefromautoFillMaskWithCandyimportsetTokenModel,show_mask_fill,mask_fill_replaced# Set the model for tokenizermodel_name="Your-Model-Name-Here"setTokenModel(model_name)# Example sentencesinput_sentences=["Pasensya heto lng ako, bobo sa pagaral","Pasensya hito lng ako, bobo sa pagaral","Pasensya heto lng ako, bubo sa pagaral","Pasensya hito lng ako, bubo sa pagaral"]# Show masked input and scores for candidate wordsshow_mask_fill(input_sentences)# Print the sentence with masked words replacedprint(mask_fill_replaced(input_sentences))Replace "Your-Model-Name-Here" with the model name you want to use from Hugging Face.
Package: auto-find-date-pdf
Simple use Date and text parsing from pdf rtf and images (with use of call back function)This is a simple package provided by Marvsai healthcare LTD. It can find any format regular dates in a str
as python Datetime objects.Easy to use methoddef find_dates(file_contents: str):Find any dates in a large python string usually taken from a file or pdf

  Args:
      file_contents (str): The string in which to find any format of dates


  Returns:
      List[datetime.datetime]: A list of datetime objects the latest can be found using max()Optimised replacement of multiple strings in a stringreplace_multiple_strings(input_string, replacements_dict)Replace multiple strings in the input string using a dictionary of replacement pairs.

Args:
    input_string (str): The string in which to replace the substrings.
    replacements_dict (dict): A dictionary of replacement pairs, where the keys are the
        substrings to be replaced and the values are the replacement strings.

Returns:
    str: The input string with all instances of the substrings replaced with their
        corresponding replacement strings.
"""Easy to use extraction of text from PDF or RTF files:def extract_rtf_pdf(name: str, get_ai_text:Callable=None)->str:Find text from pdf and rtf

  Args:
      name (str): The string in which to find any format of dates
      get_ai_text: call back function that can call google vision api or AWS or Azure equivalents for text extraction
      Called for images and image PDFs.

  Returns:
      List[datetime.datetime]: A list of datetime objects the latest can be found using max()
  """
Package: autoflows
AutoflowsAutomated Flyte Workflows using LLMsTheautoflowspackage allows you to run Flyte workflows that are powered by
LLMs. These workflows use LLMs to determine which task to run in a suite of
user-defined, trusted Flyte tasks.InstallationpipinstallautoflowsUsageFirst we can define some Flyte tasks as usual:# example.pyfromflytekitimporttaskfromautoflowsimportautoflowimage_spec=ImageSpec("auto-workflows",registry="ghcr.io/unionai-oss",requirements="requirements.txt",python_version="3.10",)@task(container_image=image_spec)defadd_numbers(x:float,y:float)->FlyteFile:...@task(container_image=image_spec)defconcat_strings(strings:List[str])->FlyteFile:...@task(container_image=image_spec)deftrain_classifier(data:List[dict],target_column:str)->FlyteFile:...Then, in the same file, we define aFlyteRemoteobject that we want to use to
run our autoflow.# example.pyremote=FlyteRemote(config=Config(platform=PlatformConfig(endpoint="<my_endpoitn>",client_id="<my_client_id>",),),default_project="flytesnacks",default_domain="development",)Finally, we define theautoflowfunction:# example.py@autoflow(tasks=[add_numbers,concat_strings,train_classifier],model="gpt-3.5-turbo-1106",remote=remote,openai_secret_group="<OPENAI_API_SECRET_GROUP>",openai_secret_key="<OPENAI_API_SECRET_KEY>",client_secret_group="<CLIENT_SECRET_GROUP>",client_secret_key="<CLIENT_SECRET_KEY>",container_image=image_spec,)asyncdefmain(prompt:str,inputs:dict)->FlyteFile:"""You are a helpful bot that picks functions based on a prompt and a set of inputs.What tool should I use for completing the task '{prompt}' using the following inputs?{inputs}"""Running on Flyte or UnionThen, you can register the workflow along with all of the tasks:pyflyte--configconfig.yamlregisterexample.pyWhereconfig.yamlis the Flyte configuration file pointing to your Flyte or
Union cluster.Finally, you can run the workflow, and let theautoflowfunction decide which
task to run based on the prompt and inputs. For example, to add two numbers, you
would do:pyflyte--configconfig.yamlrunexample.pymain\--prompt"Add these two numbers"\--inputs'{"x": 1, "y": 2}'To concatenate two strings, you would do:pyflyterun\test_auto_workflow.pyauto_wf\--prompt"Combine these two strings together"\--inputs'{"strings": ["hello", " ", "world"]}'And to train a classifier based on data:pyflyterun\test_auto_workflow.pyauto_wf\--prompt"Train a classifier on this small dataset"\--inputs"{\"target_column\": \"y\", \"training_data\":$(catdata.json)}"Wheredata.jsoncontains json objects that looks something like:[
    {"x": 5, "y": 10},
    {"x": 3, "y": 5},
    {"x": 10, "y": 19},
]