Esta documentação é de uma versão antiga do Python que não é mais atualizada. Você deveria atualizar e ler a Documentação do Python para versão estável atual.

# `zipapp` — Manage executable Python zip archives

Novo na versão 3.5.

Código-fonte: Lib/zipapp.py

Este módulo fornece ferramentas para gerenciar a criação de arquivos zip contendo código Python, que pode ser executado diretamente pelo interpretador Python. O módulo fornece uma Interface de Linha de Comando e uma API do Python.

## Exemplo básico

O exemplo a seguir mostra como a Interface de Linha de Comando pode ser usada para criar um arquivo executável a partir de um diretório contendo código Python. Quando executado, o arquivo executará a função `main` do módulo `myapp` no arquivo.

    $ python -m zipapp myapp -m "myapp:main"
    $ python myapp.pyz
    <output from myapp>

## Interface de Linha de Comando

Quando chamado como um programa a partir da linha de comando, as seguintes opções estão disponíveis:

    $ python -m zipapp source [options]

Se source for um diretório, isso criará um arquivo a partir do conteúdo de source. Se source for um arquivo, ele deve ser um arquivo, e será copiado para o arquivo de destino (ou o conteúdo de sua linha shebang será exibido se a opção –info for especificada).

As seguintes opções são compreendidas:

`-o``<output>``,` `--output``=<output>`

  Escreve a saída em um arquivo chamado output. Se essa opção não for especificada, o nome do arquivo de saída será o mesmo que o source de entrada, com a extensão `.pyz` adicionada. Se um nome de arquivo explícito for fornecido, ele será usado como está (então uma extensão `.pyz` deve ser incluída se necessário).

  Um nome de arquivo de saída deve ser especificado se source for um arquivo (e nesse caso, output não deve ser o mesmo que source).

`-p``<interpreter>``,` `--python``=<interpreter>`

  Adiciona uma linha `#!` ao arquivo especificando interpreter como o comando a ser executado. Além disso, no POSIX, torne o arquivo executável. O padrão é não escrever nenhuma linha `#!` e não tornar o arquivo executável.

`-m``<mainfn>``,` `--main``=<mainfn>`

  Escreve um arquivo `__main__.py` no arquivo que executa mainfn. O argumento mainfn deve ter o formato “pkg.mod:fn”, onde “pkg.mod” é um pacote/módulo no arquivo, e “fn” é um chamável no módulo fornecido. O arquivo `__main__.py` executará esse chamável.

  `--main` não pode ser especificado ao copiar um arquivo.

`-c````,` `--compress```

  Compacta arquivos com o método deflate, reduzindo o tamanho do arquivo de saída. Por padrão, os arquivos são armazenados descompactados no arquivo.

  `--compress` não tem efeito ao copiar um arquivo.

  Novo na versão 3.7.

`--info```

  Exibe o interpretador incorporado no arquivo, para fins de diagnóstico. Neste caso, quaisquer outras opções são ignoradas e SOURCE deve ser um arquivo, não um diretório.

`-h````,` `--help```

  Exibe uma mensagem curta de uso e sai

## API do Python

O módulo define duas funções de conveniência:

