Saravanan666/pypi-org huggingface dataset:
Package: keyprotect
keyprotect-python-clientA Pythonic client for IBM Key ProtectThis is a thin wrapper around the KeyProtect client in theredstonePython package. For detailed documentation and API references, please see theredstone docsThe client works with Python 3.5 or higherInstallationThe client is available on PyPI as thekeyprotectpackage and is installable viapip:pipinstall-UkeyprotectUsageThe following python is a quick example of how to use the keyprotect module.The example expectsIBMCLOUD_API_KEYto be set to a valid IAM API key,
andKP_INSTANCE_IDto be set to the UUID identifying your KeyProtect instance.importosimportkeyprotectfromkeyprotectimportbxauthtm=bxauth.TokenManager(api_key=os.getenv("IBMCLOUD_API_KEY"))kp=keyprotect.Client(credentials=tm,region="us-south",service_instance_id=os.getenv("KP_INSTANCE_ID"))forkeyinkp.keys():print("%s\t%s"%(key["id"],key["name"]))key=kp.create(name="MyTestKey")print("Created key '%s'"%key['id'])kp.delete(key_id=key.get('id'))print("Deleted key '%s'"%key['id'])# wrap and unwrap require a non-exportable key,# these are also referred to as root keyskey=kp.create(name="MyRootKey",root=True)# wrap/unwrap, payload should be a bytestring if python3message=b'This is a really important message.'wrapped=kp.wrap(key_id=key.get('id'),plaintext=message)ciphertext=wrapped.get("ciphertext")unwrapped=kp.unwrap(key_id=key.get('id'),ciphertext=ciphertext)assertmessage==unwrapped# wrap/unwrap with AADmessage=b'This is a really important message too.'wrapped=kp.wrap(key_id=key.get('id'),plaintext=message,aad=['python-keyprotect'])ciphertext=wrapped.get("ciphertext")unwrapped=kp.unwrap(key_id=key.get('id'),ciphertext=ciphertext,aad=['python-keyprotect'])assertmessage==unwrappedUsing custom endpointThe following example shows how to use custom service endpointkp=keyprotect.Client(credentials=tm,region="<region>",service_instance_id=os.getenv("KP_INSTANCE_ID"),# Set custom service endpointendpoint_url="https://private.us-south.kms.cloud.ibm.com")
Package: keyring-configparser
keyring_configparserA ConfigParser subclass that can read values stored with thekeyring pypi package.Installationpip install keyring_configparserUsageIt is recommended to be familiar with theConfigParsermodule and thekeyringpypi package before use.KeryingConfigParseris identical toConfigParserexcept when it reads a specific token as a configuration value ("$."by default) it uses the keyring package to resolve the value. This enables using secret values in configuration files without storing the value as plain-text within the file.Basic Example#/tmp/app.config
[section_name]
non_secret = hello world
secret_name = $.importkeyringkeyring.set_password("section_name","secret_name","secret_value")fromkeyring_configparserimportKeyringConfigParserconfig=KeyringConfigParser()config.read("/tmp/app.config")config.get('section_name','non_secret')>"hello world"sec=config.get('section_name','secret_name')>"secret_value"Additional ExamplesConfigured Keyring InstancesA configured keyring instance can be supplied to theKeyringConfigParserconstructor. This allows using non-default backends or any other non-default keyring settings when looking up values in keyring.For example, to use thekeyrings.cryptfilebackend:#/tmp/app.config
[section_name]
non_secret = hello world
secret_name = $.fromkeyrings.cryptfile.cryptfileimportCryptFileKeyringkr=CryptFileKeyring()kr.keyring_key="CRYPTFILE_PASSWORD"kr.set_password("section_name","secret_name","secret_value")fromkeyring_configparserimportKeyringConfigParserfromkeyrings.cryptfile.cryptfileimportCryptFileKeyringkr=CryptFileKeyring()kr.keyring_key="CRYPTFILE_PASSWORD"config=KeyringConfigParser(keyring=kr)config.read("/tmp/app.config")config.get('section_name','secret_name')>"secret_value"Custom Config TokenA token can be supplied to theKeyringConfigParserconstructor to override the default token"$.". When the custom token is encountered in the configuration file the value will be resolved with keyring.#/tmp/app.config
[section_name]
non_secret = hello world
secret_name = !~!
default_token = $.importkeyringkeyring.set_password("section_name","secret_name","secret_value")fromkeyring_configparserimportKeyringConfigParserconfig=KeyringConfigParser(token="!~!")config.read("/tmp/app.config")config.get('section_name','secret_name')>"secret_value"config.get('section_name','default_token')>"$."Questions / IssuesPlease raise any questions in theDiscussionspage of the repository.Please document any issues encountered in theIssuespage of the repository.
Package: keyring_jeepney
ThePython keyring libis a
cross-platform interface to store and retrieve passwords and other secret
information.This is a keyring backend for Linux that only needs pure Python dependencies.
Like the mainSecretServicebackend, it uses DBus to talk to the secret
service daemon. However, theSecretServicebackend relies on system libraries,
which makes installation more difficult. This backend usesJeepney, a pure Python DBus backend.To use this module, simply install it and use thekeyringAPI as normal; if
the mainSecretServicebackend is not available, keyring should
automatically detect and usekeyring_jeepney.To explicitly use this module:import keyring
import keyring_jeepney
keyring.set_keyring(keyring_jeepney.Keyring())The standard SecretService backend has been much better tested than this one,
so you probably want to use that one where practical.
Package: keyring-pass
keyring_passThis is apassbackend forkeyringInstall withpip install keyring-passand set the following content in
yourkeyringrc.cfgfile:[backend]default-keyring=keyring_pass.PasswordStoreBackendYou can modify the defaultpython-keyringprefix forpass, by:adding following tokeyringrc.cfg:[pass]key-prefix=alternative/prefix/pathbinary=gopass(forkeyringversion 23.0.0 or higher) setting environment variables:KEYRING_PROPERTY_PASS_KEY_PREFIXKEYRING_PROPERTY_PASS_BINARYYou can clear the path (start from root), by setting above to.or an empty value (justkey-prefix=on the line).Test your setupYou can check if your setup works end-to-end (creates, reads and deletes a key from password store).# warning: this will create and delete a key at `<prefix>/test/asd` in your password storepython-mkeyring_pass
Package: keyring-pybridge
keyring-pybridgeUsageInstallkeyring-pybridgefrom pypi usingpip install keyring-pybridge, or whatever alternative python package manager you prefer.Then set environment variables to use the backend:PYTHON_KEYRING_BACKEND=keyring_pybridge.PyBridgeKeyringFinally, you have to point the backend to the secondary python executable that you want to connect to. The keyring package must be installed in that python executable's environment.KEYRING_PROPERTY_PYTHON=/path/to/pythonWSLThe most useful application of this backend is when you are using keyring in a WSL environment, and would like to connect it to the host machine's Windows Credential Manager.On the host machine, you need to create a python environment and install keyring in it.Then, in WSL, configure the environment variableKEYRING_PROPERTY_PYTHONto point to the python executable with keyring installed:KEYRING_PROPERTY_PYTHON=C:\path\to\the\right\python.exeSince this library calls the windows binary via a subprocess, this facilitates the context switch to windows that allows keyring to communicate with the Windows Credential Manager. 🎉
Package: keyrings.alt
Alternate keyring backend implementations for use with thekeyring package.Keyrings in this package may have security risks or other implications. These
backends were extracted from the main keyring project to
make them available for those who wish to employ them, but are
discouraged for general production use. Include this module and use its
backends at your own risk.For example, the PlaintextKeyring stores passwords in plain text on the file
system, defeating the intended purpose of this library to encourage best
practices for security.For EnterpriseAvailable as part of the Tidelift Subscription.This project and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use.Learn more.
Package: keyrings.codeartifact
AWS CodeArtifact Keyring BackendThekeyrings.codeartifactpackage provides authentication for publishing and consuming packages within a private
PyPi repository hosted onAWS CodeArtifact; it contains an extension to thekeyringlibrary that will automatically inject a time-limited access token.InstallationTo install this package, install the "keyrings.codeartifact" package usingpip:pip install keyrings.codeartifactUsageThekeyringlibrary has been integrated with recent versions of pip and twine. Once installed, this library will
automatically supply credentials whenever pip/twine (or other keyring-enabled package) attempts to use a repository
hosted within CodeArtifact. It will use any appropriate AWS credentials provided in~/.aws/credentialsby default.--index-url https://${DOMAIN}-${ACCOUNT}.d.codeartifact.${REGION}.amazonaws.com/pypi/${REPOSITORY}/simple/ConfigThis backend provides a number of configuration options to modify the behaviour of the AWS client.These configuration options can be specified within a[codeartifact]section of thekeyringrc.cfg.Runkeyring diagnoseto find its as the location; it varies between different platforms.Available options:profile_name: Use a specific AWS profile to authenticate with AWS.token_duration: Validity period (in seconds) for retieved authorization tokens.aws_access_key_id: Use a specific AWS access key to authenticate with AWS.aws_secret_access_key: Use a specific AWS secret access key to authenticate with AWS.For more explanation of these options see theAWS CLI documentation.An examplekeyringrc.cfgsection:[codeartifact]# Tokens should only be valid for 30 minutes.token_duration=1800# Use the 'default' profile name.profile_name=default# Use the following access keys.aws_access_key_id=xxxxxxxxxaws_secret_access_key=xxxxxxxxx
Package: keyrings.efile
keyrings.efileWe needed a keyrings implementation that just worked in headless environments.keyrings.efileencrypts passwords using files stored on the local filesystem (/var/tmp/).It's not secure if an attacker can read all the files, but at least doesn't store the password
as plain text.The current implemetation has the kerying priority set to 20 to take precedence over the Chainer backend.
This may change in future releaeses.
Package: keyrings.envvars
keyrings.envvarsis a keyring backend plugin for thekeyringutility that provides credentials via environment variables.Requirementskeyring >= 23.4.0Python >= 3.9InstallationYou can installkeyrings.envvarsviapipfromPyPI:$pipinstallkeyrings.envvarsUsagekeyrings.envvarsuses the following format for environment variables:KEYRING_SERVICE_NAME_<n>=<service>
KEYRING_SERVICE_USERNAME_<n>=<username>
KEYRING_SERVICE_PASSWORD_<n>=<password>Example for usage with pip credentials:KEYRING_SERVICE_NAME_0=private-pypi-index.example.com
KEYRING_SERVICE_USERNAME_0=testusername
KEYRING_SERVICE_PASSWORD_0=testpassword
KEYRING_SERVICE_NAME_1=another-private-pypi-index.example.com
KEYRING_SERVICE_USERNAME_1=testusername
KEYRING_SERVICE_PASSWORD_1=testpasswordThis can be used along with a requirements.txt containing appropriate--extra-index-urlflags to avoid storing
credentials in plain-text:--extra-index-url https://private-pypi-index.example.com/simple

