Saravanan666/pypi-org huggingface dataset:
Package: hatch-containers
hatch-containersCI/CDPackageMetaThis provides a plugin forHatchthat allows the use of containerizedenvironments.Table of ContentsInstallationConfigurationPythonImageCommandStartupShellNotesFutureLicenseInstallationpip install hatch-containersConfigurationTheenvironment pluginname iscontainer.pyproject.toml[tool.hatch.envs.<ENV_NAME>]type="container"hatch.toml[envs.<ENV_NAME>]type="container"PythonIf thePython versionis set to a multi-character integer like310then it will be interpreted as its<MAJOR>.<MINOR>form e.g.3.10.If not set, then the<MAJOR>.<MINOR>version of the firstpythonfound along yourPATHwill be used, defaulting to the Python executable Hatch is running on.ImageTheimageoption specifies the container image to use e.g.python:alpine. It recognizes the placeholder value{version}which will be replaced by the value of thePython option.Default:[envs.<ENV_NAME>]image="python:{version}"CommandThecommandoption specifies the command that the container will execute whenstarted.Default:[envs.<ENV_NAME>]command=["/bin/sleep","infinity"]StartupBy default, containers will be started automatically whenenteredor whenrunning commandsand will be stopped immediately after. If you want containers to start automatically uponcreationand not be stopped untilremoval, you can setstart-on-creationtotrue.Default:[envs.<ENV_NAME>]start-on-creation=falseShellTheshelloption specifies the executable that will be used whenenteringcontainers. By default, this is set to/bin/bashunlessalpineis in theimagename, in which case/bin/ashwill be used instead.NotesThere must be adockerexecutable along yourPATH.Theenv-excludeenvironment variable filterhas no effect.FutureSupport for Windows containersSupport for building imagesLicensehatch-containersis distributed under the terms of theMITlicense.
Package: hatch-datadog-build-metadata
hatch-datadog-build-metadataCI/CDPackageMetaThis provides a plugin forHatchthat injects metadata from your preferred version control system like Git.Table of ContentsGlobal dependencyMetadata hookMetadata hook optionsURLsExampleLicenseGlobal dependencyEnsurehatch-datadog-build-metadatais defined within thebuild-system.requiresfield in yourpyproject.tomlfile.[build-system]requires=["hatchling","hatch-datadog-build-metadata"]build-backend="hatchling.build"Metadata hookNote:only Git is supportedThemetadata hook pluginname isdatadog-build-metadata.pyproject.toml[tool.hatch.metadata.hooks.datadog-build-metadata]Metadata hook optionsURLsTheurlsoption is equivalent toproject.urlsexcept that each URL supportscontext formattingwith the following fields:commit_hash- the latest commit hashremote_url- the raw remote URL as stored in VCS configremote_http_url- theremote_urlconverted to an HTTP(S) URLBe sure to addurlstoproject.dynamic:pyproject.toml[project]dynamic=["urls",]By default, the following URLs are set:source_code_link->{remote_http_url}#{commit_hash}ExampleThe following example assumes that the code is hosted by GitHub.pyproject.toml[tool.hatch.metadata.hooks.datadog-build-metadata]Homepage="https://www.example.com"source_archive="{remote_http_url}/archive/{commit_hash}.tar.gz"hatch.toml[metadata.hooks.datadog-build-metadata]Homepage="https://www.example.com"source_archive="{remote_http_url}/archive/{commit_hash}.tar.gz"Licensehatch-datadog-build-metadatais distributed under the terms of theMITlicense.
Package: hatch-dependency-coversion
hatch-dependency-coversionThis is a plugin forHatchthat allows you to rewrite the versions in selected dependency specifiers to be exactly the same as the current version of the project configured inpyproject.toml's[project]table, requiring exact coversioning of those dependencies with the project.This is useful for projects that are developed in lockstep but distributed as independent python packages rather than as subcomponents of the same namespace package. It is the equivalent of the followingsetup.py:VERSION='1.0.0'setup(name='my-project',version=VERSION,install_requires=[f'my-dependency=={VERSION}'])Minimal configuration is done in yourpyproject.tomllike this:[build-system]# Since this is a plugin for hatchling, you must be using hatchling as your build backendrequires=["hatchling","hatch-dependency-coversion"]build-backend="hatchling.build"[project]name="my-project"version="0.1.0"dependencies=[# 0.0.0 is chosen at random and will be overwritten"my-dependency==0.0.0"][tool.hatch.metadata.hooks.dependency-coversion]# this list contains the names of dependencies to overrideoverride-versions-of=["my-dependency"]Table of ContentsOperationUse as a pluginConfigurationLicenseOperationhatch-dependency-coversionis a metadata hook forhatch, or more specifically forhatchling, the PEP-508 build backend written by thehatchteam. Whenever a package that useshatch-dependency-coversionis built,hatch-dependency-coversiongets the chance to alter the list of dependencies the package will specify as required, and thatpipand other installers or environment creators use to determine what dependencies to install.Only those dependencies identified by name in thetool.hatch.metadata.hooks.dependency-coversion.override-versions-oflist will have their versions overridden; nothing else will be touched.Any PEP-440 version specifiers other than the version are left untouched; you can usehatch-dependency-coversionon dependencies that are optionally installed with markers (i.e. withos_name == 'Windows'or similar) and the markers will be preserved.PluginEnsurehatch-dependency-coversionis listed in thebuild-system.requiresfield in yourpyproject.toml:[build-system]requires=["hatchling","hatch-dependency-coversion"]build-backend="hatchling.build"Configurationhatch-dependency-coversionis configured throughpyproject.tomlas a metadata hook in a similar way to other hatch plugins. Its plugin name isdependency-coversion:[tool.hatch.metadata.hooks.dependency-coversion]override-versions-of=["dependency1","dependency2"]Theoverride-versions-ofkey is the only configuration thathatch-dependency-coversiontakes. It is a list of strings, each of which should be the package name (the same thing you'd pass topipor list in a dependency specifier) of one of the dependencies. Anything in here that is not in the top levelproject.dependencieskey is ignored.Licensehatch-dependency-coversionis distributed under the terms of theApache-2.0license.
Package: hatch-docstring-description
UsageInclude it as a plugin to yourpyproject.toml:[build-system]requires=["hatchling","hatch-docstring-description"]build-backend="hatchling.build"Mark yourdescriptionfield asdynamic:[project]dynamic=["description"]Licensehatch-docstring-descriptionis distributed under the terms of theGPL 3 (or later)license.
Package: hatch-fancy-pypi-readme
Your ✨Fancy✨ Project Deserves a ✨Fancy✨ PyPI Readme!hatch-fancy-pypi-readmeis an MIT-licensed metadata plugin forHatchbyHynek Schlawack.Its purpose is to help you to have fancy PyPI readmes – unlikethisone you’re looking at right now.Please check out thedocumentationto see whathatch-fancy-pypi-readmecan do for you and your projects!
Package: hatch-flex
Hatch plugin to customize build dependenciesSimple Hatch plugin to customize dependencies
according to whether the build iseditableorstandard.
This may be useful for example in mono-repo projects
where sub-projects need to be installed manually,
from the local repo, and not the pypi index.
In this case you can add dependencies to thestandarddependencies that will be used only
when building wheels.UsageYou can specifyeditable-dependenciesfor editable installs
andstandard-dependenciesfor other builds in the[tool.hatch.build.hooks.flex]section of thepyproject.toml.
These dependencies, according to the build type, will be added
to the dependencies already declared in the project section.[build-system]
requires = ["hatchling", "hatch-flex"]
build-backend = "hatchling.build"