`zipapp.``create_archive`(source, target=None, interpreter=None, main=None, filter=None, compressed=False)

  Cria um arquivo de aplicação a partir de source. A fonte pode ser qualquer um dos seguintes:

  - O nome de um diretório, ou um objeto caminho ou similar referente a um diretório, caso em que um novo arquivo de aplicação será criado a partir do conteúdo desse diretório.

  - O nome de um arquivo de aplicação existente, ou um objeto caminho ou similar referindo-se a tal arquivo, em cujo caso o arquivo é copiado para o alvo (modificando-o para refletir o valor dado para o argumento interpreter). O nome do arquivo deve incluir a extensão `.pyz`, se necessário.

  - Um objeto arquivo aberto para leitura no modo bytes. O conteúdo do arquivo deve ser um arquivo de aplicação, e o objeto arquivo é presumido como estando posicionado no início do arquivo.

  O argumento target determina onde o arquivo resultante será escrito:

  - Se for o nome de um arquivo ou um objeto caminho ou similar, o arquivo será escrito nesse arquivo.

  - Se for um objeto arquivo aberto, o arquivo será escrito naquele objeto arquivo, que deve estar aberto para escrita no modo bytes.

  - Se o destino for omitido (ou `Nenhum`), a fonte deverá ser um diretório e o destino será um arquivo com o mesmo nome da fonte, com uma extensão `.pyz` adicionada.

  O argumento interpreter especifica o nome do interpretador Python com o qual o arquivo será executado. Ele é escrito como uma linha “shebang” no início do arquivo. No POSIX, isso será interpretado pelo sistema operacional, e no Windows será manipulado pelo inicializador Python. Omitir o interpreter resulta em nenhuma linha shebang sendo escrita. Se um interpretador for especificado, e o alvo for um nome de arquivo, o bit executável do arquivo alvo será definido.

  O argumento main especifica o nome de um chamável que será usado como o programa principal para o arquivo. Ele só pode ser especificado se a fonte for um diretório, e a fonte ainda não contiver um arquivo `__main__.py`. O argumento main deve ter o formato “pkg.módulo:chamável” e o arquivo será executado importando “pkg.módulo” e executando o chamável fornecido sem argumentos. É um erro omitir main se a fonte for um diretório e não contiver um arquivo `__main__.py`, pois, caso contrário, o arquivo resultante não seria executável.

  O argumento opcional filter especifica uma função de retorno de chamada que recebe um objeto Path representando o caminho para o arquivo que está sendo adicionado (relativo ao diretório da fonte). Ele deve retornar `True` se o arquivo for adicionado.

  O argumento opcional compressed determina se os arquivos são compactados. Se definido como `True`, os arquivos no arquivo são compactados com o método deflate; caso contrário, os arquivos são armazenados descompactados. Este argumento não tem efeito ao copiar um arquivo existente.

  Se um objeto arquivo for especificado para source ou target, é responsabilidade do chamador fechá-lo após chamar create_archive.

  Ao copiar um arquivo existente, os objetos arquivo fornecidos precisam apenas dos métodos `read` e `readline` ou `write`. Ao criar um arquivo de um diretório, se o alvo for um objeto arquivo, ele será passado para a classe `zipfile.ZipFile` e deve fornecer os métodos necessários para essa classe.

  Novo na versão 3.7: Added the filter and compressed arguments.

`zipapp.``get_interpreter`(archive)

  Retorna o interpretador especificado na linha `#!` no início do arquivo. Se não houver nenhuma linha `#!`, retorna `None`. O argumento archive pode ser um nome de arquivo ou um objeto arquivo ou similar aberto para leitura no modo bytes. É presumido esteja no início do arquivo.

## Exemplos

Compacte um diretório em um arquivo e execute-o.

    $ python -m zipapp myapp
    $ python myapp.pyz
    <output from myapp>

O mesmo pode ser feito usando a função `create_archive()`:

    >>> import zipapp
    >>> zipapp.create_archive('myapp', 'myapp.pyz')

Para tornar o aplicativo diretamente executável no POSIX, especifique um interpretador a ser usado.

    $ python -m zipapp myapp -p "/usr/bin/env python"
    $ ./myapp.pyz
    <output from myapp>

Para substituir a linha shebang em um arquivo existente, crie um arquivo modificado usando a função `create_archive()`:

    >>> import zipapp
    >>> zipapp.create_archive('old_archive.pyz', 'new_archive.pyz', '/usr/bin/python3')

To update the file in place, do the replacement in memory using a `BytesIO` object, and then overwrite the source afterwards. Note that there is a risk when overwriting a file in place that an error will result in the loss of the original file. This code does not protect against such errors, but production code should do so. Also, this method will only work if the archive fits in memory:

    >>> import zipapp
    >>> import io
    >>> temp = io.BytesIO()
    >>> zipapp.create_archive('myapp.pyz', temp, '/usr/bin/python2')
    >>> with open('myapp.pyz', 'wb') as f:
    >>>     f.write(temp.getvalue())

## Especificando o interpretador

Observe que se você especificar um interpretador e então distribuir seu arquivo de aplicação, você precisa garantir que o interpretador usado seja portátil. O inicializador Python para Windows oferece suporte às formas mais comuns da linha POSIX `#!`, mas há outras questões a serem consideradas:

- Se você usar “/usr/bin/env python” (ou outras formas do comando “python”, como “/usr/bin/python”), você precisa considerar que seus usuários podem ter Python 2 ou Python 3 como padrão, e escrever seu código para funcionar em ambas as versões.

