Python - Guia Completo do Nuitka: Como Usar para Compilar Programas Python em Executáveis
Python - Guia Completo do Nuitka: Como Usar para Compilar Programas Python em Executáveis
Sempre crie uma frase de segurança única para jogos, Airdrops e qualquer outra coisa de origem desconhecida, em vez de usar sua carteira principal.
O Nuitka é um compilador para Python que converte programas Python em executáveis nativos. Ele não apenas compila os scripts Python em código de máquina, mas também permite que você crie pacotes independentes (executáveis) que podem ser distribuídos sem a necessidade de instalar o Python ou dependências adicionais. Neste post, vamos abordar o que é o Nuitka, como instalá-lo, como usá-lo, e explicar as opções e recursos mais importantes.
O que é o Nuitka?
O Nuitka é um compilador para Python que transforma código Python em código C, compilando-o em um executável nativo (por exemplo, .exe no Windows, ou executáveis binários no Linux). Isso traz diversas vantagens:
Desempenho: O código compilado tende a ser mais rápido do que o código Python interpretado.
Distribuição: Ao gerar um único arquivo executável, você pode distribuir seu programa sem precisar se preocupar com a instalação do Python ou dependências.
Facilidade: O Nuitka é fácil de usar e oferece diversas opções para incluir dados e pacotes junto com o executável.
Como Instalar o Nuitka
O Nuitka pode ser instalado diretamente do PyPI, usando o pip. Basta rodar o seguinte comando:
pip install nuitka
Se você estiver usando Python 3, pode ser necessário usar o comando pip3 em vez de pip:
pip3 install nuitka
Além disso, o Nuitka requer que você tenha o C compiler instalado em sua máquina, pois ele usa esse compilador para gerar o código binário. Dependendo do sistema operacional, isso pode exigir ferramentas adicionais:
Windows: Você pode instalar o compilador MSVC com o Visual Studio Build Tools.
Linux: Instale as ferramentas de desenvolvimento, como build-essential (em distribuições baseadas no Debian/Ubuntu):
sudo apt-get install build-essential
macOS: Instale as ferramentas de linha de comando do Xcode com:
xcode-select --install
Como Funciona o Nuitka?
O Nuitka trabalha em duas etapas principais:
Compilação: O código Python é convertido para C. O Nuitka cria uma árvore de sintaxe abstrata (AST) e traduz isso para código C.
Linkagem: O código C gerado é então compilado em código de máquina, criando um binário executável para o sistema operacional de destino (Windows, Linux ou macOS).
Essencialmente, o Nuitka faz o seguinte:
- Gera código C a partir do código Python.
- Compila esse código C em um executável ou biblioteca dinâmica (no caso de criar um módulo).
- Permite empacotar tudo em um único arquivo executável, se desejado.
Principais Opções e Diretivas do Nuitka
O Nuitka oferece várias opções para personalizar a forma como seu código Python é compilado. Aqui estão algumas das mais importantes:
1. --standalone
Essa opção cria uma versão autossuficiente do executável, onde todas as dependências necessárias são incluídas no mesmo diretório ou dentro do próprio executável. Ou seja, você pode rodar seu programa em uma máquina que não tenha o Python instalado.
Exemplo:
py -m nuitka --standalone main.py
2. --onefile
Com essa opção, Nuitka cria um único arquivo executável, combinando o programa Python e todas as suas dependências em um único arquivo. Esse é um ótimo recurso para distribuir seu programa de maneira simples, sem a necessidade de instalar dependências ou pacotes adicionais.
Exemplo:
py -m nuitka --onefile main.py
3. --include-data-dir
Essa opção permite incluir arquivos de dados (como imagens, fontes, arquivos de configuração, etc.) dentro do executável. Ao usar --standalone e --onefile, você precisa garantir que os recursos sejam incluídos corretamente no executável.
Sintaxe:
--include-data-dir=<diretório_fonte>=<diretório_destino>
Exemplo:
Se você tem as pastas img e fnt no seu projeto, pode incluir esses diretórios com:
py -m nuitka --standalone --onefile --include-data-dir=img=img --include-data-dir=fnt=fnt main.py
Isso empacota as pastas img e fnt no executável, e o código Python pode acessar esses recursos durante a execução.
4. --windows-icon-from-ico
Esta opção permite incluir um ícone personalizado para o executável gerado no Windows. O arquivo de ícone deve ser um arquivo .ico.
Exemplo:
py -m nuitka --windows-icon-from-ico=icon.ico main.py
5. --python-flag
Você pode usar esta opção para passar flags para o interpretador Python, como -O (otimização), -B (não gerar arquivos .pyc), etc.
Exemplo:
py -m nuitka --python-flag=-O main.py
6. --no-pyi-launcher
Em alguns casos, você pode querer desativar o launcher que o Nuitka cria quando compila o código. Isso pode ser útil se você está tentando criar um executável ainda mais enxuto.
Como Usar o Nuitka para Criar Executáveis
Vamos agora detalhar um exemplo prático. Suponha que você tenha a seguinte estrutura de diretórios:
project/main.pyimg/image.pngfnt/font.ttf
Você quer criar um executável que inclua o código Python e os arquivos de imagem e fonte. O comando seria:
py -m nuitka --standalone --onefile --include-data-dir=img=img --include-data-dir=fnt=fnt --windows-icon-from-ico=icon.ico main.py
--standalone: Cria uma versão independente do executável.
--onefile: Gera um único arquivo executável.
--include-data-dir=img=img: Inclui a pasta img dentro do executável.
--include-data-dir=fnt=fnt: Inclui a pasta fnt dentro do executável.
--windows-icon-from-ico=icon.ico: Define um ícone para o executável no Windows.
Após a execução desse comando, você terá um único arquivo executável que contém tanto o código Python quanto os recursos (imagens, fontes, etc.), e pode ser distribuído sem a necessidade de instalar o Python ou outras dependências.
Dicas e Considerações
Acesso a Recursos Dentro do Executável
Após compilar o programa, se você usar o modo --onefile, todos os arquivos de recursos (como imagens e fontes) serão comprimidos dentro do executável. Para acessar esses arquivos, use o seguinte código:
import sysimport osfrom pathlib import Path# A maneira de acessar os recursos dependendo de onde o código está sendo executadoif getattr(sys, 'frozen', False):# Se o código estiver rodando a partir do executávelresource_path = Path(sys.executable).parentelse:# Se estiver executando o código normalmenteresource_path = Path(__file__).parent# Caminho para os recursosimage_path = resource_path / 'img' / 'image.png'font_path = resource_path / 'fnt' / 'font.ttf'
Isso garante que, tanto no ambiente de desenvolvimento quanto no executável compilado, os arquivos de recursos serão encontrados corretamente.
Conclusão
O Nuitka é uma ferramenta poderosa para transformar programas Python em executáveis nativos. Ele permite que você distribua programas sem precisar se preocupar com a instalação do Python ou dependências externas, além de oferecer um aumento de desempenho ao gerar código nativo.
Ao seguir este guia, você aprendeu como instalar o Nuitka, como usá-lo para compilar seus programas, e como incluir arquivos de dados e recursos dentro do executável. Com isso, você está pronto para criar aplicações Python mais robustas e fáceis de distribuir!
Antes:
pyinstaller --onefile --hidden-import google-auth --hidden-import google-api-python-client --icon=Mercadosheet.ico mercado.py
Depois:
nuitka --standalone --onefile --include-package=google-auth --include-package=google-auth-httplib2 --include-package=google-api-python-client --include-package=pandas --include-package=requests --windows-icon-from-ico=Mercadosheet.ico mercado.py
nuitka --standalone --onefile --include-module=grpc --include-package=grpc --include-package-data=grpc --windows-icon-from-ico=Mercadosheet.ico mercado.py
Inclua o módulo explicitamente
Se o módulo estiver instalado, mas o Nuitka ainda não conseguir encontrá-lo, tente incluir o módulo google-auth de forma explícita, especificando o nome do pacote diretamente:
nuitka --standalone --onefile --include-module=google-auth --include-package=google-auth --windows-icon-from-ico=Mercadosheet.ico mercado.py
Tente usar a flag --noinclude-pytest-mode
Se o seu script usa testes ou depende do pytest, o Nuitka pode tentar excluir algumas bibliotecas no modo pytest, o que pode causar problemas com a detecção de módulos. Tente desabilitar o modo pytest se ele não for relevante para o seu script:
nuitka --standalone --onefile --include-module=google-auth --noinclude-pytest-mode --windows-icon-from-ico=Mercadosheet.ico mercado.py
Use a flag --follow-imports
Essa flag garante que todos os módulos importados serão incluídos no processo de compilação. Caso o módulo google-auth seja importado por outro módulo, essa flag pode ajudar a resolver o problema:
nuitka --standalone --onefile --follow-imports --windows-icon-from-ico=Mercadosheet.ico mercado.py
Copie manualmente o google-auth para o diretório de build
Se nada mais funcionar, você pode tentar copiar manualmente o módulo google-auth para o diretório de saída do build. Após a compilação com o Nuitka, copie os arquivos do módulo do seu ambiente Python para o diretório onde o executável standalone foi gerado.
Passo a Passo: Como Copiar Manualmente o Módulo google-auth para o Diretório de Build
1. Verifique o Diretório de Build do Nuitka
Após rodar o comando do Nuitka, ele cria um diretório de build (por padrão, esse diretório se chama build ou dist na mesma pasta onde você rodou o comando). Esse diretório contém os arquivos necessários para o executável standalone.
Por exemplo, se você rodou o comando como:
nuitka --standalone --onefile --include-module=google-auth --windows-icon-from-ico=Mercadosheet.ico mercado.py
Após a execução, o diretório de saída do Nuitka deve estar localizado dentro da pasta onde você executou o comando e pode ser chamado de algo como mercado.dist ou mercado.build (dependendo da sua configuração). No caso de um build standalone com --onefile, o executável final estará dentro desse diretório.
2. Localize o Módulo google-auth no Seu Ambiente Python
Agora, você precisa localizar o diretório onde o módulo google-auth está instalado no seu ambiente Python. Isso pode ser feito com o comando:
pip show google-auth
Esse comando vai mostrar a localização do módulo. A saída será algo assim:
Name: google-auth
Version: x.y.z
Summary: Google Authentication Library
Home-page: https://googleapis.github.io/google-auth-library-python/
Author: Google Inc.
Author-email: googleapis-packages@google.com
License: Apache 2.0
Location: C:\Users\<seu_usuario>\AppData\Local\Programs\Python\Python38\Lib\site-packages
Anote o caminho do diretório, que no exemplo acima é:
C:\Users\<seu_usuario>\AppData\Local\Programs\Python\Python38\Lib\site-packages
3. Copie os Arquivos do Módulo google-auth
Agora, vá até o diretório de instalação do google-auth (no caminho mostrado acima, o diretório seria site-packages/google_auth).
Dentro deste diretório, você verá uma pasta chamada google_auth (o nome pode variar ligeiramente, dependendo da versão ou de outros módulos relacionados).
Copie a pasta google_auth e todos os seus arquivos (incluindo submódulos e dependências) para o diretório de saída do seu build, onde o executável foi gerado.
4. Cole no Diretório de Build do Executável
Localize o diretório onde o executável standalone foi gerado (algo como mercado.dist ou mercado.build), e cole a pasta google_auth lá dentro. O caminho seria algo como:
bash
Copiar código
mercado.dist/
│
├── google_auth/ # Cole a pasta google_auth aqui
├── mercado.exe # Executável gerado pelo Nuitka
├── ...
5. Verifique a Inclusão do Módulo
Após copiar o módulo google-auth para o diretório de build, o Nuitka deve ser capaz de encontrar o módulo quando o executável for executado, porque o módulo agora estará diretamente no diretório com o executável.
6. Teste o Executável Standalone
Agora, tente rodar o executável gerado. Vá até o diretório onde o executável foi gerado e execute o arquivo mercado.exe (ou o nome do seu executável). Ele deve conseguir importar o módulo google-auth sem problemas.
Dicas Finais:
Se o módulo google-auth depender de outros módulos externos, você também precisará copiá-los para o diretório de build.
Se o seu código usar outros módulos que não foram incluídos automaticamente, repita esse processo para cada módulo.
Embora isso seja uma solução manual, é útil quando o Nuitka não consegue incluir todos os módulos necessários de forma automática.
Nenhum comentário
Comente só assim vamos crescer juntos!
Observação: somente um membro deste blog pode postar um comentário.