Saravanan666/pypi-org huggingface dataset:
Package: setuptools-download
setuptools-downloadsetuptools plugin to download external filesusagethis plugin is intended to be used through setuptools declarative metadata:the value ofdownload_*is an ini-like string with the section being the
filename.file settingsurl(required): url to download the file fromsha256(required): checksum of the downloaded filegroup+marker(optional or required together)group: a name for a mutually exclusive groupmarker: aPEP 508 marker expression(can be specified multiple times)only supports:os_name,sys_platform,platform_machineextract+extract_path(optional or required together)extract: how to extract the downloaded file (ziportar)extract_path: path to extract from archiveexample[options]setup_requires=setuptools-download[setuptools_download]download_data_files=[share/example/data.txt]url=https://example.com/data.txtsha256=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[share/example/embedded]url=https://example.com/release-1.0.tar.gzsha256=bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbextract=tarextract_path=release-v1.0/share/example/embeddeddownload_scripts=[example-tool]group=example-tool-binarymarker=sys_platform = "linux" and platform_machine = "x86_64"url=https://example.com/example-tool-linux-x86-64sha256=ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc[example-tool]group=example-tool-binarymarker=sys_platform = "darwin" and platform_machine = "x86_64"marker=sys_platform = "darwin" and platform_machine = "arm64"url=https://example.com/example-tool-darwin-x86-64sha256=ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd[example-tool.exe]group=example-tool-binarymarker=sys_platform = "win32" and platform_machine = "AMD64"url=https://example.com/example-tool-win32.exesha256=eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
Package: setuptools-dso
setuptools extension for building non-Python Dynamic Shared ObjectsBuilding non-python shared libraries (eg.libY.so,libY.dylib, orY.dll) for inclusion in a Python Wheel.This extension is an alternative to bundling externally built
libraries in Python Wheel packages by providing the means to
replace an external build system (eg. Makefile) so that non-python
libraries to be built from source within the python ecosystem.Documentation athttps://mdavidsaver.github.io/setuptools_dsoGithub projecthttps://github.com/mdavidsaver/setuptools_dsoPYPIhttps://pypi.org/project/setuptools-dso/
Package: setuptools-ext
setuptools-extThis is aPEP 517 Build backend interfacesupporting fields in theCore metadata specificationswhich are otherwise difficult to provide using existing tools.
Specifically, it allows declaring those fields marked with an “—” in the rightmost column of the table below by specifying them in a[tool.setuptools-ext]section ofpyproject.toml.
The backend otherwise functions identically tosetuptools.build_meta, and is in fact a drop-in replacement for the default setuptools build backend.Setuptoolslacks a way to specify some fields, despite their validity in Python package metadata according to the spec.PEP 621 – Storing project metadata in pyproject.tomlappears to have punted on some of the fields too.Fieldsetup.py keywordpyproject.toml nameNamenamenameVersionversionversionDynamic (multiple use)—dynamicPlatform (multiple use)platforms—Supported-Platform (multiple use)——SummarydescriptiondescriptionDescriptionlong_descriptionreadmeDescription-Content-Typelong_description_content_typereadmeKeywordskeywordskeywordsHome-pageurl[project.urls]Download-URLdownload_url—AuthorauthorauthorsAuthor-emailauthor_emailauthorsMaintainermaintainermaintainersMaintainer-emailmaintainer_emailmaintainersLicenselicense / license_fileslicenseClassifier (multiple use)classifiersclassifiersRequires-Dist (multiple use)install_requiresdependenciesRequires-Pythonpython_requiresrequires-pythonRequires-External (multiple use)——Project-URL (multiple-use)project_urls[project.urls]Provides-Extra (multiple use)extras_require[project.optional-dependencies]Provides-Dist (multiple use)——Obsoletes-Dist (multiple use)——Reference links for the info above:SetuptoolskeywordsandNew and Changedsetup()KeywordsDeclaring project metadatainpyproject.tomlUsageTo offer a simple example, if you want to add aSupported-Platformand theRequires-Externalfield three times, producing these lines in the.dist-info/METADATAfile:Supported-Platform: RedHat 8.3
Requires-External: C
Requires-External: libpng (>=1.5)
Requires-External: make; sys_platform != "win32"You would configure the tool like this inpyproject.toml, specifying a build dependency onsetuptools-extand then adding the fields in a[tool.setuptools-ext]section:[build-system]requires=["setuptools-ext"]build-backend="setuptools_ext"...[tool.setuptools-ext]supported-platform=["RedHat 8.3",]requires-external=["C","libpng (>=1.5)",'make; sys_platform != "win32"']The metadata fields may then be consumed by automated tooling for building RPM packages with system dependencies, for example.Note:This package does notadd new keyword argumentstosetup.py(that’s out of scope for a PEP 517 build backend).
Package: setuptools-flakes
Setuptools flakes commandThis package exposepyflakesas flakes command to setup.py.
It is a fork ofZooko O’Whielacronxcode.Usagepython setup.py flakes
python setup.py flakes --exclude-packages=foo.bar,baz.qux
python setup.py flakes --file=./results.logNews0.1Release date: 5-Jun-2012First release
Package: setuptools-freeze
Integrate “pyinstaller” to “setuptools”. This will make it easy to freeze your
package. More precisely, it will create a executable file form the console
scripts entry points in your package.How to useAdd “setuptools_freeze” to your setup requires:setup(
    ...
    setup_requires=[
        'setuptools_freeze',
        ...
    ],
    entry_points={
        'console_scripts': ['<script name>=mypackage.gui:main']
    },
    ...
)Now you can freeze your project:python setup.py pyinstallerThis will create the folder “dist/<script name>”, which include the executable
file.If you also use “Inno Setup” to create a executable setup file, you can use the
“inno” command. Before that you have to do two thinks.
1. Install “Inno Setup” and add the compiler to your $PATH
2. Add a guid to the setup file
Now you can run:python setup.py innoDeveloper nodesThis is still under develop. This is even more a proof of concept, than a
beautiful package. But it work for my case and hopefully I will make it
beautiful in future.Developer tools:python -m pip install --upgrade pip wheel setuptools flake8 toxInstall:python setup.py installTest:python setup.py flake8
python setup.py testBuild:python setup.py buildToDocreate build folder if not exist
Package: setuptools-generate
setuptools-generateGenerate shell completions and man page when building a python package.UsageAdd this package to your build requires:[build-system]requires=["setuptools-generate",]build-backend="setuptools.build_meta"[project]name="demo"version="0.0.1"[project.scripts]demo="demo:main"Build your package:python-mbuildSee yoursdist:$treesdist sdist├──  _demo  # zsh completion script├──  demo  # bash completion script├──  demo-0.0.1-py3-none-any.whl  # wheel file├──  demo-0.0.1.tar.gz  # source distribution file├──  demo.1  # man page└──  demo.fish  # fish completion scriptYou got them.Example projects:demo for clickdemo for shtabtranslate-shellSeedocumentto know more.
Package: setuptools-gettext
setuptools plugin for gettextCompile .po files into .mo files.This plugin addsbuild_mo,clean_moandinstall_mosubcommands for
setup.py as well as hooking those into standard commands.UsageBy default, setuptools_gettext compiles and installs mo files when there is apodirectory present that contains.pofiles.The .mo files are installed adjacent to your package as package data in a subdirectory calledlocale.You can override these settings inpyproject.toml:[build-system]requires=["setuptools","setuptools-gettext"]...[tool.setuptools-gettext]# directory in which the .po files can be foundsource_dir="po"# directory in which the generated .mo files are placed when buildingbuild_dir="breezy/locale"
Package: setuptools-gitver
Simple Git version plugin for setuptools.UsageModify thesetup.pyof your project and addsetuptools-gitvertosetup_requiresand add keyword argumentgitver=True.  Then,
after each release, add.post+gitversuffix to the version string.For example, insetup.py:import setuptools

