Saravanan666/pypi-org huggingface dataset:
Package: authy
Python Client for Twilio Authy Two-Factor Authentication (2FA) APIDocumentation for Python usage of the Authy API lives in theofficial Twilio documentation.The Authy API supports multiple channels of 2FA:One-time passwords via SMS and voice.Soft token (TOTPvia the Authy App)Push authentication via the Authy AppIf you only need SMS and Voice support for one-time passwords, we recommend using theTwilio Verify APIinstead.More on how to choose between Authy and Verify here.Authy QuickstartFor a full tutorial, check out either of the Python Authy Quickstarts in our docs:Python/Django Authy QuickstartPython/Flask Authy QuickstartAuthy Python InstallationInstall withpip:$ pip install authyORDownload thesource codeand run the following command from your terminal:$ python setup.py installNote that you may need admin permissions to run the above commands.UsageTo use the Authy client, import AuthyApiClient and initialize it with your production API Key found in theTwilio Console:fromauthy.apiimportAuthyApiClientauthy_api=AuthyApiClient('your_api_key')2FA WorkflowCreate a userSend a one-time passwordVerify a one-time passwordORCreate a userSend a push authenticationCheck a push authentication statusPhone VerificationPhone verification now lives in the Twilio APIand hasPython support through the official Twilio helper libraries.Legacy (V1) documentation here.Verify V1 is not recommended for new development. Please consider usingVerify V2.ContributingInstall development dependencies with pip:sudo pip install -r requirements.txtTo run tests:make testormake testfile tests/<test_case_file>CopyrightCopyright (c) 2011-2020 Authy Inc. SeeLICENSEfor further details.
Package: authz-analyzer
authz-analyzer (AKA Authorization Analyzer) helps DevOps and data engineers quickly understand who has access to what data and how.DevOps and data engineers are often tasked with managing the security of the databases, data lakes or warehouses they operate. This usually involves setting permissions to enable users to query the data they need. However, as the number of users and use-cases increase, complexity explodes. It's no longer humanly possible to remember who had access to what, how and why, which makes meeting security and compliance requirements impossible.The root cause of this problem is that permissions to data are usually stored in normalized form, which is great for evaluating permissions but not so great when you want to clearly understand your permissions landscape. When asked "how come Joe can query that table?", it can be a long process to get to a definitive answer and that's just time we don't have. With so many data stores, each with its own security model, it's not feasible to manage it all manually.Identifying this was an issue for many of our customers, the team atSatoridecided to buildAuthorization Analytics, a service that helps admins to better manage their data store permissions. We believe no one should have to sift through DB system tables to get a clear picture of who can do what with data.Authz Analytics is available in two forms:authz-analyzer open source CLI - scan the permissions structure of a database to get the list of all users and data assets they can access.Satori Authorization Analytics - a fully managed SaaS solution to periodically scan, store and visualize all users and data assets they can access. Learn morehere.DocumentationFor more information on the authz-analyzer open-source,go to the docs.ContributingPlease follow thecontributing guidelines.CreditsThis package was created withCookiecutterand thewaynerv/cookiecutter-pypackageproject template.
Package: authzed
Authzed Python ClientThis repository houses the Python client library for Authzed.Authzedis a database and service that stores, computes, and validates your application's permissions.Developers create a schema that models their permissions requirements and use a client library, such as this one, to apply the schema to the database, insert data into the database, and query the data to efficiently check permissions in their applications.Supported client API versions:v1You can find more info on each API on theAuthzed API reference documentation.
Additionally, Protobuf API documentation can be found on theBuf Registry Authzed API repository.SeeCONTRIBUTING.mdfor instructions on how to contribute and perform common tasks like building the project and running tests.Getting StartedWe highly recommend following theProtecting Your First Appguide to learn the latest best practice to integrate an application with Authzed.If you're interested in examples of a specific version of the API, they can be found in their respective folders in theexamples directory.Basic UsageInstallationThis project is packaged as the wheelauthzedon thePython Package Index.If you are usingpip, the command to install the library is:pipinstallauthzedInitializing a clientWith the exception ofgRPCutility functions found ingrpcutil, everything required to connect and make API calls is located in a module respective to API version.In order to successfully connect, you will have to provide aBearer Tokenwith your own API Token from theAuthzed dashboardin place oft_your_token_here_1234567deadbeefin the following example:fromauthzed.api.v1importClientfromgrpcutilimportbearer_token_credentialsclient=Client("grpc.authzed.com:443",bearer_token_credentials("t_your_token_here_1234567deadbeef"),)Performing an API callfromauthzed.api.v1import(CheckPermissionRequest,CheckPermissionResponse,ObjectReference,SubjectReference,)post_one=ObjectReference(object_type="blog/post",object_id="1")emilia=SubjectReference(object=ObjectReference(object_type="blog/user",object_id="emilia",))# Is Emilia in the set of users that can read post #1?resp=client.CheckPermission(CheckPermissionRequest(resource=post_one,permission="reader",subject=emilia,))assertresp.permissionship==CheckPermissionResponse.PERMISSIONSHIP_HAS_PERMISSION
Package: authzerolib
authozero libraryThis is a super simple and basic Auth0 Python client library.You can also find it here:https://pypi.python.org/pypi/authzerolibQuickstartfrom authzero import AuthZero