[tool.hatch.build.hooks.flex]
editable-dependencies = [...]
standard-dependencies = [...]Related Projects & ResourceshatchModern, extensible Python project managementissue 588Support for Editable DependenciesChanges0.0.1Initial release0.0.2Added config type checking
Package: hatching-triage
Usagetriage.Client__init__token: Stringroot_url:Stringdefault:https://api.tria.gesubmit_sample_filefilename: Stringfile: Fileinteractive: Booleandefault: Falseprofiles: String[]default: []Return JSONhttps://tria.ge/docs/cloud-api/samples/#submitting-a-filesubmit_sample_urlurl: Stringinteractive: Booleandefault: Falseprofiles: String[]default: []Return JSONhttps://tria.ge/docs/cloud-api/samples/#submitting-a-urlset_sample_profilesample_id: Stringprofiles: String[]Return JSON{}set_sample_profile_automaticallysample_id: Stringpick: String[]default: []Return JSON{}owned_samplesmax: Intdefault: 20Return Paginatorhttps://tria.ge/docs/cloud-api/samples/#get-samplespublic_samplesmax: Intdefault: 20Return Paginatorhttps://tria.ge/docs/cloud-api/samples/#get-samplessearch_samplesquery: Stringmax: Intdefault: 20Return Paginatorhttps://tria.ge/docs/cloud-api/samples/#get-samplessample_by_idsample_id: StringReturn JSONhttps://tria.ge/docs/cloud-api/samples/#get-samplessampleiddelete_samplesample_id: StringReturn JSON{}static_reportsample_id: StringReturn JSONhttps://tria.ge/docs/cloud-api/samples/#get-samplessampleidreportsstaticoverview_reportsample_id: StringReturn JSONhttps://tria.ge/docs/cloud-api/samples/#get-samplessampleidoverviewjsontask_reportsample_id: Stringtask_id: StringReturn JSONhttps://tria.ge/docs/cloud-api/samples/#get-samplessampleidtaskidreport_triagejsonsample_task_filesample_id: Stringtask_id: Stringfilename: StringReturn binary datafile contentssample_archive_tarsample_id: StringReturn binary datafile contentssample_archive_zipsample_id: StringReturn binary datafile contentscreate_profilename: Stringtags: String[]network: String[]Either "internet", "drop" or Nonetimeout: IntReturn JSONhttps://tria.ge/docs/cloud-api/profiles/delete_profileprofile_id: StringReturn JSON{}profilesReturn Paginatorhttps://tria.ge/docs/cloud-api/profiles/sample_eventssample_id: StringReturn JSONhttps://tria.ge/docs/cloud-api/samples/#get-samplesevents
Package: hatch-jupyter-builder
hatch-jupyter-builderThis provides abuild hookplugin forHatchthat adds a build step for use with Jupyter packages.Table of ContentsDocumentationInstallationLicenseUsage and ConfigurationLocal DevelopmentDocumentationThe full documenation is available onRead The Docs.Installationpip install hatch-jupyter-builderLocal DevelopmentTo test this package locally with another package, use the following:[tool.hatch.build.hooks.jupyter-builder]dependencies=["hatch-jupyter-builder@file://<path_to_this_repo>"]Skipping the BuildYou can skip the build by setting theSKIP_JUPYTER_BUILDERenvironment
variable.MigrationThis library can be used to migrate from asetuptoolsbased package to
usehatch_jupyter_builder. It will attempt to migratejupyter-packagingconfig as well, if present.To migrate, run the following:python-mhatch_jupyter_builder.migrate.The migration script will do most of the migration automatically, but
will prompt you for anything it cannot do itself.To compare dist files with a reference checkout, run the following:python-mhatch_jupyter_builder.compare_migration<source_dir><target_dir>sdistThe migration scripts can also be used without installation, usingpipx, e.g.:pipxhatch_jupyter_buildermigrate.Usewheelto compare wheel file contents.See thedocumentation for more information on migrationfor more details.Licensehatch-jupyter-builderis distributed under the terms of theMITlicense.
Package: hatchling
HatchlingPackageMetaThis is the extensible, standards compliant build backend used byHatch.UsageThe following snippet must be present in your project'spyproject.tomlfile in order to use Hatchling as your build backend:[build-system]requires=["hatchling"]build-backend="hatchling.build"Then a build frontend likepip,build, or Hatch itself can build or install your project automatically:#installusingpippip install /path/to/project#buildpython -m build /path/to/project#buildwithHatchhatch build /path/to/projectDocumentationProject metadataDependenciesPackaging
Package: hatch-modulefile
hatch_modulefileThis provides automatic modulefile generation forEnvironmentModules. Modulefiles are created with a basic template which:Loads any modules listed inrequiresSources the activate script of the installed packages (assumes venv installation)Sets extra environment variables defined in extra-pathsTable of ContentsInstallationExampleLicenseInstallationpip install hatch-modulefileExampleExample use case. Note that requires is a list of modulefiles available on your system
through environment modules. Extra paths defines modulefile environment manipulations.[build.hooks.modulefile]
requires = [
"module1/1.0.0",
"module2/3.1.2",
"module3/2.0.0",
]
extra-paths = [
{ type="setenv", variable="NUMEXPR_MAX_THREADS", value="8" },
{ type="prepend-path", variable="PATH", value="/custom/path" },
]This would generate a modulefile which looks like this:#%Module

