Saravanan666/pypi-org huggingface dataset:
Package: poetry-cdk-plugin
Poetry CDK pluginProvides CDK CLI commandssynth,deployanddestroywith basic and default options.This plugin removes the need to manage SHELL commands to perform basic CDK CLI commands.PrerequisitesCDK CLIPython^3.9Poetry^1.3InstallationUse pip to install the package:pip install poetry-cdk-pluginUsageFrom a valid CDK codebase root directory, where Poetry is used, type:poetry cdk synth: to run cdk synth of your CDK applicationpoetry cdk deploy: to run cdk deploy of your CDK application (without approval)poetry cdk destroy: to run cdk destroy of your CDK application (with force option)RoadmapAdd acdk lambda packagecommand to provide a ZIP forCDK Lambda constructand itsfrom_assetfeature
Package: poetry-chuy-plugin
Poetry Chuy PluginThis plugin integratesChuywithPoetry.Note: This only works in Poetry 1.2.0 or superior.InstallationFrom your terminal:poetrypluginaddpoetry-chuy-pluginConfigurationIn yourpyproject.toml:[tool.chuy]format="poetry run black ."lint="poetry run pylint chuy tests"tests="poetry run pytest"package="poetry build && poetry publish"UsagepoetrychuytestsOr pass multiple arguments:poetrychuytestslintSeeChuyfor all the options.LicenseThis project is licensed under theMIT License.
Package: poetry-ci-updater
Poetry CI UpdaterThis package is intended to help integrating poetry with your CI.It will create a new branch where it will push the updated poetry.lock to.
If your git provider is supported, it will also create a pull/merge request.InstallationPypipoetry add --dev poetry-ci-updaterGitpoetryadd--devgit+https://github.com/MarcoGlauser/poetry-ci-updater@masterUsageGitlabBecause Gitlab currently can't write to the repository with the $CI_JOB_TOKEN, you will need
to define a secret enviroment variable  with the name PERSONAL_ACCESS_TOKEN.update-dependencies:stage:buildimage:python:3.8before_script:-git config user.email "{$GITLAB_USER_EMAIL}"-git config user.name "${GITLAB_USER_NAME}"script:-pip install poetry-git remote rm origin-git remote add origin https://gitlab-ci-token:${PERSONAL_ACCESS_TOKEN}@${CI_SERVER_HOST}:${CI_SERVER_PORT}/${CI_PROJECT_PATH}.git-CI_JOB_TOKEN=${PERSONAL_ACCESS_TOKEN} poetry run poetry-ci-updaterrules:-if:$CI_PIPELINE_SOURCE == "schedule"TODOGithub Actions supportTestsProvider OptionsKeep update branch up to date
Package: poetry-codeartifact-login
Poetry AWS CodeArtifact LoginA Poetry plugin for authenticating with AWS CodeArtifact.Requirementspoetry >= 1.2.0Install using the dedicated installation script. Seehere.AWS CLI v2Seeherefor installation guide.Intallationpoetry self add poetry-codeartifact-loginUsageAWS credentials will need to be configured on the system prior to usage. Typically this is done using theaws configurecommand and/or directly modifying the configuration files. Seeherefor more info. They can also be set throughenvironment variables, which will take precedence over any configuration file values.Once credentials have been configured, you can log in to CodeArtifact:poetry aws-login <source_name>Assuming the credentials are configured properly and the identity they belong to has proper permissions,poetrywill be configured with a short-lived authentication token that will automatically be used for installation of any packages in the authenticated source. Seeherefor more information on working with private repositories throughpoetry.If want to log in with a profile other than the default, you can do:poetry aws-login <source_name> --profile <profile_name>CLI Referencepoetry aws-login --help
Package: poetry-codeartifact-login-plugin
poetry-codeartifact-login-pluginThis is a plugin forPoetrythat allows poetry to obtain and use login credentials for
an AWS CodeArtifact repository.BackgroundCodeArtifact is AWS's solution for hosting Python packages (and other languages). Users must authenticate with
CodeArtifact using http-basic authentication (anonymous access is not supported). Users can obtain the necessary
credentials by using the AWS CLI. A user who is properly authenticated with AWS can obtain a login token for
CodeArtifact that will expire after a certain amount of time (by default, 12 hours). This plugin allows Poetry to
automatically obtain and use these credentials.DependenciesThis plugin depends on the AWS CLI being installed on the search $PATH. The AWS CLI must be properly configured
with the necessary credentials and region.SetupUpdate your project'spyproject.tomlfile to include your CodeArtifact repository as a source for packages.
For example,[[tool.poetry.source]]name="MyRepository"url="https://mydomain-1234567890123.d.codeartifact.us-west-2.amazonaws.com/pypi/my-repository/simple/"default=trueNext, add a[tool.poetry_codeartifact_login]section to yourpyproject.tomlfile. For each CodeArtifact
repository in your list of sources, add a corresponding[[tool.poetry_codeartifact_login.source]]section.
For example,[tool.poetry_codeartifact_login][[tool.poetry_codeartifact_login.source]]name="MyRepository"domain="mydomain"domain_owner="1234567890123"aws_profile="developer-profile"ConfigurationEach[[tool.poetry_codeartifact_login.source]]section has the following fields:name: This must match the name of the source as defined in the corresponding[[tool.poetry.source]]section.domain: The name of the domain of the CodeArtifact repository.domain_owner: The AWS account number that owns the domain.aws_profile: (OPTIONAL) The name of the AWS profile to use when obtaining credentials. If not provided,
the default profile will be used.UsageOnce the plugin is installed, and a project configured with the necessarypyproject.tomlsettings, poetry will
automatically attempt to refresh the CodeArtifact login token before each operation that requires it. If
all works as expected, you should not need to do anything else.ArchitectureThe plugin registers a hook that runs prior to each operation that requires a login token. The hook checks if the
is valid, unexpired token is already available. If not, the plugin runs theaws codeartifact get-authorization-tokencommand to obtain a new token, and stores it in the poetry configuration for the corresponding repository.The plugin uses the standard poetry functionality for storage and management of credentials. Poetry will
attempt to use a platform-specific keyring to store the credentials, if available. Otherwise, the credentials
will be stored in a poetry configuration flatfile on disk. Refer to thepoetry documentationfor more information.
Package: poetry-codeartifact-plugin
poetry-codeartifact-pluginThis Poetry plugin automatically refreshes your authorization token when working with CodeArtifact repositories.InstallationRun this to install the plugin:poetry self add poetry-codeartifact-pluginAnd to remove:poetry self remove poetry-codeartifact-pluginUsageNo configuration or workflow changes are needed. If the plugin detects a HTTP 401 or 403 from a CodeArtifact URL, it will refresh your authorization token and retry the request.This assumes that your local AWS creds are up-to-date -- if not, your command will still fail.Adding a CodeArtifact repositoryAdd this snippet to your project'spyproject.toml:[[tool.poetry.source]]name="codeartifact-pypi"# arbitrary, just don't reuse repository names between CodeArtifact reposurl="https://DOMAIN-123412341234.d.codeartifact.us-west-2.amazonaws.com/REPO/pypi/simple/"# get this URL from your CodeArtifact dashboard or the GetRepositoryEndpoint API callLearn more about Poetry repositories here:https://python-poetry.org/docs/repositories/
Package: poetry-commit-date-versioning
poetry-commit-date-versioningDate-based versioning for Poetry projects. Reads the commit date and sha from
git and uses it to set the project version. Nothing else. No attempt is made to
work with anything other than git.To use:poetry self add poetry-commit-date-versioningIn pyproject.toml add a stanza to enable the plugin for a given project[tool.poetry-commit-date-versioning]
enable = trueYou can optionally indicate whether the plugin should generate zero-padded
version segments or pep440 canonicalized segments. With padding, version number
segments are left-padded with zeros to extend to the maximum possible width of
the field. For example a version number including the month of January 1980
would be padded to start with1980.01. With canonicalization that same version
number would be1980.1. By default, pep440 canonicaization is used but padding
can be enabled with theversion-styleconfiguration field. This field accepts
one of two values:"pep440-canonicalized"or"zero-padded"[tool.poetry-commit-date-versioning]
enable = true
version-style = "zero-padded"As the version number is not written into source code files anywhere, we
suggest usingimportlibto determine your module's version number.from importlib import metadata