if __name__ == '__main__':
    setuptools.setup(
        name='example-package',
        version='1.2.3.post+gitver',
        setup_requires=['setuptools-gitver'],
        gitver=True,
    )This will then generate version numbers like 1.2.3.post0.dev7+ga1b2c3d
where 7 is the number of commits since the v1.2.3 tag and a1b2c3d is
commit id of the HEAD.When creating a release, update the version and remove thepost+gitversuffix.  When there is no+gitversuffix, the
version won’t be touched by Setuptools Gitver.  Also remember to tag the
release in Git withgit tag-av1.2.3.
Package: setuptools-git-ver
setuptools-git-verAutomatically set package version using git tag/hashInstallInstall using pipUsageTo just use the default templates for versioning:setuptools.setup(...version_config=True,...setup_requires=['setuptools-git-ver'],...)Changing templates (also shows the defaults):setuptools.setup(...version_config={"template":"{tag}","dev_template":"{tag}.dev{ccount}+git.{sha}""dirty_template":"{tag}.dev{ccount}+git.{sha}.dirty"},...setup_requires=['setuptools-git-ver'],...)Templatestemplate: used if no untracked files and latest commit is taggeddev_template: used if no untracked files and latest commit isn't taggeddirty_template: used if untracked files exist or uncommitted changes have been madeFormat Options{tag}: Latest tag in the repository{ccount}: Number of commits since last tag{sha}: First 8 characters of the sha hash of the latest commit
Package: setuptools-git-version
Automatically set package version from Git.IntroductionInstead of hardcoding the package version insetup.pylike:setup(name='foobar',version='1.0',...)this package allows to extract it from the underlying Git repository:setup(name='foobar',version_format='{tag}.dev{commitcount}+{gitsha}',setup_requires=['setuptools-git-version'],...)Changes1.0.3 - 2015-04-23[bugfix] rename module to avoid import conflicts1.0.2 - 2015-04-14[bugfix] make it work with Python 3(.4)1.0.1 - 2015-04-14brownbag release1.0 - 2015-04-10initial public release
Package: setuptools-git-versioning
Use git repo data (latest tag, current commit hash, etc) for building a
version number accordingPEP 440.Features:Can be installed & configured through bothsetup.pyandPEP 518’spyproject.tomlDoes not require to change source code of the projectTag-, file-, and callback-based versioning schemas are supportedTemplates fortag,devanddirtyversions are separatedTemplates support a lot of substitutions including git and environment informationWell-documentedSeedifferencebetweensetuptools-git-versioningand other tools.Limitations:Currently the only supported VCS isGitOnly git v2 is supportedCurrently does not support automatic exporting of package version to a file for runtime use
(but you can usesetuptools-git-versioning> fileredirect instead)DocumentationSeehttps://setuptools-git-versioning.readthedocs.io/en/stable/Contribution GuideSee ./CONTRIBUTING.rstInstallpyproject.tomlJust addsetuptools-git-versioningtobuild-sytemsection of yourpyproject.toml,
add a sectiontool.setuptools-git-versioningwith config options, and mark the projectversionas dynamic.[build-system]requires=["setuptools>=41","wheel","setuptools-git-versioning<2",]build-backend="setuptools.build_meta"[tool.setuptools-git-versioning]enabled=true[project]dynamic=["version"]And check the package version generated (seecommand help):$python-msetuptools_git_versioning0.0.1# or$setuptools-git-versioning0.0.1setup.pyJust addsetuptools-git-versioningtosetup_requiresargument ofsetuptools.setupfunction call,
and then add new argumentsetuptools_git_versioningwith config options:importsetuptoolssetuptools.setup(...,setuptools_git_versioning={"enabled":True,},setup_requires=["setuptools-git-versioning<2"],)And check the package version generated (seecommand help):$pythonsetup.py--version0.0.1# or$python-msetuptools_git_versioning0.0.1# or$setuptools-git-versioning0.0.1
Package: setuptools-golang-examples
setuptools-golang-examplesA few examples utilizingsetuptools-golang.c_moduleDemonstrates that you can mix go extensions with c extensions seamlessly.go_sumA very basic hello-world-y demoThis example is roughly lifted from @FiloSottile'sblog posthello_libThis module demonstrates importing go code within the project.redThis module demonstrates importing external code (in this caseansi)sum_pure_goThis module demonstrates it is possible to write an extension using only go
files.It's slightly cheaty in that one of the go files is entirely a C header.You could instead do something similar tothis examplebut it's much more difficult to support multiple versions of python.
Package: setuptools-green
This module provides a “green” command for setuptools scripts that usesgreento run tests.StatusTravis CI (Ubuntu)AppVeyor (Windows)CoveragePyPILicenceUsageOptions for 'GreenTestCommand' command:
  --quiet          Don't show test descriptions when running
  --concurrent     Run tests concurrently
  --coverage       Collect coverage
  --coverage-omit  Patterns to omit from coverage, comma separated
  --target         Name of subdirectory where tests are to be foundBy default, the verbose mode is used, but you can pass –quiet to just
