Saravanan666/pypi-org huggingface dataset:
Package: auto-ner
auto_nerEnd to End application for Custom Named Entity Recognition.
Highlights:Powerd by GenAiFew shot LearningTraining and inference pipelinesAuto_annotatewill take unlabeled text data and create labellied text data that can further be used for custom Named Entity Recognition (NER) Model training.InstallationPypirun following command in terminalpipinstallauto-nerFrom sourceRun following command in terminalgit clone https://github.com/bokey007/auto_ner.gitcd auto_nerpython setup.py sdist bdist_wheelpip install ./dist/imp3-0.1.0.tar.gzUsageauto_ner.runAbove command will lauch the app on default port 8501.Open the browser and go tohttp://localhost:8501Select the image and then select the appropriate set of operations you want to perform on that perticular image.play with the parameters interatively untill you reach at optimal configuration.auto_ner.run--port8080Above command can be used to specify the port on which you want to run the app.Application WorkflowSystem ArchitectureDemoSolution is implemnted in following three stepsCreate the baseline
Spacy Model ([Transformer implementation on Hold])Meet the Expectations
Training Bert ([ToDo])Exeed the expectationsFew shot / Zero Shot NERBeyond mere NER : entyity linking ([ToDo])Development tools:setuptools (https://pypi.org/project/setuptools/): Used to create a python packagepipreqs (https://pypi.org/project/pipreqs/): Used to create requirements.txt filetwine (https://pypi.org/project/twine/): Used to upload the package to pypi.orgGithub Actions (): Used to automate the process of uploading the package to pypi.orgpytest (https://pypi.org/project/pytest/): Used to write unit testswheel (https://pypi.org/project/wheel/): Used to create a wheel file
Package: autonet
Hello, Network-Operation is aimed at providing some tools or modules for network automated operation.
If you are interested in it, find bugs or have any requirement, feel free to contact me viazc8131868@gmail.com.
You may also find more useful methods in some_methods folder.
For more details please check examples.docx for reference.import getpasspwd = getpass.getpass("pls input your password::")a = autonet.autonet(username="chengzheng",                                                                       
		password = pwd,    
		device_ios= "cisco_ios",
		url="/Users/zhengcheng/Desktop/result.txt",
		url_error_ip="/Users/zhengcheng/Desktop/error_ip.txt"
	  	)b = a.PING_IP(["1.1.1.1", "2.2.2.2)]b = a.PING_Subnet("1.1.1.0/24")b = a.get_version("30.31.190.94")b = a.get_serial_number("30.31.190.94")a.auto_show("1.1.1.1", ["show ntp status"])a.auto_config("2.2.2.2", ["hostname test", "interface g0/1", "switchport mode trunk"])a.auto_config_file("1.1.1.1", "commands.txt")a.close_logging()For now, autonet has been tested on cisco_ios, cisco_nxos, rg_os. It's no double other OS can use PING_IP or PING_Subnet which is independent on OS command. Autnonet will support more OS later.
Package: autonlp
🤗 AutoNLPAutoNLP: faster and easier training and deployments of SOTA NLP modelsInstallationYou can Install AutoNLP python package via PIP. Please note you will need python >= 3.7 for AutoNLP to work properly.pip install autonlpPlease make sure that you have git lfs installed. Check out the instructions here:https://github.com/git-lfs/git-lfs/wiki/InstallationQuick start - in the terminalPlease take a look atAutoNLP Documentationfor a list of supported tasks and languages.Note:
AutoNLP is currently in beta release. To participate in the beta, just go tohttps://huggingface.co/autonlpand apply 🤗First, create a project:autonlplogin--api-keyYOUR_HUGGING_FACE_API_TOKEN
autonlpcreate_project--namesentiment_detection--languageen--taskbinary_classification--max_models5Upload files and start the training. You need a training and a validation split. Only CSV files are supported at the moment.# Train splitautonlpupload--projectsentiment_detection--splittrain\--col_mappingreview:text,sentiment:target\--files~/datasets/train.csv# Validation splitautonlpupload--projectsentiment_detection--splitvalid\--col_mappingreview:text,sentiment:target\--files~/datasets/valid.csvOnce the files are uploaded, you can start training the model:autonlptrain--projectsentiment_detectionMonitor the progress of your project.# Project progressautonlpproject_info--namesentiment_detection# Model metricsautonlpmetrics--projectPROJECT_IDQuick start - Python APISetting up:fromautonlpimportAutoNLPclient=AutoNLP()client.login(token="YOUR_HUGGING_FACE_API_TOKEN")Creating a project and uploading files to it:project=client.create_project(name="sentiment_detection",task="binary_classification",language="en",max_models=5)project.upload(filepaths=["/path/to/train.csv"],split="train",col_mapping={"review":"text","sentiment":"target",})# also upload a validation with split="valid"Start the training of your models:project.train()To monitor the progress of your training:project.refresh()print(project)After the training of your models has succeeded, you can retrieve the metrics for each model and test them with the 🤗 Inference API:client.predict(project="sentiment_detection",model_id=42,input_text="i love autonlp")or use command line:autonlppredict--projectsentiment_detection--model_id42--sentence"i love autonlp"How much do I have to pay?It's difficult to provide an exact answer to this question, however, we have an estimator that might help you.
Just enter the number of samples and language and you will get an estimate. Please keep in mind that this is just an estimate and can easily over-estimate or under-estimate (we are actively working on this).autonlpestimate--num_train_samples10000--project_namesentiment_detection
Package: autonlpinsights
Auto NLP InsightsAutoNLPInsights  extracts the Named Entities,Sentiments,Summary,KeyPhrases,Topics
from the (Url/Plain Text/PDF Files ) and helps to visualize them (EDA) with one line of code.DASH APPInstallationpip install autonlpinsightsVisualizationfromautonlpinsightsimportnlpinsights# Any URL or Plain Textdata='https://www.cnbc.com/2021/08/06/doximity-social-network-for-doctors-full-of-antivax-disinformation.html'nlpinsight=nlpinsights(data)nlpinsight.cleanedtext# WORDCLOUDSnlpinsight.visualize_wordclouds()# NGRAMSnlpinsight.visualize_ngrams(ngram_value=2,top_n=5)# NAMED ENTITY TREE MAPnlpinsight.visualize_namedentities()# For Vizualizing Raw text with Named Entities  (Include spacy_fig = True)nlpinsight.visualize_namedentities(spacy_fig=True)# SENTIMENTS (Pie with sentiment labels )nlpinsight.visualize_sentiments()# SENTIMENT TABLE (Sentences sorted with sentiment score along with labels)nlpinsight.get_sentiment_df()# SUMMARY(Top 5 sentences using Abstarctive Summarization)nlpinsight.get_summary_table()# Gensim Topic Modellingnlpinsight.visualize_topics(num_topics=3)Meta Data######Returns dictionary with all (Named Entities,Sentiments,Summary,KeyPhrases,Topics)fromautonlpinsightsimportnlpinsightsurl='https://www.cnbc.com/2021/08/06/doximity-social-network-for-doctors-full-of-antivax-disinformation.html'nlpinsight=nlpinsights(url)# Returns dictionary with all (Named Entities,Sentiments,Summary,KeyPhrases,Topics)nlpinsight.get_full_nlpinsights()Note:
This is still in initial phase of Developement and will be adding more features soon
Package: autonml
CMU TA2 (Built using DARPA D3M ecosystem)Taking your machine learning capacity to the nth power.AutonML is an automated machine learning system developed by CMU Auton Lab
to power data scientists with efficient model discovery and advanced data analytics. It is designed to be the first step in exploratory data science. AutonML leverages powerful methods in machine learning to solve an enriched array of tasks on different data modalities.AutonML is Carnegie Mellon University's implementation of theData Driven Discovery program (D3M).Documentation is available here
Package: autonode-diagrams
Autonode DiagramsThe PythonDiagramsproject is an excellent resource for drawing technical diagrams using code, allowing diagrams to be version controlled easily and you to spend time writing content rather than fussing over formatting.However, one current limitation is that all nodes of the diagram must have both a label and an icon to be displayed. AlthoughDiagramscomes with a large number of relevant node types and corresponding icons pre-installed, and thecustom nodeallows you to extend this even further, sometimes you don't have a suitable icon for the node available, or you want to quickly generate a diagram and worry about populating the icons later.This package extends theDiagram's Custom Nodeand automatically generates an icon based on the text in the node's label if no icon is provided. It is designed to be used in conjunction with, not as a replacement to,Diagrams.Quick StartMost of this code is taken from theDiagram's Quick Start guideplusCustom nodes with remote icons guide. This is to show how Autonode Diagram'sIconclass integrates seamlessly with the rest of the regular Python Diagram's functionality, allowing the two to be used side-by-side.fromdiagramsimportDiagramfromdiagrams.programming.languageimportPythonfromdiagrams.customimportCustomfromautonode_diagramsimportIconfromurllib.requestimporturlretrievewithDiagram("Quick Start",show=False):# Get a remote PNG to prove that autonode_diagrams.Icon can also work just like normal diagrams.custom.Customemoji_url="https://openmoji.org/php/download_asset.php?type=emoji&emoji_hexcode=2728&emoji_variant=color"emoji_fp="./sparkle.png"urlretrieve(emoji_url,emoji_fp)# You can delete this file laterIcon("Just a label, no icon given",border=True)>>Python("Autonode Diagrams")>>Icon("Something beautiful",emoji_fp)PrerequisitesArial font.PythonDiagramsalong with their dependencies (specificallyGraphvizwill need to be installed).
Package: autonogame
autonogameBot for the browser game OGame.https://en.ogame.gameforge.com/This software is under development. It is capable of buildingresources,depositsandfacilities. New features will be implemented in the future.It is built on top of the Python modulepyogamewhich provides the API to communicate with the game. The GitHub repository ishere.InstallingYou can install this software as apippackage and run it from a terminal.pipinstallautonogame
autonogameIn alternative you can download and execute the pre-built app (Windows only) by visiting theReleasespage.ContributingIf you are a developer and you want to contribute to this project you can clone, install and test this software on your Windows or Unix machine.gitclone--recursivegit@github.com:tassoneroberto/autonogame.gitcdautonogameYou can install this Python module locally on Windows or Unix.Windowspy-mvenvvenv.\venv\Scripts\Activate.ps1py-mpipinstall-e.Unixpython-mvenvvenvsourcevenv/bin/activate
python-mpipinstall-e.RunYou can run the GUI by simply executing the following command:autonogameBuild appA Windows executable.exe(or MacOS application.app) can be built using thepyinstallersoftware (more infohere). The command can be execute usingMake:makebuild-appIf you are on a Windows OS and you don't haveMakealready installed you can get it fromCHOCOLATEY:chocoinstallmakeThe./appfolder will contain the portable executable.
Package: autonomi
Autonomi Cloud Python ClientThe Autonomi Cloud Python Client provides a convenient way to interact with the Autonomi Cloud API. We provide a unified client interface for various API services offered on theAutonomi Cloud Platform.InstallationThe Autonomi AI Python Client is available on PyPI. You can install it using pip:pipinstallautonomiInstall from source:gitclonehttps://github.com/autonomi-ai/autonomi-clientcdautonomi-client
pipinstall-e.AuthenticationThe Autonomi AI Python Client uses API keys to authenticate requests. You can create your own API keys, after you've signed up, in theAutonomi Cloud console.exportAUTONOMI_API_KEY='...'UsageThe python client needs to be configured with your personal API key before you can use it. You can set the API key in the environment variableAUTONOMI_API_KEYas described above or pass it to the client constructor.fromautonomi.clientimportAutonomiClient# Usage with variable `AUTONOMI_API_KEY` read from your environment.>>>cli=AutonomiClient()AutonomiClient[version=X.Y.Z]::[endpoint=https://api.autonomi.ai/v1,health=OK,auth=OK]# Usage with API key passed to constructorcli=AutonomiClient(api_key='...')AutonomiClient[version=X.Y.Z]::[endpoint=https://api.autonomi.ai/v1,health=OK,auth=OK]RequirementsPython 3.7+We currently support Python 3.7+ on Linux and macOS. If you have any questions or issues, pleaseopen an issue.
Package: autonomie-celery
Asynchronous tasks are executed through celery.
pyramid_celery is used to integrate celery with the Pyramid related stuff.
pyramid_beaker is used to cache responses.tasks:Asynchronous tasks called from Autonomiescheduler:Beat tasks, repeated along the time (like cron tasks)ResultsNo result backend is used, tasks interact directly with Autonomie’s database to
return datas.Autonomie celery provides all the models that should be used to store task
execution related stuff (see autonomie_celery.models).InstallSystem packagesautonmie_celery needs a redis server to runOn Debianapt-get install redis-serverOn Fedoradnf install redis-serverPython stuffautonomie_celery should be run in the same environment as Autonomie :https://github.com/CroissanceCommune/autonomieYou may first runworkon autonomiegit clone https://github.com/CroissanceCommune/autonomie_celery.git
cd autonomie_celery
python setup.py install
cp development.ini.sample development.iniCustomize the development.ini file as neededStart itLaunch the following command to launch the worker daemon:celery worker -A pyramid_celery.celery_app --ini development.iniLaunch the following command to launch the beat daemon:celery beat -A pyramid_celery.celery_app --ini development.ini
Package: autonomie_oidc_provider
autonomie_oidc_provider README=================================This is still a work in progress.Open Id connect provider based on Autonomie (http://autonomie.coop).Only *Authorization Code Flow* is supportedGetting Started---------------- cd <directory containing this file>- $VENV/bin/pip install -e .- $VENV/bin/initialize_autonomie_oidc_provider_db development.ini- $VENV/bin/pserve development.iniAuthorization handling-----------------------Generate a new client's key :.. code-block:: consoleoidc-manage <config_uri> clientadd --client=<client> --uri=<redirect_uri> --scopes=<scopes> --cert_salt=<cert_salt>config_uri : Your ini fileclient: A label for your clientredirect_uri : The redirect uri has described in the openid connect specifications (The one passed in the Authorize step)scopes : The scope the application is requesting (at least the openid scope should be provided) e.g: "openid profile"cert_salt : A salt random key that will be used to encrypt the client secret in the databaseAfter generating both client_id and client_secret. The client app is able to request authentication.Authorize Endpoint........................The client app can call the Authorization url :https://myoidc_provider.com/oidc/authorizeIt allows :- Authenticate a user- Get an Authorization code in the responseToken url.........................Called in the background, the Token endpoint is accessible at the following url :https://myoidc_provider.com/oidc/tokenThe RFC : https://tools.ietf.org/html/rfc6749#section-2.3.1Describes Client Password transmission methods.Supported client auth method :* Through request headers : Basic auth tokens are supported* Through request POST params : client_id and client_secret keys are then expectedIn the response you get :- An access token with mandatory informations- An id_token JWS encrypted as described in the spec- Since we use code flow, the id_token also returns the at_hash access_token identification keyAutonomie integration-----------------------In your Autonomie's ini file add the following :.. codeblock:: pythonpyramid.includes =...autonomie_oidc_provider...(That's for model registration so that the db startup initialize the tables)And add the following :.. codeblock::autonomie.includes =...autonomie_oidc_provider.plugin...That register OIDC client application configuration UI :* routes* views* traversal tree branch* template api stuff* templates* menu entries0.0----  Initial version
Package: autonomi-nos
🔥 NOSOptimize, serve and auto-scale Pytorch models on any hardware.Cut your inference costs by 10x.Website|Docs|DiscordNOSis a PyTorch library for optimizing and running lightning-fast inference of popular computer vision models.Optimizing and serving models for production AI inference is still difficult, often leading to notoriously expensive cloud bills and often underutilized GPUs. That’s why we’re buildingNOS- a fast inference server for modern AI workloads. With a few lines of code, developers can optimize, serve, and auto-scale Pytorch model inference without having to deal with the complexities of ML compilers, HW-accelerators, or distributed inference. Simply put, NOS allows AI teams to cut inference costs up to10x, speeding up development time and time-to-market.What is NOS?⚡️Fast: Built for PyTorch and designed to optimize/run models faster🔥Performant: Run models such as SDv2 or object detection 2-3x faster out-of-the-box👩‍💻No PhD required: Optimize models for maximum HW performance without a PhD in ML📦Extensible: Easily add optimization and HW-support for custom models⚙️HW-accelerated:Take full advantage of your HW (GPUs, ASICs) without compromise☁️Cloud-agnostic:Run on any cloud HW (AWS, GCP, Azure, Lambda Labs, On-Prem)NOSinherits its name fromNitrousOxideSystem, the performance-enhancing system typically used in racing cars. NOS is designed to be modular and easy to extend.Batteries Included💪SOTA Model Support:NOS provides out-of-the-box support for popular CV models such asStable Diffusion,OpenAI CLIP,YOLOXobject detection, tracking and more🔌APIs:NOS provides out-of-the-box APIs and avoids all the ML model deployment hassles🐳Docker:NOS ships with docker images to run accelerated and scalable CV workloads📈Multi-Platform: NOS allows you to run models on different HW (NVIDIA, custom ASICs) without any model compilation or runtime management.Getting StartedGet started with NOS in a few lines of code:pipinstallautonomi-nos[torch]API DocumentationQuickstartSupported ModelsRoadmapContributeWe welcome contributions! Please see ourcontributing guidefor more information.
Package: autonomous-app
Autonomous:warning: :warning: :warning: WiP :warning: :warning: :warning:A local, containerized, service based application library built on top of Flask.
The goal is to make it easy to create self-contained Python applications with minimal dependencies using built in libraries for many different kinds of tasks.pypigithubFeaturesFully containerized, service based Python application frameworkAll services are localized to a virtual intranetBuilt-in Local NoSQL database and Model APICloud file storage with Cloudinary or S3Auto-Generated Documentation Pages (Coming Soon!!!)DependenciesLanguagesPython 3.10FrameworksFlaskContainersDockerDocker ComposeServernginxgunicornNetworking and SerializationrequestsDatabaseLocalTestingpytestcoverageDocumentation- Coming Soonpdochighlight.jsDeveloper NotesTODOAuto generate API documentationSetup/fix template app generatorAdd type hintsSwitch to less verbose html preprocessorAdd more database options100% testing coverageIssue TrackingNoneProcessesGenerate appTDBTestsmaketestspackageUpdate version in/src/autonomous/__init__.pymake package
Package: autonomy-dev
Autonomy DevTooling to speed up autonomy development.UsageContractsWe can scaffold a new contract using theadev scaffold contractcommand. This will create a new directory with;open-aea contract componentopen-aea contract component class 🎉open-aea contract component function generation 🚧open-aea contract component test generation 🚧adevscaffoldcontract0xc939df369C0Fc240C975A6dEEEE77d87bCFaC259beyond_pricer\--block-explorer-api-key$BLOCK_EXPLORER_API_KEY\--block-explorer-url"https://api-goerli.arbiscan.io"Installationpipinstallautonomy-dev[all]Releasebump the version in pyoproject and create a new branch and tagexportnew_version=v0.1.5
gitcheckout-b$new_versiongitadd.
gitcommit-m"[chore] bumping version$new_version"gittag$new_versiongitpush--set-upstreamorigin(gitrev-parse--abbrev-refHEAD)gitpush--tag
Package: autonomy-toolkit
Autonomy Toolkitautonomy-toolkitis a simple wrapper arounddocker composewith some minor features which enhance the usability across multiple users and operating systems. The initial design goal was to aid in development of robotics projects that involve autonomy (hence the name), however it has since reduced in scale and is just a wrapper ofdocker compose.Theautonomy-toolkitpackage is under active development by theSimulation Based Engineering Laboratoryat theUniversity of Wisconsin-Madison.Please seethe official documentation(or ongithub) for more details.SupportContact theSimulation Based Engineering Laboratoryfor any questions or concerns regarding the contents of this repository.See AlsoVisit our website athttps://sbel.wisc.edu!
Package: autonon
AutononAUTONON is a groundbreaking library developed by Organon Analytics, revolutionizing the world of Machine Learning. With its advanced capabilities, AUTONON automates and accelerates the entire Machine Learning process(MLops), enabling swift application to real-life challenges. As a versatile Python library available in both private and public clouds, AUTONON offers open source and commercial versions, catering to diverse user needs. Featuring four powerful modules, AUTONON empowers users with unparalleled capabilities. The feature extraction module enables efficient extraction of relevant information from datasets, while the data quality module ensures the integrity and reliability of input data. The machine learning module facilitates seamless model development and optimization, while the deep learning module opens doors to cutting-edge neural network architectures. By leveraging AUTONON, data scientists and practitioners can unlock new levels of efficiency, productivity, and accuracy in their Machine Learning endeavors. Whether it's accelerating research projects, developing innovative solutions, or tackling complex business problems, AUTONON empowers users to achieve exceptional results and stay at the forefront of the rapidly evolving field of Machine LearningDocumentationCode of ConductContributionBug reports:  You can use GitLab issues.Contact:support@organonanalytics.comCompany website:Organon AnalyticsInstallationpipinstallautononRequirementsA compiler for C is required for building cython modules. Check requirements for your operating system inhttps://cython.readthedocs.io/en/latest/src/quickstart/install.htmlFor oracle connections, cx_Oracle library is used. This library requires Oracle Client Libraries to be installed.
Please follow the instructions in the link :https://cx-oracle.readthedocs.io/en/latest/user_guide/installation.html#install-oracle-clientPreparing Development EnvironmentAfter you pull the code, runcmd/csetup.batfor Windowschmodu=rwxsetup.sh
./setup.shfor Linux.This script will prepare a virtual environment('orgenv') and build cython source files.
Then, you can start development after activating "orgenv" environmentNOTE:Script uses default python version in your system to generate the virtual environment.
If your default python version is less than 3.8 or you want to use another python version,
you can change the "python" commands in the script with the path to python version you want to use.Unit Tests And CoverageTo run unittests and measure code coverage:Activate 'orgenv' virtual environmentRun command to run coverage:coveragerun--omit='*orgenv*'-munittestorganon/all_tests.pyRun command to get coverage report:coverage reportLicenseThis project is licensed under the terms of theMIT License