Alguém pode explicar o que setup.py
é e como pode ser configurado ou usado?
Alguém pode explicar o que setup.py
é e como pode ser configurado ou usado?
Respostas:
setup.py
é um arquivo python, que normalmente informa que o módulo / pacote que você está prestes a instalar foi empacotado e distribuído com o Distutils, que é o padrão para a distribuição de módulos Python.
Isso permite que você instale facilmente pacotes Python. Muitas vezes, basta escrever:
$ pip install .
pip
irá usar o setup.py para instalar o seu módulo. Evite ligar setup.py
diretamente.
https://docs.python.org/3/installing/index.html#installing-index
setup.py
arquivo.
Isso ajuda a instalar um pacote python foo
em sua máquina (também pode estar virtualenv
) para que você possa importar o pacote foo
de outros projetos e também dos prompts [I] Python.
Faz o mesmo trabalho de pip
, easy_install
etc.,
Usando setup.py
Vamos começar com algumas definições:
Pacote - Uma pasta / diretório que contém o __init__.py
arquivo.
Módulo - Um arquivo python válido com .py
extensão.
Distribuição - Como um pacote se relaciona com outros pacotes e módulos .
Digamos que você deseja instalar um pacote chamado foo
. Então você faz,
$ git clone https://github.com/user/foo
$ cd foo
$ python setup.py install
Em vez disso, se você não deseja realmente instalá-lo, mas ainda deseja usá-lo. Então faça,
$ python setup.py develop
Este comando criará links simbólicos para o diretório de origem nos pacotes de sites em vez de copiar coisas. Por isso, é bastante rápido (principalmente para pacotes grandes).
Criando setup.py
Se você tem sua árvore de pacotes como,
foo
├── foo
│ ├── data_struct.py
│ ├── __init__.py
│ └── internals.py
├── README
├── requirements.txt
└── setup.py
Em seguida, faça o seguinte em seu setup.py
script para que ele possa ser instalado em alguma máquina:
from setuptools import setup
setup(
name='foo',
version='1.0',
description='A useful module',
author='Man Foo',
author_email='foomail@foo.com',
packages=['foo'], #same as name
install_requires=['bar', 'greek'], #external packages as dependencies
)
Em vez disso, se sua árvore de pacotes for mais complexa como a abaixo:
foo
├── foo
│ ├── data_struct.py
│ ├── __init__.py
│ └── internals.py
├── README
├── requirements.txt
├── scripts
│ ├── cool
│ └── skype
└── setup.py
Então, setup.py
nesse caso, você seria como:
from setuptools import setup
setup(
name='foo',
version='1.0',
description='A useful module',
author='Man Foo',
author_email='foomail@foo.com',
packages=['foo'], #same as name
install_requires=['bar', 'greek'], #external packages as dependencies
scripts=[
'scripts/cool',
'scripts/skype',
]
)
Adicione mais itens a ( setup.py
) e torne-o decente:
from setuptools import setup
with open("README", 'r') as f:
long_description = f.read()
setup(
name='foo',
version='1.0',
description='A useful module',
license="MIT",
long_description=long_description,
author='Man Foo',
author_email='foomail@foo.com',
url="http://www.foopackage.com/",
packages=['foo'], #same as name
install_requires=['bar', 'greek'], #external packages as dependencies
scripts=[
'scripts/cool',
'scripts/skype',
]
)
O long_description
é usado em pypi.org como a descrição README do seu pacote.
E finalmente, agora você está pronto para fazer o upload do seu pacote para o PyPi.org, para que outras pessoas possam instalar o seu pacote usando pip install yourpackage
.
O primeiro passo é reivindicar o nome e o espaço do seu pacote no pypi usando:
$ python setup.py register
Depois que o nome do seu pacote estiver registrado, ninguém poderá reivindicá-lo ou usá-lo. Após o registro bem-sucedido, você deve fazer o upload do seu pacote para lá (na nuvem),
$ python setup.py upload
Opcionalmente, você também pode assinar seu pacote com GPG
,
$ python setup.py --sign upload
Bônus : Veja uma amostra setup.py
de um projeto real aqui:torchvision-setup.py
requests
) tem esse projeto para dar explicitamente um bom exemplo de setup.py - github.com/kennethreitz/setup.py
setup.py
é a resposta do Python para um instalador e make
arquivo multiplataforma .
Se você estiver familiarizado com instalações de linha de comando, será make && make install
traduzido para python setup.py build && python setup.py install
.
Alguns pacotes são Python puro e são apenas compilados em bytes. Outros podem conter código nativo, o que exigirá um compilador nativo (como gcc
ou cl
) e um módulo de interface Python (como swig
ou pyrex
).
python setup.py install
na verdade, é executado python setup.py build
primeiro (portanto, você não precisa executá-los separadamente, a menos que em casos específicos). Eu acredito que make
sempre precisa ser executado manualmente antes de executar make install
.
make
não é necessário nenhum parâmetro específico (ou pedido): depende completamente do criador dos Makefile
"alvos" disponíveis (e em que ordem eles precisam ser chamados). Como o bare Makefile
s (geralmente) não é muito portátil, eles tendem a ser gerados usando comandos como ./configure
(autotools) ou cmake .
(cmake) e, portanto, cabe a esses programas definir se você precisa executar explicitamente make
antes make install
ou não.
Se você baixou o pacote que possui "setup.py" na pasta raiz, é possível instalá-lo executando
python setup.py install
Se você está desenvolvendo um projeto e está se perguntando para que serve esse arquivo, consulte a documentação do Python ao escrever o script de instalação
setup.py
é um script Python que geralmente é fornecido com bibliotecas ou programas, escritos nessa linguagem. Seu objetivo é a instalação correta do software.
Muitos pacotes usam a distutils
estrutura em conjunto com setup.py
.
O setup.py pode ser usado em dois cenários: primeiro, você deseja instalar um pacote Python. Segundo, você deseja criar seu próprio pacote Python. Geralmente, o pacote Python padrão possui alguns arquivos importantes, como setup.py, setup.cfg e Manifest.in. Ao criar o pacote Python, esses três arquivos determinarão o nome (conteúdo em PKG-INFO na pasta egg-info), versão, descrição, outras instalações necessárias (geralmente no arquivo .txt) e alguns outros parâmetros. O setup.cfg é lido por setup.py enquanto o pacote é criado (pode ser tar.gz). Manifest.in é onde você pode definir o que deve ser incluído no seu pacote. De qualquer forma, você pode fazer várias coisas usando o setup.py como
python setup.py build
python setup.py install
python setup.py sdist <distname> upload [-r urltorepo] (to upload package to pypi or local repo)
Existem muitos outros comandos que podem ser usados com o setup.py. para ajuda
python setup.py --help-commands
python setup.py --help-commands
. Muito útil ao cavar no setup.py.
Ao baixar um pacote, setup.py
abra o Terminal (Mac, Linux) ou o Prompt de Comando (Windows). Usando cd
e ajudando você com o botão Tab, defina o caminho até a pasta em que você baixou o arquivo e onde há setup.py
:
iMac:~ user $ cd path/pakagefolderwithsetupfile/
Pressione enter, você verá algo parecido com isto:
iMac:pakagefolderwithsetupfile user$
Digite depois disso python setup.py install
:
iMac:pakagefolderwithsetupfile user$ python setup.py install
Pressione enter
. Feito!
Para instalar um pacote Python que você baixou, extraia o arquivo e execute o script setup.py dentro:
python setup.py install
Para mim, isso sempre foi estranho. Seria mais natural apontar um gerenciador de pacotes para o download, como faria em Ruby e Nodejs, por exemplo.gem install rails-4.1.1.gem
Um gerenciador de pacotes também é mais confortável, porque é familiar e confiável. Por outro lado, cada um setup.py
é novo, porque é específico ao pacote. Exige fé na convenção "Eu confio neste setup.py executa os mesmos comandos que outros que usei no passado". Essa é uma taxa lamentável para a força de vontade mental.
Não estou dizendo que o fluxo de trabalho setup.py é menos seguro do que um gerenciador de pacotes (eu entendo que o Pip executa o setup.py por dentro), mas certamente sinto que é complicado e dissonante. Existe uma harmonia nos comandos, todos no mesmo aplicativo gerenciador de pacotes. Você pode até gostar disso.
setup.py
é um arquivo Python como qualquer outro. Pode levar qualquer nome, exceto por convenção que é chamadosetup.py
para que não haja um procedimento diferente para cada script.
Com mais freqüência setup.py
é usado para instalar um módulo Python, mas o servidor tem outros propósitos:
Módulos:
Talvez esse seja o uso mais famoso dos setup.py
módulos. Embora possam ser instalados usando pip
, versões antigas do Python não incluíam pip
por padrão e precisavam ser instaladas separadamente.
Se você queria instalar um módulo, mas não quis instalar pip
, a única alternativa era instalar o módulo a partir do setup.py
arquivo. Isso poderia ser alcançado via python setup.py install
. Isso instalaria o módulo Python no dicionário raiz (sem pip
, easy_install
ect).
Este método é frequentemente usado quando pip
falhará. Por exemplo, se a versão correta do Python do pacote desejado não estiver disponível via pip
talvez porque não seja mais mantida, o download do código-fonte e da execução python setup.py install
executaria a mesma coisa, exceto no caso de binários compilados serem necessários (mas desconsiderará o Versão Python - a menos que seja retornado um erro).
Outro uso setup.py
é instalar um pacote da fonte. Se um módulo ainda estiver em desenvolvimento, os arquivos wheel não estarão disponíveis e a única maneira de instalar é instalar diretamente da fonte.
Construindo extensões Python:
Quando um módulo é construído, ele pode ser convertido em módulo pronto para distribuição usando um script de instalação do distutils . Uma vez construídos, eles podem ser instalados usando o comando acima.
Um script de instalação é fácil de construir e uma vez que o arquivo foi configurado corretamente e pode ser compilado executando python setup.py build
(consulte o link para todos os comandos).
Mais uma vez, é nomeado setup.py
para facilitar o uso e por convenção, mas pode assumir qualquer nome.
Cython:
Outro uso famoso de setup.py
arquivos inclui extensões compiladas. Isso requer um script de configuração com valores definidos pelo usuário. Eles permitem uma execução rápida (mas uma vez compilada depende da plataforma). Aqui está um exemplo simples da documentação :
from distutils.core import setup
from Cython.Build import cythonize
setup(
name = 'Hello world app',
ext_modules = cythonize("hello.pyx"),
)
Isso pode ser compilado via python setup.py build
Cx_Freeze:
Outro módulo que requer um script de instalação é cx_Freeze
. Isso converte o script Python em executáveis. Isso permite que muitos comandos, como descrições, nomes, ícones, pacotes, incluam, excluam ect e, uma vez executados, produzirão um aplicativo distribuível. Um exemplo da documentação :
import sys
from cx_Freeze import setup, Executable
build_exe_options = {"packages": ["os"], "excludes": ["tkinter"]}
base = None
if sys.platform == "win32":
base = "Win32GUI"
setup( name = "guifoo",
version = "0.1",
description = "My GUI application!",
options = {"build_exe": build_exe_options},
executables = [Executable("guifoo.py", base=base)])
Isso pode ser compilado via python setup.py build
.
Então, o que é um setup.py
arquivo?
Simplesmente, é um script que cria ou configura algo no ambiente Python.
Um pacote quando distribuído deve conter apenas um script de instalação, mas não é incomum combinar vários em um único script de instalação. Observe que isso geralmente envolve, distutils
mas nem sempre (como mostrei no meu último exemplo). A única coisa a lembrar é que apenas configura o pacote / script Python de alguma forma.
Leva o nome para que o mesmo comando sempre possa ser usado ao criar ou instalar.
Para simplificar, o setup.py é executado como "__main__"
quando você chama as funções de instalação das outras respostas mencionadas. Dentro do setup.py, você deve colocar tudo o necessário para instalar o seu pacote.
As duas seções a seguir discutem duas coisas que muitos módulos setup.py possuem.
Esta função permite especificar atributos do projeto, como o nome do projeto, a versão .... Mais importante, essa função permite instalar outras funções, se estiverem empacotadas corretamente. Consulte esta página da Web para obter um exemplo de setuptools.setup
Esses atributos de setuptools.setup permitem a instalação desses tipos de pacotes:
Pacotes que são importados para o seu projeto e listados no PyPI usando setuptools.findpackages :
packages=find_packages(exclude=["docs","tests", ".gitignore", "README.rst","DESCRIPTION.rst"])
Pacotes que não estão em PyPI , mas podem ser baixados de uma URL usando dependency_links
dependency_links=["http://peak.telecommunity.com/snapshots/",]
Em um mundo ideal, setuptools.setup
iria lidar com tudo para você. Infelizmente, isso nem sempre é o caso. Às vezes, você precisa fazer coisas específicas, como instalar dependências com o comando subprocess , para obter o sistema no qual você está instalando no estado certo para o seu pacote. Tente evitar isso, essas funções ficam confusas e geralmente diferem entre SO e distribuição uniforme .