__version__ = metadata.version(__name__)This project was created as an alternative topoetry dynamic
versioningbecause
it rewrites the pyproject.toml file with every invocation (even if nothing
has changed) and is thus incompatible with a development process that uses
pyproject.toml file in Makefile dependencies.poetry date versioning
pluginwhich may be
abandoned and incomplete and which is definitely centered around writing
version numbers into python source files.
Package: poetry-conda
poetry-conda pluginThis plugin allows the installation of Poetry into Conda environments other thanbaseand enables it to create
virtual environments for your projects without polluting the Conda environment where it is installed.It works with any combination of Python 3.8+ and Poetry 1.3+.InstallationInside a Conda environment, install the plugin usingpip:pipinstallpoetry-condaUsageThis plugin adds the Poetry settingvirtualenvs.ignore-conda-envwith a default value oftrue. When set totrue,
Poetry will ignore Conda environments when creating virtual environments for your projects.You can change this setting locally or globally the same way you would change any other Poetry setting, including through:thepoetry configcommandPoetry environment variablesthepoetry.tomlfilethepypoetry/config.tomlfileContributingContributions to this project are welcome. Please fork this repository, make your changes, and submit a pull request.LicenseThis project is licensed under the terms of the MIT license.
Package: poetry-core
Poetry CoreAPEP 517build backend implementation developed forPoetry. This project is intended to be a lightweight, fully compliant,
self-contained package allowing PEP 517-compatible build frontends to build Poetry-managed projects.UsageIn most cases, the usage of this package is transparent to the end-user as it is either used by Poetry itself
or a PEP 517 frontend (eg:pip).In order to enable the use ofpoetry-coreas your build backend, the following snippet must be present in your
project'spyproject.tomlfile.[build-system]requires=["poetry-core"]build-backend="poetry.core.masonry.api"Once this is present, a PEP 517 frontend likepipcan build and install your project from source without the need
for Poetry or any of its dependencies (besidespoetry-core).# install to current environmentpipinstall/path/to/poetry/managed/project# build a wheel packagepipwheel/path/to/poetry/managed/projectWhy is this required?Prior to the release of version1.1.0, Poetry was a project management tool that included a PEP 517
build backend. This was inefficient and time consuming when a PEP 517 build was required. For example,
bothpipandtox(with isolated builds) would install Poetry and all dependencies it required. Most of these
dependencies are not required when the objective is to simply build either a source or binary distribution of your
project.In order to improve the above situation,poetry-corewas created. Shared functionality pertaining to PEP 517 build
backends, including readingpyproject.tomland building wheel/sdist, were implemented in this package. This
makes PEP 517 builds extremely fast for Poetry-managed packages.
Package: poetry-core-donotuse
Poetry CoreAPEP 517build backend implementation developed forPoetry. This project is intended to be a light weight, fully compliant,
self-contained package allowing PEP 517 compatible build frontends to build Poetry managed projects.UsageIn most cases, the usage of this package is transparent to the end-user as it is either made use by Poetry itself
or a PEP 517 frontend (eg:pip).In order to enable the usepoetry-coreas your build backend, the following snippet must be present in your
project'spyproject.tomlfile.[build-system]requires=["poetry-core"]build-backend="poetry.core.masonry.api"Once this is present, a PEP 517 frontend likepipcan build and install your project from source without the need
for Poetry or any of it's dependencies.# install to current environmentpipinstall/path/to/poetry/managed/project# build a wheel packagepipwheel/path/to/poetry/managed/projectWhy is this required?Prior to the release of version1.1.0, Poetry was a build as a project management tool that included a PEP 517
build backend. This was inefficient and time consuming in majority cases a PEP 517 build was required. For example,
bothpipandtox(with isolated builds) would install Poetry and all dependencies it required. Most of these
dependencies are not required when the objective is to simply build either a source or binary distribution of your
project.In order to improve the above situation,poetry-corewas created. Shared functionality pertaining to PEP 517 build
backends, including reading lock file,pyproject.tomland building wheel/sdist, were implemented in this package.  This
makes PEP 517 builds extremely fast for Poetry managed packages.
Package: poetry-creator
Poetry CreatorPoetry Creator is a Python package that makes it super easy to get started with a new Poetry project. It helps you initialize a new project with a basic structure and install some common Python packages that you might need.InstallationTo install Poetry Creator, simply run:pip install poetry-creatorUsageOnce Poetry Creator is installed, you can use it to create a new project like this:poetry-creator my_project_nameThis command will:Create a new directory calledmy_project_name.Initialize a new Poetry project in that directory.Create apyproject.tomlfile with the required dependencies.Initialize a basic FastAPI project structure.Thepyproject.tomlfile includes dependencies for a variety of common Python packages, including:FastAPIUvicornGunicornOpenAI and OpenAI-AsyncRedisBlackTermcolorPython-dotenvWebsocketsAiofilesLoguruWebrtcvadAfter creating the project, Poetry Creator will automatically install these dependencies and then run your new project using Uvicorn.Remember to replace"<your name here> <your email here>"in thepyproject.tomlfile with your actual name and email.ErrorsIf there's a problem during project creation (for example, if the project directory already exists), Poetry Creator will print an error message and exit.
Package: poetry-deps-scanner
Poetry dependencies scanner & gitlab commenterThis project consists of two scripts.One analyses thepoetry.lockandpyproject.tomlfiles
it receives and produces an output listing the outdated
packages.The other takes an input and posts it as a comment on a Gitlab
merge request.Here's how we use them:# .gitlab-ci.ymlscan-deps:stage:testimage:deps-scannerallow_failure:truescript:-scan-deps poetry.lock pyproject.toml | comment-gitlabonly:-merge_requestsThedeps-scannerimage is built from the Dockerfile in this repository.Here's an example of what the output looks like in a merge request for
this repository:Installationpython-mpipinstallpoetry-deps-scannerDependencies analysisThe following snippet is an example output the first script may produce:Name        │ Type   │ Source        │ Message
─────────────┼────────┼───────────────┼───────────────────────────────────────
 command-log │ direct │ xxxxx.itsf.io │ current=1.0.0 -> latest=2.0.0
 coverage    │ direct │ pypi.org      │ current=6.3.2 -> latest=6.4.1
 asgiref     │ trans. │ pypi.org      │ current=3.5.1 -> latest=3.5.2
 grpclib     │ trans. │ github.com    │ Couldn't compare versions.
 requests    │ error  │               │ ValueError (Hello world)TheTypecolumn indicates whether the package is a direct or transitive