private-package==1.2.3Note: Defining multiple identical credentials (service name and username)
will result in the last defined password being returned as the environment
variables are sorted by the keyring backend.export KEYRING_SERVICE_NAME_0=https://private-pypi-index.example.com
export KEYRING_SERVICE_USERNAME_0=testusername
export KEYRING_SERVICE_PASSWORD_0=testpassword
export KEYRING_SERVICE_NAME_1=https://private-pypi-index.example.com
export KEYRING_SERVICE_USERNAME_1=testusername
export KEYRING_SERVICE_PASSWORD_1=testpassword_1
keyring get https://private-pypi-index.example.com testusername
testpassword_1If there are multiple credentials defined for a service and no username is given when searching thenNonewill be returned.
For example, given the definitions above:>>>importkeyring>>>cred=keyring.get_credential('https://private-pypi-index.example.com',None)>>>print(cred)NoneContributingContributions including suggestions, pull requests, etc. are very welcome.keyrings.envvarsusesConventional Commitsformat for commit messages.Runnoxbefore committing any changes.LicenseDistributed under the terms of theMIT license,keyrings.envvarsis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.Please readhttps://www.chiark.greenend.org.uk/~sgtatham/bugs.htmlbefore you file an issue.CreditsThis project was generated from@cjolowicz’sHypermodern Python Cookiecuttertemplate.
Package: keyrings.google-artifactregistry-auth
Artifact Registry tools for PythonThis repository contains an alternatekeyringbackend implementation to help with interacting with Python repositories hosted on Artifact Registry.Authenticationkeyrings.google-artifactregistry-authis a Python package which allows you to configure keyring to interact with Python repositories stored in Artifact Registry.The backend automatically searches for credentials from the environment and authenticates to Artifact Registry. It looks for credentials in the following order:Google Application Default Credentials.From thegcloudSDK. (i.e., the access token printed viagcloud config config-helper --format='value(credential.access_token)')Hint: You can see which account is active with the commandgcloud config config-helper --format='value(configuration.properties.core.account)'If neither of them exist, an error occurs.To use the keyring backend:Log inOption 1: log in as a service account:(1). Using a JSON file that contains a service account key:$ export GOOGLE_APPLICATION_CREDENTIALS=[path/to/key.json](2). Or usinggcloud:$ gcloud auth application-default loginOption 2: log in as an end user viagcloud:$ gcloud auth loginConfigure twine (.pypirc) and pip (pip.conf) tools to connect to the repository. Use the output from the following command:$ gcloud artifacts print-settings pythonIn your.pypircfile add:[disutils]index-servers=REPOSITORY_ID[REPOSITORY_ID]repository=https://LOCATION-python.pkg.dev/PROJECT_ID/REPOSITORY_ID/In yourpip.conffile add:[global]extra-index-url=https://LOCATION-python.pkg.dev/PROJECT_ID/REPOSITORY_ID/simple/Install thekeyrings.google-artifactregistry-authpackage$ pip install keyrings.google-artifactregistry-authList backends to confirm the installation.$ keyring --list-backendsThe list should includekeyrings.gauth.GooglePythonAuth (priority: 9)keyring.backends.chainer.ChainerBackend (priority: -1)keyring.backends.fail.Keyring (priority: 0)Usage with other toolsUsage withtoxThetoxtoolis a testing and automation tool.Because the credential helper needs to be installedbeforeany private
dependencies are installed, it needs to be bootstrapped into thetoxenvironment via a plugin.To do this, specify thekeyrings.google-artifactregistry-authpackage via therequiresrequirement in yourtox.inifile:[tox]envlist=pyrequires=keyrings.google-artifactregistry-auth[testenv]deps=-r requirements.txtYou can then configure yourrequirement.txtfile to use the Artifact Registry repo as
an extra index, and specify both public and private dependencies:--extra-index-url https://[REGION]-python.pkg.dev/[PROJECT_ID]/[REPOSITORY]/simple

