Publicamos atualizações frequentes em nossa documentação, e a tradução desta página ainda pode estar em andamento. Para obter as informações mais recentes, acesse a documentação em inglês. Se houver problemas com a tradução desta página, entre em contato conosco.

Usar Python com GitHub Actions

É possível criar um fluxo de trabalho de integração contínua (CI) para criar e testar o seu projeto Python.

Neste artigo

Introdução

Este guia mostra como criar, testar e publicar um pacote no Python.

Os executores hospedados em GitHub possuem uma cache de ferramentas com um software pré-instalado, que inclui o Python e o PyPy. Você não precisa instalar nada! Para obter uma lista completa do software atualizado e das versões pré-instaladas do Python e do PyPy, consulte software instalado em executores hospedados em GitHub.

Pré-requisitos

Você deve estar familiarizado com o YAML e a sintaxe do GitHub Actions. Para obter mais informações, consulte "Sintaxe de fluxo de trabalho para o GitHub Actions".

Recomendamos que você tenha um entendimento básico do Python, PyPy e pip. Para obter mais informações, consulte:

Introdução com o modelo do fluxo de trabalho do Python

O GitHub fornece um modelo de fluxo de trabalho do Python que deve funcionar na maioria dos projetos Python. Este guia inclui exemplos que você pode usar para personalizar o modelo. Para obter mais informações, consulte o modelo de fluxo de trabalho do Python.

Para iniciar rapidamente, adicione o modelo ao diretório .github/workflows do repositório.

nome: Pacote do Python

em: [push]

trabalhos:
  criar:

    runs-on: ubuntu-latest
    estratégia:
      matriz:
        python-version: [2.7, 3.5, 3.6, 3.7, 3.8]

    etapas:
    - usa: actions/checkout@v2
    - nome: Configura o Python ${{ matrix.python-version }}
      usa: actions/setup-python@v2
      com:
        python-version: ${{ matrix.python-version }}
    - nome: Instalar dependências
      executar: |
        python -m pip install --upgrade pip
        pip install flake8 pytest
        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
    - nome : Lint with flake8
      executar: |
        # interrompe a criação em caso de erros de sintaxe do Python ou de nomes indefinidos
        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
        # exit-zero trata todos os errors como avisos. O editor do GitHub tem 127 caracteres
        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
    - nome: Testar com pytest
      executar: |
        pytest

Especificar uma versão do Python

Para usar uma versão pré-instalada do Python ou do PyPy em um executor hospedado em GitHub, use a ação setup-python. Esta ação encontra uma versão específica do Python ou do PyPy na cache das ferramenatas em cada executor e adiciona os binários necessários ao PATH, que persiste para o restante do trabalho. Se uma versão específica do Python não for pré-instalada na cache de ferramentas, a setup-python ação fará o download e irá configurar a versão apropriada do repositório python-versions.

Using the setup-action is the recommended way of using Python with GitHub Actions because it ensures consistent behavior across different runners and different versions of Python. If you are using a self-hosted runner, you must install Python and add it to PATH. For more information, see the setup-python action.

The table below describes the locations for the tools cache in each GitHub-hosted runner.

