Empacotando projetos Python

This tutorial walks you through how to package a simple Python project. It will show you how to add the necessary files and structure to create the package, how to build the package, and how to upload it to the Python Package Index (PyPI).

Dica

Se você tiver problemas para executar os comandos neste tutorial, copie o comando e sua saída e, em seguida, relate um problema no repositório packaging-problems no GitHub. Faremos o nosso melhor para ajudá-lo!

Alguns comandos exigem uma nova versão de pip, então comece certificando-se de que você tenha a versão mais recente instalada:

python3 -m pip install --upgrade pip
py -m pip install --upgrade pip

Um projeto simples

This tutorial uses a simple project named example_package_YOUR_USERNAME_HERE. If your username is me, then the package would be example_package_me; this ensures that you have a unique package name that doesn’t conflict with packages uploaded by other people following this tutorial. We recommend following this tutorial as-is using this project, before packaging your own project.

Crie a seguinte estrutura de arquivos localmente:

packaging_tutorial/
└── src/
    └── example_package_YOUR_USERNAME_HERE/
        ├── __init__.py
        └── example.py

The directory containing the Python files should match the project name. This simplifies the configuration and is more obvious to users who install the package.

__init__.py é necessário para importar o diretório como um pacote, e deve estar vazio.

example.py é um exemplo de módulo dentro do pacote que pode conter a lógica (funções, classes, constantes, etc.) do seu pacote. Abra esse arquivo e insira o seguinte conteúdo:

def add_one(number):
    return number + 1

Se você não está familiarizado com módulos e pacotes de importação do Python, reserve alguns minutos para ler a documentação do Python para pacotes e módulos.

Depois de criar esta estrutura, você desejará executar todos os comandos neste tutorial dentro do diretório packaging_tutorial.

Criando arquivos do pacote

Agora você adicionará arquivos que são usados para preparar o projeto para distribuição. Quando terminar, a estrutura do projeto ficará assim:

packaging_tutorial/
├── LICENSE
├── pyproject.toml
├── README.md
├── src/
│   └── example_package_YOUR_USERNAME_HERE/
│       ├── __init__.py
│       └── example.py
└── tests/

Criando um diretório de teste

tests/ é um espaço reservado, ou placeholder, para arquivos de teste. Deixe-o vazio por enquanto.

Criando pyproject.toml

pyproject.toml tells “frontend” build tools like pip and construir what “backend” tool to use to create distribution packages for your project. You can choose from a number of backends; this tutorial uses Hatchling by default, but it will work identically with setuptools, Flit, PDM, and others that support the [project] table for metadata.

Nota

Some build backends are part of larger tools that provide a command-line interface with additional features like project initialization and version management, as well as building, uploading, and installing packages. This tutorial uses single-purpose tools that work independently.

Open pyproject.toml and enter one of these [build-system] tables:

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"
[build-system]
requires = ["setuptools>=61.0"]
build-backend = "setuptools.build_meta"
[build-system]
requires = ["flit_core>=3.2"]
build-backend = "flit_core.buildapi"
[build-system]
requires = ["pdm-pep517"]
build-backend = "pdm.pep517.api"
  • requires is a list of packages that are needed to build your package. You don’t need to install them; build frontends like pip will install them automatically in a temporary, isolated virtual environment for use during the build process.

  • build-backend is the name of the Python object that frontends will use to perform the build.

Configurando metadados

Open pyproject.toml and enter the following content. Change the name to include your username; this ensures that you have a unique package name that doesn’t conflict with packages uploaded by other people following this tutorial.

[project]
name = "example_package_YOUR_USERNAME_HERE"
version = "0.0.1"
authors = [
  { name="Example Author", email="author@example.com" },
]
description = "A small example package"
readme = "README.md"
license = { file="LICENSE" }
requires-python = ">=3.7"
classifiers = [
    "Programming Language :: Python :: 3",
    "License :: OSI Approved :: MIT License",
    "Operating System :: OS Independent",
]