show dots for passes and “E” for failures.
Package: setuptools-grpc
Plugin for setuptools to compile protobuf and gRPC service files to python modules.This package providesbuild_grpccommand forsetuptools.
Its purpose is to build gRPC modules duringbuildstep ofsetuptoolspackaging.What this isn’tThis is not a command line script.Direct invocation ofsetup.py(such aspython setup.py build_grpc) has been deprecated
and will be removed in future version ofsetuptools.If you’d like to have CLI for building gRPC modules, usegrpcio-toolsdirectly (that’s what this package uses under the hood).
After installing that package, you can learn about its options
by runningpython-mgrpc_tools.protoc--help.InstallationYou probably shouldn’t install this package directly.
Instead, you should add it to thebuild-system.requiresinpyproject.toml.
SeeConfiguration.OptionsCommandbuild_grpcprovides following options:proto_files: Newline separated list of glob patterns matching protobuf files to be compiled.
Paths are relative to the current directory.**can be used to match any files and zero or more directories.
Default value is empty list.grpc_files: Newline separated list of glob patterns matching grpc service files to be compiled.
Paths are relative to the current directory.**can be used to match any files and zero or more directories.
Default value is empty list.proto_path: Path to root directory with protobuf files.
This path is passed through-Ioption togrpc_tools.protoc.
Default is.(current directory).output_path: Path to root directory for generated python modules.
This path is passed through--python_outor--grpc_python_outoption togrpc_tools.protoc.
Default is.(current directory).ConfigurationYou have to specifysetuptools-grpcas part of build backend requirements.
This follows specification introduced inPEP 518.
You can read more about it insetuptools docs.# file: pyproject.toml[build-system]requires=["setuptools","setuptools-grpc"]build-backend="setuptools.build_meta"Next, you need to actually addbuild_grpcas subcommand of thebuildcommand.
This needs to be done insetup.py, but ifsetuptoolsever allows for declarative
config, we’ll be happy to support it.# file: setup.pyfromsetuptoolsimportsetupfromsetuptools.command.buildimportbuildclasscustom_build(build):sub_commands=[('build_grpc',None),]+build.sub_commandssetup(cmdclass={'build':custom_build})Finally, you need to configuresetuptools_grpcitself.
This can be done insetup.py, but we recommend declarative config insetup.cfg.
Depending on your project structure, you may not need some of the options below.
You’ll always need to specify at leastproto_filesorgrpc_files,
otherwisesetuptools_grpcwon’t do anything.# file: setup.cfg[build_grpc]proto_files=src/**/*.protogrpc_files=src/**/*_grpc.protoproto_path=./srcoutput_path=./out
Package: setuptools_hg
setuptools_hg is a plugin for setuptools/distribute to enable it to find
files under the Mercurial version control system.It uses the Mercurial Python library by default and falls back to use the
command line programmhg(1). That’s especially useful inside virtualenvs
that don’t have access to the system wide installed Mercurial lib (e.g. when
created with--no-site-packages).NoteThe setuptools featureYou can read about the hooks used by setuptool_hg in thesetuptoolsordistributedocumentation. It basically returns a list of files that are
under Mercurial version control when running thesetupfunction, e.g. if
you create a source and binary distribution. It’s a simple yet effective way
of not having to define package data (non-Python files) manually in MANIFEST
templates (MANIFEST.in).UsageHere’s an example of a setup.py that uses setuptools_hg:from setuptools import setup, find_packages