# samplepackage will be installed directly from PyPI
samplepackage
# mypackage will be installed from the Artifact Registry repository
mypackage
Package: keyrings.google-artifactregistry-auth-gcloud
Artifact Registry tools for PythonThis repository contains an alternatekeyringbackend implementation to help with interacting with Python repositories hosted on Artifact Registry.Authenticationkeyrings.google-artifactregistry-authis a Python package which allows you to configure keyring to interact with Python repositories stored in Artifact Registry.The backend automatically searches for credentials from the environment and authenticates to Artifact Registry. It looks for credentials in the following order:Google Application Default Credentials.From thegcloudSDK. (i.e., the access token printed viagcloud config config-helper --format='value(credential.access_token)')Hint: You can see which account is active with the commandgcloud config config-helper --format='value(configuration.properties.core.account)'If neither of them exist, an error occurs.To use the keyring backend:Log inOption 1: log in as a service account:(1). Using a JSON file that contains a service account key:$ export GOOGLE_APPLICATION_CREDENTIALS=[path/to/key.json](2). Or usinggcloud:$ gcloud auth application-default loginOption 2: log in as an end user viagcloud:$ gcloud auth loginConfigure twine (.pypirc) and pip (pip.conf) tools to connect to the repository. Use the output from the following command:$ gcloud artifacts print-settings pythonIn your.pypircfile add:[disutils]index-servers=REPOSITORY_ID[REPOSITORY_ID]repository=https://LOCATION-python.pkg.dev/PROJECT_ID/REPOSITORY_ID/In yourpip.conffile add:[global]extra-index-url=https://LOCATION-python.pkg.dev/PROJECT_ID/REPOSITORY_ID/simple/Install thekeyrings.google-artifactregistry-authpackage$ pip install keyrings.google-artifactregistry-authList backends to confirm the installation.$ keyring --list-backendsThe list should includekeyrings.gauth.GooglePythonAuth (priority: 9)keyring.backends.chainer.ChainerBackend (priority: -1)keyring.backends.fail.Keyring (priority: 0)Usage with other toolsUsage withtoxThetoxtoolis a testing and automation tool.Because the credential helper needs to be installedbeforeany private
dependencies are installed, it needs to be bootstrapped into thetoxenvironment via a plugin.To do this, specify thekeyrings.google-artifactregistry-authpackage via therequiresrequirement in yourtox.inifile:[tox]envlist=pyrequires=keyrings.google-artifactregistry-auth[testenv]deps=-r requirements.txtYou can then configure yourrequirement.txtfile to use the Artifact Registry repo as
an extra index, and specify both public and private dependencies:--extra-index-url https://[REGION]-python.pkg.dev/[PROJECT_ID]/[REPOSITORY]/simple