- Se você usar uma versão explícita, por exemplo “/usr/bin/env python3”, sua aplicação não funcionará para usuários que não tenham essa versão. (Isso pode ser o que você quer se não tiver tornado seu código compatível com Python 2).

- Não há como dizer “python X.Y ou posterior”, então tome cuidado ao usar uma versão exata como “/usr/bin/env python3.4”, pois você precisará alterar sua linha shebang para usuários do Python 3.5, por exemplo.

Normalmente, você deve usar “/usr/bin/env python2” ou “/usr/bin/env python3”, dependendo se seu código foi escrito para Python 2 ou 3.

## Criando aplicações autônomas com zipapp

Usando o módulo `zipapp`, é possível criar programas Python autocontidos, que podem ser distribuídos para usuários finais que precisam apenas ter uma versão adequada do Python instalada em seu sistema. A chave para fazer isso é agrupar todas as dependências da aplicação no arquivo, junto com o código da aplicação.

As etapas para criar um arquivo autônomo são as seguintes:

1. Crie sua aplicação em um diretório normalmente, para que você tenha um diretório `myapp` contendo um arquivo `__main__.py` e qualquer código de aplicação de suporte.

2. Instale todas as dependências da sua aplicação no diretório `myapp`, usando pip:

       $ python -m pip install -r requirements.txt --target myapp

   (isso presume que você tenha os requisitos do seu projeto em um arquivo `requirements.txt` - caso contrário, você pode simplesmente listar as dependências manualmente na linha de comando do pip).

3. Optionally, delete the `.dist-info` directories created by pip in the `myapp` directory. These hold metadata for pip to manage the packages, and as you won’t be making any further use of pip they aren’t required - although it won’t do any harm if you leave them.

4. Empacote a aplicação usando:

       $ python -m zipapp -p "interpreter" myapp

Isso produzirá um executável autônomo, que pode ser executado em qualquer máquina com o interpretador apropriado disponível. Veja Especificando o interpretador para detalhes. Ele pode ser enviado aos usuários como um único arquivo.

No Unix, o arquivo `myapp.pyz` é executável como está. Você pode renomear o arquivo para remover a extensão `.pyz` se preferir um nome de comando “simples”. No Windows, o arquivo `myapp.pyz[w]` é executável em virtude do fato de que o interpretador Python registra as extensões de arquivo `.pyz` e `.pyzw` quando instalado.

### Making a Windows executable

On Windows, registration of the `.pyz` extension is optional, and furthermore, there are certain places that don’t recognise registered extensions “transparently” (the simplest example is that `subprocess.run(['myapp'])` won’t find your application - you need to explicitly specify the extension).

On Windows, therefore, it is often preferable to create an executable from the zipapp. This is relatively easy, although it does require a C compiler. The basic approach relies on the fact that zipfiles can have arbitrary data prepended, and Windows exe files can have arbitrary data appended. So by creating a suitable launcher and tacking the `.pyz` file onto the end of it, you end up with a single-file executable that runs your application.

A suitable launcher can be as simple as the following:

    #define Py_LIMITED_API 1
    #include "Python.h"

    #define WIN32_LEAN_AND_MEAN
    #include <windows.h>

    #ifdef WINDOWS
    int WINAPI wWinMain(
        HINSTANCE hInstance,      /* handle to current instance */
        HINSTANCE hPrevInstance,  /* handle to previous instance */
        LPWSTR lpCmdLine,         /* pointer to command line */
        int nCmdShow              /* show state of window */
    )
    #else
    int wmain()
    #endif
    {
        wchar_t **myargv = _alloca((__argc + 1) * sizeof(wchar_t*));
        myargv[0] = __wargv[0];
        memcpy(myargv + 1, __wargv, __argc * sizeof(wchar_t *));
        return Py_Main(__argc+1, myargv);
    }

If you define the `WINDOWS` preprocessor symbol, this will generate a GUI executable, and without it, a console executable.

