Script de pós-instalação com ferramentas de configuração Python

É possível especificar um arquivo de script Python pós-instalação como parte do arquivo setuptools setup.py para que um usuário possa executar o comando:

python setup.py install

em um arquivo de projeto local, ou

pip install <name>

para um projeto PyPI e o script será executado na conclusão da instalação do setuptools padrão? Estou procurando realizar tarefas pós-instalação que podem ser codificadas em um único arquivo de script Python (por exemplo, entregar uma mensagem pós-instalação personalizada ao usuário, extrair arquivos de dados adicionais de um repositório de origem remoto diferente).

Eu encontrei esta resposta SO de vários anos atrás que aborda o tópico e parece que o consenso na época era que você precisa criar um subcomando de instalação. Se esse ainda for o caso, seria possível alguém fornecer um exemplo de como fazer isso para que não seja necessário que o usuário digite um segundo comando para executar o script?

Nota: A solução abaixo só funciona ao instalar um zip ou tarball de distribuição de código-fonte, ou instalar em modo editável a partir de uma árvore de código-fonte. Ele vai não funciona quando instalando a partir de uma roda de binário ( .whl)

Esta solução é mais transparente:

Você fará alguns acréscimos setup.pye não há necessidade de um arquivo extra.

Além disso, você precisa considerar duas pós-instalações diferentes; um para o modo de desenvolvimento / editável e o outro para o modo de instalação.

Adicione essas duas classes que incluem seu script pós-instalação para setup.py:

from setuptools import setup
from setuptools.command.develop import develop
from setuptools.command.install import install


class PostDevelopCommand(develop):
    """Post-installation for development mode."""
    def run(self):
        develop.run(self)
        # PUT YOUR POST-INSTALL SCRIPT HERE or CALL A FUNCTION

class PostInstallCommand(install):
    """Post-installation for installation mode."""
    def run(self):
        install.run(self)
        # PUT YOUR POST-INSTALL SCRIPT HERE or CALL A FUNCTION

e insira o cmdclassargumento para setup()funcionar em setup.py:

setup(
    ...

    cmdclass={
        'develop': PostDevelopCommand,
        'install': PostInstallCommand,
    },

    ...
)

Você pode até chamar comandos shell durante a instalação, como neste exemplo, que faz a preparação de pré-instalação:

from setuptools import setup
from setuptools.command.develop import develop
from setuptools.command.install import install
from subprocess import check_call


class PreDevelopCommand(develop):
    """Pre-installation for development mode."""
    def run(self):
        check_call("apt-get install this-package".split())
        develop.run(self)

class PreInstallCommand(install):
    """Pre-installation for installation mode."""
    def run(self):
        check_call("apt-get install this-package".split())
        install.run(self)


setup(
    ...

PS, não há nenhum ponto de entrada de pré-instalação disponível nas ferramentas de configuração. Leia esta discussão se você está se perguntando por que não há nenhum.

Nota: A solução abaixo só funciona ao instalar um zip ou tarball de distribuição de código-fonte, ou instalar em modo editável a partir de uma árvore de código-fonte. Ele vai não funciona quando instalando a partir de uma roda de binário ( .whl)

Esta é a única estratégia que funcionou para mim quando o script pós-instalação exige que as dependências do pacote já tenham sido instaladas:

import atexit
from setuptools.command.install import install


def _post_install():
    print('POST INSTALL')


class new_install(install):
    def __init__(self, *args, **kwargs):
        super(new_install, self).__init__(*args, **kwargs)
        atexit.register(_post_install)


setuptools.setup(
    cmdclass={'install': new_install},

Nota: A solução abaixo só funciona ao instalar um zip ou tarball de distribuição de código-fonte, ou instalar em modo editável a partir de uma árvore de código-fonte. Ele vai não funciona quando instalando a partir de uma roda de binário ( .whl)

Uma solução poderia ser a de incluir um post_setup.pyno setup.pydiretório 's. post_setup.pyconterá uma função que faz a pós-instalação e setup.pysó irá importá-la e iniciá-la no momento apropriado.

Em setup.py:

from distutils.core import setup
from distutils.command.install_data import install_data

try:
    from post_setup import main as post_install
except ImportError:
    post_install = lambda: None

class my_install(install_data):
    def run(self):
        install_data.run(self)
        post_install()

if __name__ == '__main__':
    setup(
        ...
        cmdclass={'install_data': my_install},
        ...
    )

Em post_setup.py:

def main():
    """Do here your post-install"""
    pass

if __name__ == '__main__':
    main()

Com a ideia comum de iniciar a setup.pypartir de seu diretório, você será capaz de importar, caso post_setup.pycontrário, ele iniciará uma função vazia.

Em post_setup.py, a if __name__ == '__main__':instrução permite que você inicie manualmente a pós-instalação a partir da linha de comando.

Combinando as respostas de @Apalala, @Zulu e @mertyildiran; isso funcionou para mim em um ambiente Python 3.5:

import atexit
import os
import sys
from setuptools import setup
from setuptools.command.install import install

class CustomInstall(install):
    def run(self):
        def _post_install():
            def find_module_path():
                for p in sys.path:
                    if os.path.isdir(p) and my_name in os.listdir(p):
                        return os.path.join(p, my_name)
            install_path = find_module_path()

            # Add your post install code here

        atexit.register(_post_install)
        install.run(self)

setup(
    cmdclass={'install': CustomInstall},
...

Isso também dá acesso ao caminho de instalação do pacote em install_path, para fazer algum trabalho no shell.

Acho que a maneira mais fácil de realizar a pós-instalação e manter os requisitos é decorar a chamada para setup(...):

from setup tools import setup


def _post_install(setup):
    def _post_actions():
        do_things()
    _post_actions()
    return setup

setup = _post_install(
    setup(
        name='NAME',
        install_requires=['...
    )
)

Isso será executado setup()ao declarar setup. Depois de concluída a instalação dos requisitos, ele executará a _post_install()função, que executará a função interna _post_actions().

Se estiver usando atexit, não há necessidade de criar um novo cmdclass. Você pode simplesmente criar seu registro atexit antes da chamada setup (). Ele faz a mesma coisa.

Além disso, se você precisa que as dependências sejam instaladas primeiro, isso não funciona com a instalação do pip, pois seu manipulador atexit será chamado antes que o pip mova os pacotes para o lugar.

Não consegui resolver um problema com nenhuma das recomendações apresentadas, então aqui está o que me ajudou.

Você pode chamar a função, que deseja executar após a instalação apenas depois setup()em setup.py, assim:

from setuptools import setup

def _post_install():
    <your code>

setup(...)

_post_install()