Desejo colocar um programa python no GitHub e ter outras pessoas para fazer o download e executá-lo em seus computadores com sistemas operacionais variados. Eu sou relativamente novo no python, mas o usei o suficiente para ter notado que fazer com que as diversas versões de todos os módulos incluídos funcionem juntos pode ser problemática. Acabei de descobrir o uso de requirements.txt(gerado pipreqse implantado com o comando pip install -r /path/to/requirements.txt), mas fiquei muito surpreso ao perceber que requirements.txt, na verdade, não indica qual versão do python está sendo usada; portanto, obviamente, não é a solução completa por si só. Portanto, minha pergunta é: que conjunto de especificações / arquivos / outra coisa é necessária para garantir que alguém que esteja baixando meu projeto possa executá-lo com o menor número possível de problemas.

EDIT: Meu plano era ser guiado por qualquer resposta que recebesse mais votos. Mas até agora, após 4 respostas e 127 visualizações, nem uma única resposta tem um voto positivo. Se algumas das respostas não forem boas, seria útil ver alguns comentários sobre por que elas não são boas.

Você já pensou em configurar um setup.pyarquivo? É uma maneira prática de agrupar todas as suas ... bem configurações em um único local. Portanto, tudo que seu usuário precisa fazer é A) clonar seu repositório e B) executar pip install .para executar osetup.py

Há uma grande discussão sobre isso.

Bem como um exemplo de identificador escrito pelo solicitante.

Isso deve cobrir a maioria dos casos de uso. Agora, se você deseja torná-lo verdadeiramente distribuível, convém configurá-lo no PyPi , o hub de distribuição oficial.

Além disso, se você está perguntando como tornar um programa "independente do SO", não existe um tamanho único. Depende do que você está fazendo com o seu código. Requer pesquisar como o seu código específico interage com os SOs, etc.

Existem muitas, muitas, muitas, muitas, muitas, muitas maneiras de fazer isso. Vou analisar os princípios por trás de cada um, e é o caso de uso.

1. Um ambiente python

Existem diversas formas de fazer isto. pipenv, condomínio requirments.txt, etc etc.

Com alguns deles, você pode especificar versões do python. Com outras pessoas, basta especificar um intervalo de versões do python com as quais você sabe que funciona - por exemplo, se você estiver usando o python 3.7, é improvável que não suporte o 3.6; há apenas uma ou duas pequenas alterações. 3.8 também deve funcionar.

Outro método semelhante é setup.py. Eles geralmente são usados ​​para distribuir bibliotecas - como PyInstaller (outra solução que mencionarei abaixo), ou numpy, wxPython ou PyQt5 etc. - para uso na importação / linha de comando. O guia de empacotamento python é bastante útil, e há muitos tutoriais por aí. (google python setup.py tutorial) Você também pode especificar requisitos nesses arquivos.

2. Um contêiner

Docker é o grande. Se você nunca ouviu falar, ficarei surpreso. Um rápido google de um resumo vem com isso , do qual cito parte:

Então, por que todo mundo adora containers e Docker? James Bottomley, ex-CTO de virtualização de servidores da Parallels e um dos principais desenvolvedores de kernel do Linux, explicou os hipervisores de VM, como Hyper-V, KVM e Xen, todos "baseados na emulação de hardware virtual. Isso significa que eles são gordos em termos de requisitos de sistema."

Os contêineres, no entanto, usam sistemas operacionais compartilhados. Isso significa que eles são muito mais eficientes do que os hipervisores em termos de recursos do sistema. Em vez de virtualizar o hardware, os contêineres ficam sobre uma única instância do Linux. Isso significa que você pode "deixar para trás o lixo inútil de 99,9% da VM, deixando uma cápsula pequena e limpa contendo seu aplicativo"

Isso deve resumir para você. (Observe que você não precisa de um sistema operacional específico para contêineres.)

3. Um arquivo executável