# samplepackage will be installed directly from PyPI
samplepackage
# mypackage will be installed from the Artifact Registry repository
mypackage
Package: keyrings.google-artifactregistry-auth-legacy
Artifact Registry tools for PyPIThis repository contains an alternatekeyringbackend implementation to help with interacting with PyPI Repositories hosted on Artifact Registry.Authenticationkeyrings.google-artifactregistry-auth is a python package which allows you to configure keyring to interact with PyPI repositories stored in Artifact Registry.The backend automatically searches for credentials from the environment and authenticates to Artifact Registry. It looks for credentials in the following order:Google Application Default Credentials.From thegcloudSDK. (i.e., the access token printed viagcloud config config-helper --format='value(credential.access_token)')Hint: You can see which account is active with the commandgcloud config config-helper --format='value(configuration.properties.core.account)'If neither of them exist, an error occurs.To use the keyring backend:Log inOption 1: log in as a service account:(1). Using a JSON file that contains a service account key:`$ export GOOGLE_APPLICATION_CREDENTIALS=[path/to/key.json]`(2). Or using gcloud:`$ gcloud auth application-default login`Option 2: log in as an end user via gcloud:`$ gcloud auth login`Configure twine (.pypirc) and pip (pip.conf) tools to connect to the repository. Use the output from the following command:gcloud alpha artifacts print-settings pypiIn your.pypircfile add:[disutils]
index-servers =
	REPOSITORY_ID