config = {'client_id': 'AAAA', 'client_secret': 'BBBB', 'uri': 'localhost'}
az = AuthZero(config)
ret = az.get_rules()
...Seeauthzerolib.pyfor a list of functions.OptionsAuthZero.access_token_auto_renew boolif true, the library will attempt to automatically renew access_tokensAuthZero.access_token_auto_renew_leeway intin seconds, will renew the access token before it expires with that
amount of time buffer
Package: authzync
________________________________________/\__\/\ \/\ \/\___\/\ \_\ \/\___\/\ \_\ \/\"-.\ \   /\  ___\
\ \  __ \  \ \ \_\ \  \/_/\ \/ \ \  __ \  \/_/  /__  \ \____ \  \ \ \-.  \  \ \ \____
 \ \_\ \_\  \ \_____\    \ \_\  \ \_\ \_\   /\_____\  \/\_____\  \ \_\\"\_\\ \_____\\/_/\/_/\/_____/\/_/\/_/\/_/\/_____/\/_____/\/_/\/_/\/_____/Supports LDAP & local users.Follows nested groups.Compatible with Python 2 and 3.Installationgit$pypiinstallldap3$gitclonehttps://github.com/rbw0/authzync.gitpypi$pypiinstallauthzyncUsage examplePerform a sync of the LDAP directory specified inauthzync.json, get non-LDAP permissions fromlocal_db.jsonand write results tosvn_authz.txt$pythonauthzync.py--configauthzync.json--local_dblocal_db.json--authzsvn_authz.txtConfigurationAuthzync config (–config)Configures LDAP, mappings, parse rules, logging etcExamplehttps://github.com/rbw0/authzync/blob/master/examples/authzync.jsonLocal users (–local_db)Can be used to set repository permissions for users not present in the LDAP directory, i.e. local users.Examplehttps://github.com/rbw0/authzync/blob/master/examples/local_db.jsonHow it worksAuthzync starts by looking for groups matching thepatterns.access_patterninldap.base_dnNote that there’s only one required part in the group name:repo_access(ROorRW). This tells authzync which permission to apply to members of this group.Next, the value of the attribute set inmappings.section_nameis parsed according topatterns.section_patternFinally, a list of members is fetched and the authz file generated.ExampleAuthzync configNameValueldap.base_dnou=SVN,dc=example,dc=commappings.section_namedescriptionpatterns.access_pattern^svn_.*_(?P<repo_access>RO|RW)$patterns.section_pattern^(?P<repo_name>.*):(?P<repo_path>/.*)…and…LDAP directoryGroup namedescriptionvalueMemberssvn_repo1-trunk_rorepo1:/trunkuser1, user2svn_repo2-branches_rorepo2:/branchesuser1, user3svn_repo1_rwrepo1:/user3Should result in:[repo1:/trunk]
user1 = r
user2 = r

[repo2:/branches]
user1 = r
user3 = r

[repo1:/]
user3 = rwAuthorCreated by Robert Wikman <rbw@vault13.org> in 2017
Package: autisto
AutistoInstallationwget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc |  gpg --dearmor | sudo tee /usr/share/keyrings/mongodb.gpg > /dev/null
echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/6.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list
sudo apt update
sudo apt install mongodb-org
sudo systemctl enable mongod
sudo systemctl start mongod