setup(
    name="HelloWorld",
    version="0.1",
    packages=find_packages(),
    setup_requires=["setuptools_hg"],
)If you run this setup.py setuptools will automatically download setuptools_hg
to the directory where the setup.py is located at (and won’t install it
anywhere else) to get all package data files from the Mercurial repository.OptionsSet theHG_SETUPTOOLS_FORCE_CMDenvironment variable before running
setup.py if you want to enforce the use of the hg command.
“””CHANGES0.4fix a bug if the current distribution is not versionned with mercurial. [kiorky]fixhttps://bitbucket.org/jezdez/setuptools_hg/issue/5/using-hg-command-line-with-py3-does-not[kiorky]
Package: setuptools-lint
Setuptools lint commandThis package exposepylintas a lint command into setup.py.InstallationThis package is published on pypi. You can use pip to install it.pip install setuptools-lintUsagepython setup.py lintFor a full list of options, dopython setup.py lint --helpNews0.6.0Release date: 14-Sept-2018make python 2 & 3 explicit, thanks @cclaussfixed pylint > 1.9 dependencies0.5.2Release date: 21-Aug-2016fix outfile parameter0.5Release date: 12-Aug-2016fix creating dirs on outfile0.4Release date: 18-Nov-2015allow to pipe commands likepython setup.py lint install0.3Release date: 14-Jun-2014Adding dependency handeling, similar to that of setuptools’s test command,
such that required dependencies get fetched and added to the path prior to
running the lint0.2Release date: 7-Apr-2014Better support for packagesAllow specification of PyLint config file either on commandline or as setup
keyword arg0.1Release date: 5-Jun-2012First release
Package: setuptools-markdown
setuptools-markdownUseMarkdownfor your
project descriptionThis project is deprecated.Instead of using this, you should use the built-in functionality of
setuptools and PyPI.Seethis pagefor details.InstallInstallpandocInstall this modulepip install setuptools-markdownUse#!/usr/bin/env python# setup.pyfromsetuptoolsimportsetupsetup(...setup_requires=['setuptools-markdown'],long_description_markdown_filename='README.md',...)The plugin will read the specified file, convert it toreSTusingpypandocand store the
resulting reST in thelong_descriptionmetadata field of your
distribution.
Package: setuptools-metadata
setuptools-metadata - Adds metadata command to setup.pyUsing custom_metadata in setup callfrom setuptools import setupsetup(name='spam',custom_metadata={'x_str': 'bla','x_int': 23,'x_list': ['a', 'b', 'c']})Using 'setup.py metadata'./setup.py metadata --key=install_requirespygraphvizlxmlanother-packageThis prints out the 'install_requires' setup keyword argument.If it can't find the requested key, it will also search the custom_metadata dict:./setup.py metadata --key=x_strbla./setup.py metadata --key=x_int23./setup.py metadata --key=x_listabcInstallingInstall it into your system Python like this:sudo pip install setuptools-metadata
Package: setuptools-node
setuptools extensions for working with Node.jsThe setuptools_node package contains a number of useful setuptools extensions
for working with Node.js, many useful web development tools can be found in the
npm ecosystem.General UseIn general custom setuptools command are used by registering the custom command
in thecmdclassargument to thesetup()functionsetup(cmdclass={'my_command':MyCommand})General optionsBy default all paths are relative to the directory containingsetup.py.  Node
will be in thenodedirectory and node modules innode_modules--node-dirSpecify an alternate directory where node may be found--node-modules-dirSpecify an alternate directory for node modulesInstallNodeTheInstallNodecommand is used to fetch a copy of node.js and install it
in the project directory.  The download will be cached in thecachedirectory
to facilitate a quick reinstall.InstallNode Options--node-dist-urlSpecify the URL from which to fetch node--node-versionSpecify the version of node to fetch--cache-dirSpecify the directory in which to store the node downloadsetup.py:fromsetuptools_nodeimportInstallNodesetup(cmdclass={'install_node':InstallNode})Use:user@host$pythonsetup.pyinstall_nodeNpmInstallTheNpmInstallcommand is used to install modules from npm.  By defaultnpm installis used,npm cimay be specified with--use-ciNpmInstall Options--use-ciUsenpm cito install modules instead ofnpm installsetup.py:fromsetuptools_nodeimportNpmInstallsetup(cmdclass={'npm_install':NpmInstall})Use:user@host$pythonsetup.pynpm_install# oruser@host$pythonsetup.pynpm_install--use-ciGulpTheGulpcommand runs the gulp build toolGulp Options--taskSpecify the task to run insteaed of the default.  Multiple tasks may
be specified as a comma separated list.setup.py:fromsetuptools_nodeimportGulpsetup(cmdclass={'gulp':Gulp})Use:user@host$pythonsetup.pygulp# run default taskuser@host$pythonsetup.pygulp--taskfoo# run the 'foo' taskuser@host$pythonsetup.pygupl--taskclean,foo# run 'clean' and 'foo' tasksGulpBuildTheGulpBuildcommand provides a version ofbuild_pythat executes gulp
before proceeding with the normalbuild_pyprocess, this allows you to
build/transform static files for a web application before they are included
in the package built bybuild_py.Node will be installed if it is not found, and modules will be
installed/updated.GulpBuild Options--taskSpecify the task to run insteaed of the default.  Multiple tasks may
be specified as a comma separated list.Since you don't generally runbuild_pydirectly, you will need to add any
arguments to the setup.cfg:[build_py]task=myGulpTasksetup.py:fromsetuptools_nodeimportGulpBuildsetup(cmdclass={'build_py':GulpBuild})Use:user@host$pythonsetup.pybdist_wheel
Package: setuptools-npm
Plugin for setuptools to run npm commands.UsageThis command providesnpm_installandnpm_runcommands.Runpython setup.py npm_install –helporpython setup.py npm_run –helpfor available options.npm_not_skippedis a helper function that can be used as predicate for
distutils subcommand. It evaluates toTrueif env variableSKIP_NPMis not defined. This variable is exclusive to this helper function and
is not evaluated innpm_installandnpm_runcommands themselves.ExampleLet’s say you have definedbuildcommand inpackage.jsonand you’d like
to runnpm clean-installandnpm run buildeach time you runsetup.py build.
You’d configure your project like this:# pyproject.toml
[build-system]
requires = ["setuptools", "setuptools-npm"]
build-backend = "setuptools.build_meta"# setup.py
from distutils.command.build import build
from setuptools import setup
from setuptools_npm import npm_not_skipped

class custom_build(build):
    sub_commands = [
        ('npm_install', npm_not_skipped),
        ('npm_run', npm_not_skipped),
    ] + build.sub_commands

setup(cmdclass={'build': custom_build, 'sdist': custom_sdist})# setup.cfg
[npm_run]
script = build