# Gets the folder two folders up from this file
set              venv                    [file dirname [file dirname [file dirname [file normalize $ModulesCurrentModulefile/___]]]]
set              site_packages           [glob $venv/lib/python*/site-packages]

set     necessary       {
  module1/1.0.0
  module2/3.1.2
  module3/2.0.0
}

foreach mod $necessary {
    set splitList [split $mod "/"]
    set mod_name [lindex $splitList 0]
    if { [ is-loaded $mod_name ] } {
        module switch $mod
    } else {
        module load $mod
    }
}

if { [module-info mode load] || [module-info mode switch2] } {
    puts stdout "source $venv/bin/activate;"
} elseif { [module-info mode remove] && ![module-info mode switch3] } {
    puts stdout "deactivate;"
}

# Extra module path requirements
setenv          NUMEXPR_MAX_THREADS     8
prepend-path    PATH                    /custom/pathLicensehatch-modulefileis distributed under the terms of theMITlicense.
Package: hatch-msgfmt
hatch-msgfmtA hatch msgfmt plugin, simply replacing all po files with mo files, using msgfmt inPATH.At a future point, a pure-python version could be implemented, by implementing
a pure-Python version of msgfmt.  [The standard cpython msgfmt.py](https://
github.com/python/cpython/blob/main/Tools/i18n/msgfmt.py) could be a starting
point for this, but it's not as capable as GNU Gettext, and doesn't support
plural forms.  Even with a fresh implementation, handling the file encoding
from the header is challenging, especially for variable-length encodings like
EUC-JP, which could feasibly cause particular problems.Better to just use the system one for now.  If somebody wants to submit a pure-
python implementation that functions, I'll gladly integrate it as a separatemsgfmtpyplugin in the same repository.Config parameterslocales: The location of the source.pofiles.destination: The location of the destination.mofiles.  They will be put
into this location in the same structure as the source tree relative to thelocalespath.pathsub_regex(optional): An input regex to match against source files for
name changes.pathsub_replace(required ifpathsub_regexis present): An replacement
pattern to use for name changes.CopyrightThis plugin is Copyright 2023 Absolute Performance, Inc. with contributions byAdrián Chaves.MIT licensed.
Package: hatch-mypyc
hatch-mypycCI/CDPackageMetaThis provides abuild hookplugin forHatchthat compiles code withMypyc.Table of ContentsConfigurationFile selectionMypy argumentsOptionsMissing typesLicenseConfigurationThebuild hook pluginname ismypyc.pyproject.toml[tool.hatch.build.targets.wheel.hooks.mypyc]dependencies=["hatch-mypyc"]hatch.toml[build.targets.wheel.hooks.mypyc]dependencies=["hatch-mypyc"]File selectionBy default, all files included using thestandard file selection optionswith a.pyextension will be targeted. You can narrow what files to compile to an even smaller subset with theinclude/excludeoptions, which representGit-style glob patterns.[build.targets.wheel.hooks.mypyc]include=["/src/pkg/server"]exclude=["__main__.py"]Mypy argumentsYou can specify extraMypy argumentswith themypy-argsoption.[build.targets.wheel.hooks.mypyc]mypy-args=["--disallow-untyped-defs",]OptionsYou can specifyoptionsthat affect the behavior ofmypycify.[build.targets.wheel.hooks.mypyc.options]opt_level="3"Note:thetarget_diroption is used internally and therefore has no effectMissing typesIf you need more packages at build time in order to successfully type check, you can use the following options where youconfigured the plugin:dependencies- add more dependencies alongsidehatch-mypycrequire-runtime-dependencies- set totrueto include dependencies defined in theproject.dependenciesarrayrequire-runtime-features- set to an array of named dependency groups that are defined inproject.optional-dependenciesLicensehatch-mypycis distributed under the terms of theMITlicense.
Package: hatch-nodejs-version
hatch-nodejs-versionThis package provides two Hatch plugins:version source pluginthat reads/writes the package version
from theversionfield of the Node.jspackage.jsonfile.metadata hook pluginthat reads PEP 621 metadata from the
Node.jspackage.jsonfile.Table of ContentsInstallationGlobal dependencyVersion sourceMetadata hookLicenseGlobal dependencyEnsurehatch-nodejs-versionis defined within thebuild-system.requiresfield in yourpyproject.tomlfile.[build-system]requires=["hatchling","hatch-nodejs-version"]build-backend="hatchling.build"Version sourceTheversion source pluginname isnodejs.pyproject.toml[tool.hatch.version]source="nodejs"hatch.toml[version]source="nodejs"SemverThe semver specification defines the following version sections:majorminorpatchpre-releasebuildMeanwhile,PEP 440defines:epochmajorminorpatchpre-releasepost-releasedev-releaseIn order to ensure contentful round-trip support, and ensure semantic consistency between Node.js and Python, this plugin only
accepts the common version parts:majorminorpatchpre-releasee.g.1.2.3-rc0.Note that where normalisation occurs, the round-trip result will differ. This can be avoided by careful choice of the delimeters e.g.-..Version source optionsOptionTypeDefaultDescriptionpathstrpackage.jsonRelative path to thepackage.jsonfile.Metadata hookThemetadata hook pluginname isnodejs.pyproject.toml[tool.hatch.metadata.hooks.nodejs]hatch.toml[metadata.hooks.nodejs]Metadata hook optionsOptionTypeDefaultDescriptionpathstr"package.json"Relative path to thepackage.jsonfile.fieldslistofstrNoneOptional list ofpyproject.tomlfields to take from their counterparts inpackage.json. If missing, take all of the available fields.contributors-as-maintainersboolTrueWhether contributors inpackage.jsonshould be considered maintainers (otherwise, treat them as authors).bugs-labelstr"Bug Tracker"The key in the URLs table ofpyproject.tomlthat is populated by thebugsfield inpackage.jsonhomepage-labelstr"Homepage"The key in the URLs table ofpyproject.tomlthat is populated by thehomepagefield inpackage.jsonrepository-labelstr"Repository"The key in the URLs table ofpyproject.tomlthat is populated by therepositoryfield inpackage.jsonLicensehatch-nodejs-versionis distributed under the terms of theMITlicense.
Package: hatch-odoo
hatch-odooAhatch(ling) plugin to work with projects containing
Odoo addons. This tool will help you package a project containing Odoo addons so it can
be installed with pip:automatically generates dependencies based on Odoo addons manifests,package addons into the odoo/addons namespace independently of the source project
layout,install the addons in editable mode without fiddling with--addons-path,Table of Contentshatch-odooQuick startAlternative project layoutsLicenseQuick startAssuming you have a project containing your awesome Odoo addons at the root of your
project repository, you can set it up by creating apyproject.tomlfile like so.# Use the hatchling build backend, with the hatch-odoo plugin.[build-system]requires=["hatchling","hatch-odoo"]build-backend="hatchling.build"[project]name="MyAwesomeProject"version="1.0"readme="README.md"# Dependencies are dynamic because they will be generated from Odoo addons manifests.dynamic=["dependencies"]# Enable the hatch-odoo metadata hook to generate dependencies from addons manifests.[tool.hatch.metadata.hooks.odoo-addons-dependencies]# Enable the hatch-odoo build hook to package the Odoo addons into odoo/addons.[tool.hatch.build.hooks.odoo-addons-dirs][tool.hatch-odoo]# If our addons have non standard version numbers, let's help hatch-odoo discover the Odoo version.odoo_version_override="15.0"# Let's add additional dependencies that are not declared in addons manifests.dependencies=["click-odoo-contrib"]# Our addons are in the project root directory.addons_dirs=["."]You can then install it together with its dependencies in a virtual environment with a
procedure like this:#python3-mvenv.venv#.venv/bin/activate#pipinstall--upgradepipsetuptoolswheel#pipinstall-rhttps://raw.githubusercontent.com/odoo/odoo/15.0/requirements.txt#pipinstall-egit+https://github.com/odoo/odoo@15.0#pipinstall-e.#odooAll dependencies (such as OCA addons and external dependencies) declared in your project
addons manifests will be downloaded and installed from PyPI automatically.There is no need to configure addons path, since the addons are installed inodoo/addons, the regular Python import machinery works out of the boxYou can then pin dependencies for reproducibility withpip freezeor other tools.pip-deepfreezeis known to work well with
git URLs, but other tools such aspip-tools, may work as well.Alternative project layoutsDepending on your tastes and requirements, there are several alternative ways to
organize your source code. The test projects intests/dataeach have a
README that describe the layout and corresponding tradeoffs, with the correspondingpyproject.toml.Licensehatch-odoois distributed under the terms of theMITlicense.