sudo pip3 install autisto
sudo autisto  # follow further CLI instructionsIMPORTANT: After successful setup, consider setting up the back-up routine according to the instructions under /back_up .
Package: auto1
Auto1 ETLAuto1 ETL is simple etl Pipeline, which extracts the data from given source dataFile and returns the transformed data.Directory Structure│   .gitignore
│   challenge_me.txt
│   README.md
│   sample.py
│   setup.py
│
├───.vscode
│       launch.json
│
└───auto1
    │   etl.py
    │   __init__.py
    │
    ├───helper
    │   │   helper.pyauto1/etl.py: Etl scripthelper/helper.py: helper script with mapper and utility functions required for etl process.challenge_me.txt: input dataFile to perform transformationsample.py: sampy script to import etl class as moduleInstructionsinstall the package aspip install auto1importauto1.Etlin your python fileInitialize theEtlconstructor with source dataFile pathInvoke the methods in order as belowfromauto1.etlimportEtletl=Etl('challenge_me.txt')etl.load(etl.dataFile)output=etl.transform(etl.dataFile)print(output)load method creates a temporary dataFile, which is prepared for transformation.transformation methods returns the transformed records as nested list and deletes the temporary dataFile created by load method.
Package: auto1-etl-challenge
Auto1 ETL ChallengeA simple ETL pipepline that serves the purpose of a challenge forAUTO1, a company that is Europe's largest wholesale platform for used cars.Developed by Muhammad Aqib -inbox.aqib@gmail.comContentsauto1_etl_challengecontains the project directory.auto1_etl_challenge\etl.pyis the main module that hasEtlPackageAuto1class with associated methods.auto1_etl_challenge\utils.pyholds utilites that assists in performing etl operations.auto1_etl_challenge\transformations.pymodule for defining custom exceptions for the required columns.auto1_etl_challenge\constants.pyholds classes for different constant values.filesis a directory for storing files for testing purpose, specifically raw, staging and transformed files.How To UsePackage Installationauto1-etl-challengeInstall the package in the virtual environmentpipinstallauto1-etl-challengeCode GuidelinesCreate a python file and importEtlPackageAuto1class from the package.Provide source file path in the constructor.Callloadandtransformmethod.fromauto1_etl_challengeimportEtlPackageAuto1#import EtlPackageAuto1 class form packageEtlPackageAuto1(r'files\challenge_me.txt')#stores path of the source fileEtlPackageAuto1.load(EtlPackageAuto1.dataFile)# loads data and create staging file with cleaned dataresult=EtlPackageAuto1.transform(EtlPackageAuto1.dataFile)# transform data, create transformed file and return list matrixOutputStaging and transformed files are created in the same directory as source file.List of lists is returned where first list is header while the following lists contain the values (row-wise).Github
Package: autoactive
The AutoActive Python package is a set of classes used to read and write aaz files. The aaz file type is
a common filetype used in the AutoActive Research Enviroment. The overall goal of the AutoActive Research
Enviroment is to ease the analysis and development of machine learning models using data from multiple types
of sensors.The AutoActive Research Enviroment consists of Activity Presenter, AutoActive Python package and AutoActive Matlab toolbox.
Activity Presenter is a graphical user interface which makes it easy to synchronize, visualise and organise data
from multiple sensors, while the overall goal of the AutoActive Python package and the AutoActive Matlab toolbox is to make
it possible to import the preprocessed data into Python or Matlab where you can utilse all the powerfull algorithms
already implemented.The AutoActive Python package also makes it possible to write the results back to aaz files, and thereby,
also visualising the results in Activity Presenter.More information about the AutoActive Research Enviroment (ARE) and the aaz file type is available here:https://github.com/SINTEF/AutoActive-ActivityPresenterLicenseApache License Version 2.0InstallationTo use the AutoActive Python package you need to clone this repository and import it into
your projects of intereset.ExamplesThere are today two example files in the repository, where the first is an example script to shown how to
create a new aaz file and write it to a file. This file is named write_archive_sine.py and is located
in the example folder. The second example is an example script to show how to
read data from an aaz file. This file is also located in the example folder and is named read_archive_sine.py
Before running read_archive_sine.py you can create an aaz file with write_archive_sine.pyCoding style / guidelinesIf you whish to contribute to the project please follow these guidelines:use_lower_case_with_underscores_naming for everything except ClassesFor classes UseCamelCaseRemove unused code, don't comment out, you have git for thisUse the black formatter (https://pypi.org/project/black/) to format you code.TODOThere are a couple of pressing issues
1. Session Object returned from ArchiveReader should be immutable
2. Implement error handling
3. Handle Gaitup and Catapult imports as these are very common sensors used in sports.
Package: auto-activenv
# Auto ActivenvPython package to automatically activate virtual environments when installed
Compatible with Python2 and Python3.5+## Disclaimers
- This package is NOT compatible with Windows
- This package (as of right now) will only work if you name your virtual
environmentsvenv## Usage
-pip install auto-activenv-activenv –helpfor options
- Once installed, it is safe to remove the CLIpip uninstall auto-activenv## TODO’s
- Change name of virtualenvs with option or use regex to determine virtualenvs
- Install detection
Package: autoadd-bindir
https://app.codecov.io/gh/libranet/autoadd-bindirAutoadd-bindirAutomatically add the bin-directory of your virtualenv to thePATH-environment variable
viasitecustomize-entrypoint. You now no  longer need to manuallyactivateyour
virtual environment for the sole purpose of adding thie bin-drectory to your$PATH.How does it work?We register theautoadd_bin.entrypoint()-function to thesitecustomize-module that is installed by thesitecustomize-entrypoints-package.The registered function will look upsys.prefixof your python-executable and
add the corresponding bin-directory to thePATH.InstallationInstall via pip:>bin/pipinstallautoadd-bindirOr add to your poetry-based project:>poetryaddautoadd-bindirValidate & UsageAfter installing this package there is nothing left to do explicitly.
We can validate that the plugin work correctly by starting a python-session and checking thePATH-environment-variable:>bin/python>>>importos>>>print(os.getenv("PATH"))"<path-to-your-virtualenv>/bin",...Registered sitecustomize-entrypointTheautoadd_bindir-function is registered as asitecustomize-entrypoint in our pyproject.toml_:[tool.poetry.plugins][tool.poetry.plugins."sitecustomize"]autoadd_bindir="autoadd_bindir:entrypoint"Sitecustomize and all its registered entrypoints will be executed at the start ofeverypython-process.
For more information, please seesitecustomize-entrypointsCompatibilityautoadd-bindirworks on Python 3.8+, including PyPy3. Tested until Python 3.11,Notable dependenciessitecustomize-entrypoints
Package: auto-aiml
AUTO AIMLThis module takes input csv/excel file and regression/classification flag and it processes the file and create the best model.Installationpip install auto-aimlHow to use it?Open terminal and the give regression flag yes  and No for classification then csv/ excel flag Y/N and the file location and that it you are done, wait the process to complete and you can get best model .LicenseÂ© 2020 Yashwanth AgastyaThis repository is licensed under the MIT license. See LICENSE for details.
Package: autoalbument
AutoAlbumentAutoAlbument is an AutoML tool that learns image augmentation policies from data using theFaster AutoAugment algorithm. It relieves the user from the burden of manually selecting augmentations and tuning their parameters. AutoAlbument provides a complete ready-to-use configuration for an augmentation pipeline.The library supports image classification and semantic segmentation tasks. You can useAlbumentationsto utilize policies discovered by AutoAlbument in your computer vision pipelines.The documentation is available athttps://albumentations.ai/docs/autoalbument/BenchmarksHere is a comparison between a baseline augmentation strategy and an augmentation policy discovered by AutoAlbument
for different classification and semantic segmentation tasks. You can read more about these benchmarks in theautoalbument-benchmarksrepository.ClassificationDatasetBaseline Top-1 AccuracyAutoAlbument Top-1 AccuracyCIFAR1091.7996.02SVHN98.3198.48ImageNet73.2775.17Semantic segmentationDatasetBaseline mIOUAutoAlbument mIOUPascal VOC73.3475.55Cityscapes79.4779.92InstallationAutoAlbument requires Python 3.6 or higher. To install the latest stable version from PyPI:pip install -U autoalbumentHow to use AutoAlbumentYou need to create a configuration file with AutoAlbument parameters and a Python file that implements a custom PyTorch Dataset for your data. Next, you need to pass those files to AutoAlbument.AutoAlbument will use Generative Adversarial Network to discover augmentation policies and then create a file containing those policies.Finally, you can useAlbumentationsto load augmentation policies from the file and utilize them in your computer vision pipelines.You can read the detailed description of all steps athttps://albumentations.ai/docs/autoalbument/how_to_use/ExamplesTheexamplesdirectory contains example configs for different tasks and datasets:ClassificationCIFAR10SVHNImageNetSemantic segmentationPascal VOCCityscapesTo run the search with an example config:autoalbument-search --config-dir </path/to/directory_with_dataset.py_and_search.yaml>
Package: autoAmbient
auto-enviromentauto-enviroment é uma biblioteca Python que fornece modelos automatizados para facilitar o desenvolvimento de automações que interagem com interfaces de usuário em desktops, clicando, procurando e esperando quando solicitadoInstalaçãoPara realisar a instalação basta executar o seguinte comando via pip:pipinstallautoAmbientModo de usarPara começar a usar o auto-enviroment basta executar o comando no seu terminal :createAmbientA partir daí seram criados todos os arquivos base para que você comece a produzir e automatizar o que quiser.
Escolha um local que você queira clicar, tire uma print, e coloque a imagem na pasta resouces com um bom nome, logo após isso execute:createTagsFileApós a criação da referencia à imagem no arquivo de tags você deve escrever o seu fluxo em run.py como no exemplo a seguir:frombotcity.coreimportDesktopBotimporttagsastg# noqa: E261, F401importblocksasblsfromambient.tolls.utilsimportNfdefrun():classBot(DesktopBot):defaction(self,execution=None):nf=Nf(self)click(tg.btn_name)#o lugar que você que clicarBot.main()Depois disso é só executar o main.py e ver a mágica acontecerFunçõesAs quatro funções disponíveis no arquivoautomations-enviroment/src/run.pyque são fornecidas pela classeNfdo móduloambient.tolls.utilstêm as seguintes funcionalidades:click(imgName, waiting_time): essa função faz um clique esquerdo do mouse na imagem com o nome fornecido.clickIfPossible(imgName, waiting_time): realiza a mesma operação do click, mas apenas se for possível, caso contrário, ele será ignorado e não emitira mensagem de erro.awaitItGoOut(imgName, waiting_time): essa função aguarda até que a imagem passada como parâmetro desapareça da tela.find(imgName, waiting_time, afterAction, notFoundAction): essa função busca pela imagem passada como parâmetro ,caso seja encontrado, executa o afterAction e, caso não, o notFoundAction.Mensagens de erroO auto-enviroment conta com diversas maneiras de corrigir erros como as GUIs para quando a respectiva imagem não for encontrada.Mais algumas dessas interfaces podem ser usadas importandofrom ambient.tolls.gui import guicomo no exemplo a seguir.ContribuindoSe você quiser contribuir com a biblioteca AutoAmbient, você deve seguir as seguintes etapas:Fork o repositórioCrie sua branch de features (git checkout -b feature/fooBar)Realize o commit de suas alterações (git commit -am 'Add some fooBar')Faça o push das alterações (git push origin feature/fooBar)Crie um novo Pull RequestLicençaEste projeto está sob a licença MIT. Para mais informações acesse o arquivoLICENSE.
Package: autoanno
Create a MVP as fast as possible. Goal is to investigate whether TDA can be used to create an unsupervised algorithm
for automatically producing annotations and labels for relatively simple data. Key features include:Find datasets which can be used to for classification and or clustering purposes [X]
I am going to use Taskmaster 2 data set.Clean and explore the dataWrangle the data to get into a form compatible for tools such as word2vec or deepwalk
the former most likely accessed via gensim or pytorchUse these tools to encode data as vectors.Use simple models as baselines for classification and clustering. (KNN, other algs)Apply Topological data analysis on these vectors to produce clusters (ToMATo algorithm maybe a custom algorithm)Compare TDA results with baselines using statistical/error analysis. Could use external clustering based metrics or
more familiar metrics like F-measure.As the main goal here is to investigate whether unsupervised and or automated machine learning can be used for the
purpose of annotation of data, the model will be graded as a classification algorithm.
Success will be defined byThe TDA algorithm has better results (in some metric to be determined) than other unsupervised learning algorithmsThe clustering/annotation is of sufficient accuracy to be deployed as a business solution. I.e. meets accuracy threshold.For speed, this will primarily be done in notebook format.
Package: autoant
Auto AntAutoAnt is a generic processing automation package. It’s ideal for file processing, if you need
to process/syncronize/move files on several directories to different locations (local or remote)
and then renaming/moving/deleting or what ever you want. This is the answer.It’s extremely flexible and extensible, just describe your Sys Admin file/somethingprocessing nightmare
on a JSON file.DocumentationTake a look at installation, quick how to tutorials, API reference etc:DocumentationFeatures:Remote ‘Copy’ files using SMB(SAMBA), FTP, FTPS, SFTP(SSH).Local process, move, copy and rename.Filter and Rename files using regular expressions.Open file detection (Linux only).Optional, parallel (Threads) processing.Differential processing, only process what has changed. (On directories, only new or modified files).Highly extensible base, you can easily create your ownprocessors, orproducers