dependency, or if there has been an uncaught exception:directmeans the package is a direct dependency.trans.means the package is a transitive dependency: the dependency
of a direct dependency or of a transitive dependency.errormeans there has been an uncaught error. The exception class and message
are displayed in theMessagecolumnThis is computed by using thepyproject.tomlif given. If this file is
not provided on the command line, the column will be empty.A dependency is considered direct if it is present in thepyproject.toml.Gitlab commentThecomment_gitlab.pyscript requires some environment variables
to properly work:BOT_USERNAME: The username for the bot userBOT_TOKEN: A Gitlab access token for the bot user
(seehttps://docs.gitlab.com/ee/user/profile/personal_access_tokens.html)CI_SERVER_URL: The URL of the Gitlab instance where to postCI_PROJECT_ID: The ID of the project containing the MR to post onCI_MERGE_REQUEST_IID: The IID of the merge request to comment onThe last three variables are automatically populated by Gitlab CI when
running a job as part of a detached pipeline (for a merge request). Notice
theonly: [merge_requests]in the.gitlab-ci.ymlabove.Of course, you can also provide them manually to integrate with any other build
system.If a comment from the bot user already exists, it will be replaced,
in order to reduce the noise. In other words, there will be at most one
comment from the bot on a given merge request. It will contain the results of
the latest check.Build the docker image outside ITSFThe Dockerfile inside the repository references images from our internal
Docker registry proxy. You can easily build it on your own by removing
thenexus.itsf.io:5005/prefix.# on Ubuntused-i's/nexus.itsf.io:5005\///g'Dockerfile# on macOSsed-e's/nexus.itsf.io:5005\///g'-i""Dockerfile# thendockerbuild-tdeps-scanner.
Package: poetry-dev
poetry-devWhen developing multiple Python packages concurrently with Poetry manageed environments you
can install the local package as path requirements. Ie when you developbarwhich havefooas dependency, which you also want to edit, you can
dopoetry add ../foofrombarpackage. But when you want to publishbar, you have to change the path requirement back to a version requirement.After publishingbaryou have to switch back tofooas a path requirement
in order to continue develop both concurrently.This package will help you to improve that task. With one command all version
requirements will be changed to path requirements (when the package is
checkout in a sibling directory with the same as the package name).poetry_dev pathThis results in a changedpyproject.tomlfile.poetry updateis called
to make sure the package on the path is installed as editable package.Before publishing, the path requirements can be switched back to version
requirements with the following command.poetry_dev versionThe version of the dependency on the local path will be
used as minimal caret version in the changedpyproject.tomlandpoetry updateis called to make sure the corresponding version
from the repository will be installed.
Package: poetry-dotenv
⚠️WarningThis package has been deprecated and is no longer maintained,poetry-dotenvhas moved topoetry-plugin-dotenv🔮 Overview⚙️ Installation👩🏻‍💻 Usage🔮 Overviewpoetry-plugin-dotenv- is the plugin that automatically loads environment variables from a dotenv file into the environment beforepoetrycommands are run.This plugin doesn't have any dependencies, but therefore it also supports features thatpython-dotenvsupports (e.g. templates, interpolating variables usingPOSIXvariable expansions etc).⚙️ Installationpoetryselfaddpoetry-plugin-dotenv👩🏻‍💻 UsageBy default, plugin will load the.envfile from the current working directory or "higher directories".To preventpoetryfrom loading the dotenv file, set thePOETRY_DONT_LOAD_DOTENVenvironment variable.If your dotenv file is located in a different path or has a different name you may set thePOETRY_DOTENV_LOCATIONenvironment variable.# .env
DB__HOST=localhost
DB__DBNAME=prod
DB__USER=admin
DB__PASSWORD=admin
DB__ENGINE=postgresql://${DB__USER}:${DB__PASSWORD}@${DB__HOST}/${DB__DBNAME}# .env.dev
DB__HOST=localhost
DB__DBNAME=dev
DB__USER=root
DB__PASSWORD=root
DB__ENGINE=postgresql://${DB__USER}:${DB__PASSWORD}@${DB__HOST}/${DB__DBNAME}# main.pyimportosif__name__=="__main__":try:print(f"Host:{os.environ['DB__HOST']!r}")print(f"Name:{os.environ['DB__DBNAME']!r}")print(f"Username:{os.environ['DB__USER']!r}")print(f"Password:{os.environ['DB__PASSWORD']!r}")print(f"Engine:{os.environ['DB__ENGINE']!r}")exceptKeyError:print("Environment variables not set!")poetryrun-vvvpythonmain.py# Loading environment variables from '.env'.# Host: 'localhost'# Name: 'prod'# Username: 'admin'# Password: 'admin'# Engine 'postgresql://admin:admin@localhost/prod'exportPOETRY_DOTENV_LOCATION=.env.dev&&poetryrun-vvvpythonmain.py# Loading environment variables from '.env.dev'.# Host: 'localhost'# Name: 'dev'# Username: 'root'# Password: 'root'# Engine 'postgresql://root:root@localhost/dev'exportPOETRY_DONT_LOAD_DOTENV=1&&poetryrun-vvvpythonmain.py# Not loading environment variables.
Package: poetry-dotenv-plugin
Poetry Dotenv PluginAPoetryplugin that automatically loads environment variables from.envfiles into the environment before poetry commands are run.Supports Python 3.7+$cat.envMY_ENV_VAR='Hello World'$poetryrunpython-c'import os; print(os.environ.get("MY_ENV_VAR"))'HelloWorldThis plugin depends on thepython-dotenvpackagefor its functionality and therefore also supports features thatpython-dotenvsupports. Interpolating variables using POSIX variable expansion for example.OriginsInitial implementation based on the event handler application plugin example in thePoetry docs.Installpoetryselfaddpoetry-dotenv-pluginComing from PipenvIf you are transitioning frompipenvthere shouldn't be much to change with regard to the.envloading. If you were a user ofpipenv's environment variablesto control.envloading then you can use the analogous environment variables listed below.Pipenv env varPoetry env varPIPENV_DOTENV_LOCATIONPOETRY_DOTENV_LOCATIONPIPENV_DONT_LOAD_ENVPOETRY_DONT_LOAD_ENVOverriding existing environment variablesBy default, this plugin will override existing environment variables. This is because this plugin was built to make onboarding for users coming frompipenvas seamless as possible. If you want to prevent existing environment variables from being overridden, you can set thePOETRY_DOTENV_DONT_OVERRIDEenvironment variable totrue.[^1][^1]: See#16for background.
Package: poetry-dummy-greeting
poetry-dummy-greetingSample for testing pythonpoetryCreate a new project:poetry new <project-name>Create a new virtual env:poetry env use <full-path-to-python-executable>Adding dependencies:poetry add <package-name>Adding dependencies in a group:poetry add <package-name1>  <package-name2> --group <group-name>Create requirements frompoetry.lock:poetry export --output requirements.txtRun pytest within poetry VM:poetry run pytest -vBuild:poetry buildPublish:poetry publishConfigure PyPi credentialsbefore publishingInstallationYou can install the package using pip:pip install poetry-dummy-greeting
Package: poetry-dynamic-versioning-plugin
Dynamic versioning plugin for PoetryThis is a Python 3.7+ plugin forPoetry 1.2.0+to enable dynamic versioning based on tags in your version control system,
powered byDunamai.The packagepoetry-dynamic-versioning-pluginhas been merged intopoetry-dynamic-versioning,
under the optional feature namedplugin. Please install that package instead.