Existem 2 ferramentas principais que fazem isso no momento da escrita. PyInstaller e cx_Freeze. Ambos são desenvolvidos ativamente. Ambos são de código aberto.

Você pega seu script e a ferramenta o compila no bytecode, localiza as importações, copia-as e cria um ambiente python portátil que executa seu script no sistema de destino sem que o usuário final precise de python.

Pessoalmente, prefiro o PyInstaller - sou um dos desenvolvedores. O PyInstaller fornece todas as suas funcionalidades por meio de um script de linha de comando e suporta a maioria das bibliotecas que você pode imaginar - e é extensível para suportar mais. cx_Freeze requer um script de instalação.

Ambas as ferramentas suportam janelas, Linux, macOS e muito mais. O PyInstaller pode criar exes de arquivo único ou um pacote de uma pasta, enquanto o cx_Freeze suporta apenas pacotes de uma pasta. O PyInstaller 3.6 suporta python 2.7 e 3.5-3.7 - mas o 4.0 não suporta o python 2. O cx_Freeze abandonou o suporte ao python 2 a partir da última versão principal (6.0 acho).

Enfim, basta sobre os recursos das ferramentas; você mesmo pode olhar para eles. (Consulte https://pyinstaller.org e https://cx-freeze.readthedocs.io para obter mais informações)

Ao usar esse método de distribuição, você geralmente fornece o código-fonte no repositório do GitHub, alguns exes (um para cada plataforma) prontos para download e instruções sobre como criar o código em um arquivo executável.

A melhor ferramenta que usei até agora para isso é o Pipenv . Não apenas unifica e simplifica todo o fluxo de trabalho do pip + virtualenv para você, desenvolvedor, mas também garante que as versões exatas de todas as dependências (incluindo o próprio Python) sejam atendidas quando outras pessoas executam seu projeto com ele.

O site do projeto faz um bom trabalho ao explicar como usar a ferramenta, mas, por uma questão de exaustividade, darei uma breve explicação aqui.

Depois de instalar o Pipenv (por exemplo, executando pip install --user pipenv), você pode ir para o diretório do seu projeto e executar pipenv --python 3.7, para que o Pipenv crie um novo virtualenv para o seu projeto, crie um Pipfile e um Pipfile.lock (mais sobre eles posteriormente) . Se você for em frente e executar pipenv install -r requirements.txt, instalará todos os seus pacotes. Agora você pode fazer um pipenv shellpara ativar seu novo virtualenv ou pipenv run your_main_file.pysimplesmente executar seu projeto.

Agora, vamos dar uma olhada no conteúdo do seu Pipfile. Deve ser algo parecido com isto:

[packages]
Django = "*"
djangorestframework = "*"
iso8601 = "*"
graypy = "*"
whitenoise = "*"

[requires]
python_version = "3.7"

Este arquivo tem as especificações legíveis por humanos para as dependências do seu projeto (observe que ele também especifica a versão do Python). Se seus requisitos.txt tivessem versões fixadas, seu Pipfile também poderia tê-las, mas você pode seguramente curingá-las, porque as versões exatas são armazenadas no Pipfile.lock. Agora você pode executar coisas como pipenv updateatualizar suas dependências e não se esqueça de confirmar o Pipfile e o Pipfile.lock no seu VCS.

Uma vez que as pessoas clonam seu projeto, tudo o que elas precisam fazer é executar pipenv installe o Pipenv cuidará do resto (pode até instalar a versão correta do Python para elas).

Espero que isso tenha sido útil. Eu não sou afiliado de forma alguma ao Pipenv, só queria compartilhar essa ferramenta incrível.

Se seu programa é menos sobre GUI ou possui uma GUI da Web, você pode compartilhar o código usando o Google Colaboratory.

https://colab.research.google.com/

Todos podem executá-lo com o mesmo ambiente. Não há necessidade de instalação.

Caso a conversão de todos os seus scripts python em um executável possa ajudá-lo, minha resposta abaixo ajudaria ...

Desenvolvo um grande aplicativo de desktop puramente em python desde 3 anos. É uma ferramenta baseada em GUI, construída sobre a biblioteca pyqt (ligações em python da estrutura QT C ++).

Atualmente, estou usando a biblioteca de pacotes " py2exe ": é uma extensão distutils que permite criar programas executáveis ​​independentes do Windows (32 e 64 bits) a partir de scripts Python; tudo o que você precisa fazer é:

1. instalar py2exe: 'pip install py2exe'

2. Crie um script setup.py: é usado para especificar o conteúdo do EXE final (nome, ícone, autor, arquivos de dados, bibliotecas compartilhadas, etc.)

3. Executar: python setup.py py2exe

Também estou usando o software "Inno Setup" para criar o instalador: Criando atalhos, definindo variáveis ​​de ambiente, ícones, etc.

Eu acho que você pode usar o docker com seu python https://github.com/celery/celery/tree/tree/master/docker

siga os arquivos e acho que você pode descobrir o caminho para criar seu arquivo docker para seus scripts python!

Como faltam as outras respostas, gostaria de adicionar um aspecto completamente diferente:

Teste de unidade. Ou teste em geral.

Geralmente, é bom ter uma boa configuração conhecida. Dependendo de quais são as dependências do programa, pode ser necessário testar diferentes combinações de pacotes. Você pode fazer isso de maneira automatizada com, por exemplo, toxou como parte de um pipeline de CI / CD.

Não há regra geral sobre qual combinação de pacotes deve ser testada, mas geralmente a compatibilidade com python2 / 3 é um problema importante. Se você possui fortes dependências de pacotes com grandes diferenças de versão, considere testar essas versões diferentes.

Vou dar um breve resumo de algumas das soluções disponíveis existentes no que diz respeito ao pacote python que você pode escolher (conhecimento é poder):

1. Siga as diretrizes fornecidas em Estruturando seu projeto , essas convenções são amplamente aceitas pela comunidade python e geralmente é um bom ponto de partida quando os novatos começam a codificar em python. Seguindo essas diretrizes, os pythonists que assistem ao seu projeto / fonte no github ou em outros locais semelhantes saberão imediatamente como instalá-lo. Além disso, o upload do seu projeto para o pypi e a adição do IC seguindo essas regras serão fáceis.

2. Depois que seu projeto estiver estruturado adequadamente, de acordo com as convenções padrão, a próxima etapa poderá ser usar alguns dos freezers disponíveis , caso você queira enviar aos usuários finais um pacote que eles podem instalar sem forçá-los a ter o python instalado em seus máquinas Esteja ciente de que essas ferramentas não fornecerão a você nenhuma proteção de código ... dito o contrário, extrair o código python original dos artefatos finais seria trivial em todos os casos

3. Se você ainda deseja enviar seu projeto para seus usuários sem forçá-los a instalar qualquer dependência de desenvolvedor e também se preocupa com a proteção de código, para não considerar nenhum dos freezers existentes, use ferramentas como nuitka , shedskin , cython ou similares. Normalmente, reverter o código dos artefatos produzidos por essas ferramentas não é nada trivial ... Por outro lado, a proteção contra rachaduras é uma questão diferente e, a menos que você não forneça um binário físico para o usuário final, não poderá fazer muito. sobre isso, além de atrasá-los :)

4. Além disso, no caso de você precisar usar idiomas externos no seu projeto python, outro link clássico que vem à mente seria https://wiki.python.org/moin/IntegratingPythonWithOtherLanguages , adicionando os sistemas de construção dessas ferramentas ao CI, seguindo regras de 1 seria bem fácil.

Dito isso, sugiro que atenha-se ao ponto 1, pois sei que será mais do que suficiente para você começar, também esse ponto em particular deve abranger muitos dos casos de uso existentes para projetos "padrão" do python.

Embora este não seja um guia completo, siga aqueles que você poderá publicar seu projeto python para as massas rapidamente.