To compile the executable, you can either just use the standard MSVC command line tools, or you can take advantage of the fact that distutils knows how to compile Python source:

    >>> from distutils.ccompiler import new_compiler
    >>> import distutils.sysconfig
    >>> import sys
    >>> import os
    >>> from pathlib import Path

    >>> def compile(src):
    >>>     src = Path(src)
    >>>     cc = new_compiler()
    >>>     exe = src.stem
    >>>     cc.add_include_dir(distutils.sysconfig.get_python_inc())
    >>>     cc.add_library_dir(os.path.join(sys.base_exec_prefix, 'libs'))
    >>>     # First the CLI executable
    >>>     objs = cc.compile([str(src)])
    >>>     cc.link_executable(objs, exe)
    >>>     # Now the GUI executable
    >>>     cc.define_macro('WINDOWS')
    >>>     objs = cc.compile([str(src)])
    >>>     cc.link_executable(objs, exe + 'w')

    >>> if __name__ == "__main__":
    >>>     compile("zastub.c")

The resulting launcher uses the “Limited ABI”, so it will run unchanged with any version of Python 3.x. All it needs is for Python (`python3.dll`) to be on the user’s `PATH`.

For a fully standalone distribution, you can distribute the launcher with your application appended, bundled with the Python “embedded” distribution. This will run on any PC with the appropriate architecture (32 bit or 64 bit).

### Advertência

There are some limitations to the process of bundling your application into a single file. In most, if not all, cases they can be addressed without needing major changes to your application.

1. Se sua aplicação depende de um pacote que inclui uma extensão C, esse pacote não pode ser executado a partir de um arquivo zip (essa é uma limitação do sistema operacional, pois o código executável deve estar presente no sistema de arquivos para que o carregador do sistema operacional o carregue). Nesse caso, você pode excluir essa dependência do arquivo zip e exigir que seus usuários o tenham instalado ou enviá-lo junto com seu arquivo zip e adicionar código ao seu `__main__.py` para incluir o diretório que contém o módulo descompactado em `sys.path`. Nesse caso, você precisará certificar-se de enviar binários apropriados para sua(s) arquitetura(s) de destino (e potencialmente escolher a versão correta para adicionar ao `sys.path` no tempo de execução, com base na máquina do usuário).

2. If you are shipping a Windows executable as described above, you either need to ensure that your users have `python3.dll` on their PATH (which is not the default behaviour of the installer) or you should bundle your application with the embedded distribution.

3. The suggested launcher above uses the Python embedding API. This means that in your application, `sys.executable` will be your application, and not a conventional Python interpreter. Your code and its dependencies need to be prepared for this possibility. For example, if your application uses the `multiprocessing` module, it will need to call `multiprocessing.set_executable()` to let the module know where to find the standard Python interpreter.

## O formato de arquivo da aplicação zip Python

O Python tem sido capaz de executar arquivos zip que contêm um arquivo `__main__.py` desde a versão 2.6. Para ser executado pelo Python, um arquivo de aplicação simplesmente tem que ser um arquivo zip padrão contendo um arquivo `__main__.py` que será executado como o ponto de entrada para o aplicativo. Como de costume para qualquer script Python, o pai do script (neste caso, o arquivo zip) será colocado em `sys.path` e, portanto, outros módulos podem ser importados do arquivo zip.

O formato de arquivo zip permite que dados arbitrários sejam prefixados a um arquivo zip. O formato de aplicação zip usa essa habilidade para prefixar uma linha “shebang” padrão POSIX ao arquivo (`#!/caminho/para/interpretador`).

Formalmente, o formato de aplicação zip Python é:

1. An optional shebang line, containing the characters `b'#!'` followed by an interpreter name, and then a newline (`b'\n'`) character. The interpreter name can be anything acceptable to the OS “shebang” processing, or the Python launcher on Windows. The interpreter should be encoded in UTF-8 on Windows, and in `sys.getfilesystemencoding()` on POSIX.

2. Dados padrão do zipfile, conforme gerados pelo módulo `zipfile`. O conteúdo do zipfile deve incluir um arquivo chamado `__main__.py` (que deve estar na “raiz” do zipfile - ou seja, não pode estar em um subdiretório). Os dados do zipfile podem ser compactados ou descompactados.

Se um arquivo de aplicação tiver uma linha shebang, ele poderá ter o bit executável definido em sistemas POSIX, para permitir que seja executado diretamente.

Não há exigência de que as ferramentas neste módulo sejam usadas para criar arquivos de aplicações - o módulo é uma conveniência, mas arquivos no formato acima criados por qualquer meio são aceitáveis para Python.