[REPOSITORY_ID]
repository: https://LOCATION-pypi.pkg.dev/PROJECT_ID/REPOSITORY_ID/In yourpip.conffile add:[global]
index-url = https://LOCATION-pypi.pkg.dev/PROJECT_ID/REPOSITORY_ID/simple/Install the keyrings.google-artifactregistry-auth packagepip install keyrings.google-artifactregistry-authList backends to confirm the installation.`keyring --list-backends`The list should include-`ChainerBackend(priority:10)`
-`GooglePyPIAuth(priority:9)`
Package: keyrt
KeyRTНе знаю, зачем тебе может понадобиться автоматизация открытия дверей и выдачи кодов,
но это твоё право, я даю тебе удобный инструмент для его реализации. Да здравствует питон.Установкаpython-mpipinstall-UkeyrtИспользованиеОткрытие двериfromkeyrtimportKeyRTasyncdefmain():keyrt_client=KeyRT(access_token='YOUR_ACCESS_TOKEN')# Список устройств: домофон, шлагбаум, воротаdevices=awaitkeyrt_client.get_devices()fori,deviceinenumerate(devices):example=devices[i]assertexampleisdeviceexample=devices[device.]assertawaitkeyrt_client.open_device(devices[0].id)# Камерыcameras=awaitkeyrt_client.get_cameras()
Package: keys
This repository contains the Python tools for the Sapphire wireless platform.Contents/apiserver- REST API server/automaton- Python automation API/buildtools- Sapphire Operating System build tools/core- Key-value server system core/devices- Sapphire hardware device driver/deviceserver- Key-value server module for Sapphire devices/tftp- Generic TFTP clientLicense InformationThe contents of this repository are released under the Mozilla Public License, v. 2.0.Seehttp://mozilla.org/MPL/2.0/for more information.
Package: keysafe
keysafeKeyring-based utilitiy for enhanced safekeeping of login information.Many websites require user's email address as a user login id. You may want to avoid accidentally revealing these addresses, especially if your scripts are hosted publicly.keysafeprovides a way to hide not only the passwords but also the user id's by using aliases instead. The actual login info is saved in the keychain and retrieved using the standardkeyringlibrary.In other words, keys themselves are hidden in a safe.Examples of use:Create a record>>>from keysafe import safe>>>x=safe()>>>x.service='MYSAFE'>>>x.alias='John'>>>x.user='john@mail.com'>>>x.password='$WhoopsyDaisies01'>>>x.set()Retreive user id and passwrod>>> y=safe()>>> y.service='MYSAFE'>>> y.alias='John'>>> y.get()>>> y.user'john@mail.com'>>> y.password'$WhoopsyDaisies01'
Package: keyserver
KeyServer==================Command line Pub key generator from keyserver.ubuntu.com<pre>usage: keyserver.py [-h] [-k KEY] [-c] [-f FILENAME]optional arguments:-h, --help            show this help message and exit-k KEY, --key KEY     Key number for search pub key-c, --copy            Copy pub key result to clipboard-f FILENAME, --file FILENAMEStore pub key result to file</pre>::pip install keyserverExample-------Command line~~~~~~~~~~~~**Get key**::$ keyserver -k 3B4FE6ACC0B21F32 -f key1$ apt-key add key1**Get key and Copy it to clipboard**::$ keyserver -k 3B4FE6ACC0B21F32 -f key1 -c$ apt-key add key1License-------MIT
Package: keyserver-ng
Key server with email and key validation.Why?All available keyservers allow to upload any public key without
any validation/confirmaion.This keyserver sends encrypted email with confirmation link
to public key owner. Public key will be added to database only
if owner retrieve this email, decrypt it, and open confirmaion
link in the browser.How?InstallationTo install in debian based GNU/Linux:$ sudo apt-get install python3-pip libgpgme11-dev
$ sudo pip3 install keyserver-ngConfigurationSelf documented configuration file can be found in /etc/keyserver-ng.iniRunningUpstart script:$ sudo cp /etc/keyserver-ng/upstart.conf /etc/init/keyserver-ng.conf
$ sudo service keyserver-ng startRun in foreground:$ sudo keyserver-ng /etc/keyserver-ng/config.iniCurrent statusImplementedUpload key/Confirm keyFetch keyNot implemented yetSearch keyUpdate keySendmail mailerDump DB/Load DB