[project.urls]
"Homepage" = "https://github.com/pypa/sampleproject"
"Bug Tracker" = "https://github.com/pypa/sampleproject/issues"
  • name is the distribution name of your package. This can be any name as long as it only contains letters, numbers, ., _ , and -. It also must not already be taken on PyPI. Be sure to update this with your username for this tutorial, as this ensures you won’t try to upload a package with the same name as one which already exists.

  • version is the package version. See the version specifier specification for more details on versions. Some build backends allow it to be specified another way, such as from a file or a git tag.

  • authors is used to identify the author of the package; you specify a name and an email for each author. You can also list maintainers in the same format.

  • description é um resumo curto do pacote contendo apenas uma frase.

  • readme is a path to a file containing a detailed description of the package. This is shown on the package detail page on PyPI. In this case, the description is loaded from README.md (which is a common pattern). There also is a more advanced table form described in the project metadata specification.

  • license is the path to the LICENSE file, described below.

  • requires-python gives the versions of Python supported by your project. Installers like pip will look back through older versions of packages until it finds one that has a matching Python version.

  • classifiers fornece o índice e pip alguns metadados adicionais sobre seu pacote. Nesse caso, o pacote é compatível apenas com Python 3, está licenciado sob a licença MIT e é independente do sistema operacional. Você deve sempre incluir pelo menos a(s) versão(ões) do Python em que seu pacote funciona, em que licença seu pacote está disponível e em quais sistemas operacionais seu pacote funcionará. Para obter uma lista completa de classificadores, consulte https://pypi.org/classifiers/.

  • urls lets you list any number of extra links to show on PyPI. Generally this could be to the source, documentation, issue trackers, etc.

See the project metadata specification for details on these and other fields that can be defined in the [project] table. Other common fields are keywords to improve discoverability and the dependencies that are required to install your package.

Criando README.md

Abra README.md e insira o seguinte conteúdo. Você pode personalizar isso se desejar.

# Example Package