UbuntuMacWindows
Diretório da cache da ferramenta/opt/hostedtoolcache/*/Users/runner/hostedtoolcache/*C:\hostedtoolcache\windows\*
Cache da ferramenta do Python/opt/hostedtoolcache/Python/*/Users/runner/hostedtoolcache/Python/*C:\hostedtoolcache\windows\Python\*
Cache da ferramenta do PyPy/opt/hostedtoolcache/PyPy/*/Users/runner/hostedtoolcache/PyPy/*C:\hostedtoolcache\windows\PyPy\*

Se você estiver usando um executor auto-hospedado, você poderá configurá-lo para usar a ação setup-python para gerenciar suas dependências. Para obter mais informações, consulte usando o setup-python com um executor auto-hospedado na LEIAME do setup-python.

GitHub supports semantic versioning syntax. For more information, see "Using semantic versioning" and the "Semantic versioning specification."

Usar várias versões do Python

nome: Pacote Python

em: [push]

trabalhos:
  criar:

    runs-on: ubuntu-latest
    estratégia:
      # Você pode usar as versões do PyPy em python-version.
      # Por exemplo, pypy2 and pypy3
      matriz:
        python-version: [2.7, 3.5, 3.6, 3.7, 3.8]

    etapas:
    - usa: actions/checkout@v2
    - nome: Configura o Python ${{ matrix.python-version }}
      usa: actions/setup-python@v2
      com:
        python-version: ${{ matrix.python-version }}
    # Você pode testar a sua matriz imprimindo a versão atual do Python
    - nome: Exibe a versão do Python
      executar: python -c "import sys; print(sys.version)"

Usar uma versão específica do Python

You can configure a specific version of python. For example, 3.8. Alternatively, you can semantic version syntax to get the latest minor release. This example uses the latest minor release of Python 3.

nome: Pacote Python

em: [push]

trabalhos:
  criar:

    runs-on: ubuntu-latest

    etapas:
    - usa: actions/checkout@v2
    - nome: Configura Python 3.x
      usa: actions/setup-python@v2
      com:
        # Sintaxe do intervalo da versão semântica ou versão exata de uma versão do Python
        python-version: '3.x' 
        # Opcional - x64 or x86 architecture, defaults to x64
        arquitetura: 'x64' 
    # Você pode testar a sua matriz imprimindo a versão atual do Python
    - nome: Exibir uma versão do Python
      executar: python -c "import sys; print(sys.version)"

Excluir uma versão

If you specify a version of Python that is not available, setup-python fails with an error such as: ##[error]Version 3.4 with arch x64 not found. The error message includes the available versions.

You can also use the exclude keyword in your workflow if there is a configuration of Python that you do not wish to run. For more information, see "Workflow syntax for GitHub Actions."

name: Python package

on: [push]

jobs:
  build:

    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
        python-version: [2.7, 3.6, 3.7, 3.8, pypy2, pypy3]
        exclude:
          - os: macos-latest
            python-version: 3.6
          - os: windows-latest
            python-version: 3.6

Usar a versão padrão do Python

We recommend using setup-python to configure the version of Python used in your workflows because it helps make your dependencies explicit. If you don't use setup-python, the default version of Python set in PATH is used in any shell when you call python. The default version of Python varies between GitHub-hosted runners, which may cause unexpected changes or use an older version than expected.

Executor hospedado emGitHubDescrição
UbuntuOs executores do Ubuntu têm várias versões do sistema do Python instaladas em /usr/bin/python e /usr/bin/python3. As versões do Python que vêm empacotadas com o Ubuntu são adicionais às versões que o GitHub instala na cache das ferramentas.
WindowsExcluindo as versões do Python que estão na cache de ferramentas, o Windows não é compatível com uma versão equivalente do sistema do Python. Para manter um comportamento consistente com outros executores e permitir que o Python seja usado de forma inovadora sem a ação setup-python , GitHub adiciona algumas versões da cache das ferramentas ao PATH.
macOSOs executores do macOS têm mais de uma versão do sistema do Python instalada, além das versões que fazem parte da cache de ferramentas. As versões do sistema do Python estão localizadas no diretório /usr/local/Cellar/python/*.

Instalar dependências

GitHub-hosted runners have the pip package manager installed. You can use pip to install dependencies from the PyPI package registry before building and testing your code. For example, the YAML below installs or upgrades the pip package installer and the setuptools and wheel packages.

You can also cache dependencies to speed up your workflow. For more information, see "Caching dependencies to speed up your workflow."

etapas:
- usa: actions/checkout@v2
- nome: Configurar Python
  usa: actions/setup-python@v2
  com:
    python-version: '3.x'
- Nome: Instalar dependências
  executar: python -m pip install --upgrade pip setuptools wheel

Arquivo de requisitos

After you update pip, a typical next step is to install dependencies from requirements.txt.

etapas:
- usa: actions/checkout@v2
- nome: Configurar Python
  usa: actions/setup-python@v2
  com:
    python-version: '3.x'
- nome: Instalar dependências
  executar: |
    python -m pip install --upgrade pip
    pip install -r requirements.txt

Memorizar dependências

You can cache pip dependencies using a unique key, and restore the dependencies when you run future workflows using the cache action. For more information, see "Caching dependencies to speed up workflows."

Pip caches dependencies in different locations, depending on the operating system of the runner. The path you'll need to cache may differ from the Ubuntu example below depending on the operating system you use. For more information, see Python caching examples.

etapas:
- usa: actions/checkout@v2
- nome: Setup Python
  usa: actions/setup-python@v2
  com:
    python-version: '3.x'
- nome: Cache pip
  usa: actions/cache@v2
  com:
    # Este caminho é específico para o Ubuntu
    caminho: ~/.cache/pip
    # Observe se há uma correspondência da cache para o arquivo de requisitos correspondente
    chave: ${{ runner.os }}-pip-${{ hashFiles('requirements.txt') }}
    restore-keys: |
      ${{ runner.os }}-pip-
      ${{ runner.os }}-
- nome: Instalar dependências
  executar: pip install -r requirements.txt

Note: Depending on the number of dependencies, it may be faster to use the dependency cache. Projects with many large dependencies should see a performance increase as it cuts down the time required for downloading. Projects with fewer dependencies may not see a significant performance increase and may even see a slight decrease due to how pip installs cached dependencies. The performance varies from project to project.

Testar seu código

You can use the same commands that you use locally to build and test your code.

Testar com pytest e pytest-cov

This example installs or upgrades pytest and pytest-cov. Tests are then run and output in JUnit format while code coverage results are output in Cobertura. For more information, see JUnit and Cobertura.

etapas:
- usa: actions/checkout@v2
- nome: Set up Python
  usa: actions/setup-python@v2
  com:
    python-version: '3.x'
- nome: Instalar dependências
  executar: |
    python -m pip install --upgrade pip
    pip install -r requirements.txt
- Nome: Testar com pytest
  executar: |
    pip install pytest
    pip install pytest-cov
    pytest tests.py --doctest-modules --junitxml=junit/test-results.xml --cov=com --cov-report=xml --cov-report=html

UsarFlake8 para código lint

The following example installs or upgrades flake8 and uses it to lint all files. For more information, see Flake8.

etapas:
- usa: actions/checkout@v2
- nome: Configurar Python
  usa: actions/setup-python@v2
  com:
    python-version: '3.x'
- nome: Instalar dependências
  executar: |
    python -m pip install --upgrade pip
    pip install -r requirements.txt
- nome: Lint with flake8
  run: |
    pip install flake8
    flake8 .

Executar testes com tox

With GitHub Actions, you can run tests with tox and spread the work across multiple jobs. You'll need to invoke tox using the -e py option to choose the version of Python in your PATH, rather than specifying a specific version. For more information, see tox.

nome: Pacote Python

em: [push]

trabalhos:
  criar:

    runs-on: ubuntu-latest
    estratégia:
      matriz:
        python: [2.7, 3.7, 3.8]

    etapa:
      - usa: actions/checkout@v2
      - nome: Setup Python
        usa: actions/setup-python@v2
        com:
          python-version: ${{ matrix.python }}
      - nome: Instalar Toxe e todos os outros pacotes
        executar: pip install tox
      - nome: Executar Tox
        # Executar tox usando a versão do Python no `PATH`
        run: tox -e py

Empacotar dados do fluxo de trabalho como artefatos

You can upload artifacts to view after a workflow completes. For example, you may need to save log files, core dumps, test results, or screenshots. For more information, see "Persisting workflow data using artifacts."

The following example demonstrates how you can use the upload-artifact action to archive test results from running pytest. For more information, see the upload-artifact action.

name: Python package

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: [2.7, 3.5, 3.6, 3.7, 3.8]

      steps:
      - uses: actions/checkout@v2
      - name: Setup Python # Set Python version
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python-version }}
      # Install pip and pytest
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install pytest
      - name: Test with pytest
        run: pytest tests.py --doctest-modules --junitxml=junit/test-results-${{ matrix.python-version }}.xml
      - name: Upload pytest test results
        uses: actions/upload-artifact@v2
        with:
          name: pytest-results-${{ matrix.python-version }}
          path: junit/test-results-${{ matrix.python-version }}.xml
        # Use always() to always run this step to publish test results when there are test failures
        if: ${{ always() }}

Publicar nos registros do pacote

You can configure your workflow to publish your Python package to any package registry you'd like when your CI tests pass.

You can store any access tokens or credentials needed to publish your package using repository secrets. The following example creates and publishes a package to PyPI using twine and dist. For more information, see "Creating and using encrypted secrets."

Nome: Fazer o upload no pacote Python

em:
  versão:
    tipos: [created]

trabalhos:
  implementar:
    runs-on: ubuntu-latest
    etapas:
    - usa: actions/checkout@v2
    - nome: Configurar Python
      usa: actions/setup-python@v2
      com:
        python-version: '3.x'
    - nome: Instalar dependências
      executar: |
        python -m pip install --upgrade pip
        pip install setuptools wheel twine
    - nome: Criar e publicar
      env:
        TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
        TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
      executar: |
        python setup.py sdist bdist_wheel
        twine upload dist/*

For more information about the template workflow, see python-publish.

Pergunte a uma pessoa

Não consegue encontrar o que procura?

Entrar em contato