This is a simple example package. You can use
[Github-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
to write your content.

Criando um LICENSE

É importante que cada pacote enviado para o Índice de Pacotes do Python inclua uma licença. Isso informa aos usuários que instalam seu pacote os termos sob os quais eles podem usá-lo. Para obter ajuda na escolha de uma licença, consulte https://choosealicense.com/. Depois de escolher uma licença, abra LICENSE e digite o texto da licença. Por exemplo, se você escolheu a licença MIT:

Copyright (c) 2018 The Python Packaging Authority

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Incluindo outros arquivos

The files listed above will be included automatically in your source distribution. If you want to include additional files, see the documentation for your build backend.

Gerando arquivos de distribuição

O próximo passo é gerar pacotes de distribuição para o pacote. Estes são arquivos que são enviados para o Índice de Pacotes do Python e podem ser instalados pelo pip.

Certifique-se de que você tenha a versão mais recente da construção do PyPA instalada:

python3 -m pip install --upgrade build
py -m pip install --upgrade build

Dica

Se você tiver problemas ao instalá-los, veja o tutorial Instalando pacotes.

Agora, execute este comando a partir do mesmo diretório no qual pyproject.toml está localizado:

python3 -m build
py -m build

Este comando deve produzir muito texto e, uma vez concluído, deve gerar dois arquivos no diretório dist:

dist/
  example_package_YOUR_USERNAME_HERE-0.0.1-py3-none-any.whl
  example_package_YOUR_USERNAME_HERE-0.0.1.tar.gz

The tar.gz file is a source distribution whereas the .whl file is a built distribution. Newer pip versions preferentially install built distributions, but will fall back to source distributions if needed. You should always upload a source distribution and provide built distributions for the platforms your project is compatible with. In this case, our example package is compatible with Python on any platform so only one built distribution is needed.

Enviando os arquivos de distribuição

Finalmente, é hora de enviar seu pacote para o Índice de Pacotes do Python!

A primeira coisa que você precisa fazer é registrar uma conta no Test PyPI, que é uma instância separada do índice do pacote destinada a teste e experimentação. É ótimo para coisas como este tutorial, em que não queremos necessariamente enviar para o índice real. Para registrar uma conta, vá em https://test.pypi.org/account/register/ e conclua as etapas nessa página. Você também precisará verificar seu endereço de e-mail antes de enviar qualquer pacote. Para mais detalhes, veja Usando TestPyPI.

Para enviar seu projeto com segurança, você precisará de um token de API do PyPI. Crie um em https://test.pypi.org/manage/account/#api-tokens, definindo o “Escopo” como “Toda a conta”. Não feche a página antes de copiar e salvar o token – você não verá o token novamente.

Agora que você está registrado, você pode usar twine para enviar os pacotes de distribuição. Você precisará instalar o Twine:

python3 -m pip install --upgrade twine
py -m pip install --upgrade twine

Uma vez instalado, execute o Twine para enviar de todos os arquivos em dist:

python3 -m twine upload --repository testpypi dist/*
py -m twine upload --repository testpypi dist/*

Você será solicitado a fornecer um nome de usuário e uma senha. Para o nome de usuário, use __token__. Para a senha, use o valor do token, incluindo o prefixo pypi-.

Depois que o comando for concluído, você deverá ver uma saída semelhante a esta:

Uploading distributions to https://test.pypi.org/legacy/
Enter your username: [your username]
Enter your password:
Uploading example_package_YOUR_USERNAME_HERE-0.0.1-py3-none-any.whl
100%|█████████████████████| 4.65k/4.65k [00:01<00:00, 2.88kB/s]
Uploading example_package_YOUR_USERNAME_HERE-0.0.1.tar.gz
100%|█████████████████████| 4.25k/4.25k [00:01<00:00, 3.05kB/s]

Once uploaded your package should be viewable on TestPyPI; for example: https://test.pypi.org/project/example_package_YOUR_USERNAME_HERE.

Instalando seu pacote recém-enviado

Você pode usar o pip para instalar seu pacote e verificar se ele funciona. Crie um ambiente virtual e instale seu pacote a partir do Test PyPI:

python3 -m pip install --index-url https://test.pypi.org/simple/ --no-deps example-package-YOUR-USERNAME-HERE
py -m pip install --index-url https://test.pypi.org/simple/ --no-deps example-package-YOUR-USERNAME-HERE

Certifique-se de especificar seu nome de usuário no nome do pacote!

pip deve instalar o pacote de Test PyPI e a saída deve ser semelhante a esta:

Collecting example-package-YOUR-USERNAME-HERE
  Downloading https://test-files.pythonhosted.org/packages/.../example_package_YOUR_USERNAME_HERE_0.0.1-py3-none-any.whl
Installing collected packages: example_package_YOUR_USERNAME_HERE
Successfully installed example_package_YOUR_USERNAME_HERE-0.0.1

Nota

Este exemplo usa o sinalizador --index-url para especificar Test PyPI em vez do PyPI real. Além disso, ele especifica --no-deps. Como o Test PyPI não tem os mesmos pacotes que o PyPI real, é possível que a tentativa de instalação de dependências falhe ou instale algo inesperado. Embora nosso pacote de exemplo não tenha nenhuma dependência, é uma boa prática evitar instalar dependências ao usar o Test PyPI.

Você pode testar se ele foi instalado corretamente importando o pacote. Certifique-se de que ainda está em seu ambiente virtual e execute o Python:

python3
py

e importe o pacote:

>>> from example_package_YOUR_USERNAME_HERE import example
>>> example.add_one(2)
3

Próximos passos

Parabéns, você empacotou e distribuiu um projeto Python! ✨ 🍰 ✨

Lembre-se de que este tutorial mostrou como enviar o seu pacote para Test PyPI, que não é um armazenamento permanente. O sistema de teste ocasionalmente exclui pacotes e contas. É melhor usar Test PyPI para testes e experimentos como este tutorial.

Quando estiver pronto para carregar um pacote real para o Índice de Pacotes do Python, você pode fazer quase o mesmo que fez neste tutorial, mas com estas diferenças importantes:

  • Choose a memorable and unique name for your package. You don’t have to append your username as you did in the tutorial, but you can’t use an existing name.

  • Registre uma conta em https://pypi.org – observe que esses são dois servidores separados e os detalhes de login do servidor de teste não são compartilhados com o servidor principal.

  • Use twine upload dist/* para enviar seu pacote e insira suas credenciais para a conta que você registrou no PyPI real. Agora que você está enviando o pacote em produção, você não precisa especificar --repository; o pacote será enviado para https://pypi.org/ por padrão.

  • Instale seu pacote a partir do PyPI real usando python3 -m pip install [seu-pacote].

Neste ponto, se você quiser ler mais sobre o empacotamento de bibliotecas Python, aqui estão algumas coisas que você pode fazer: