Secuencia de comandos posterior a la instalación con herramientas de configuración de Python

¿Es posible especificar un archivo de secuencia de comandos de Python posterior a la instalación como parte del archivo setuptools setup.py para que un usuario pueda ejecutar el comando?

python setup.py install

en un archivo de archivo de proyecto local, o

pip install <name>

para un proyecto PyPI y el script se ejecutará al finalizar la instalación de las herramientas de configuración estándar? Estoy buscando realizar tareas posteriores a la instalación que se puedan codificar en un solo archivo de secuencia de comandos de Python (por ejemplo, entregar un mensaje personalizado posterior a la instalación al usuario, extraer archivos de datos adicionales de un repositorio de origen remoto diferente).

Me encontré con esta respuesta SO de hace varios años que aborda el tema y parece que el consenso en ese momento era que necesita crear un subcomando de instalación. Si ese sigue siendo el caso, ¿sería posible que alguien proporcione un ejemplo de cómo hacer esto para que no sea necesario que el usuario ingrese un segundo comando para ejecutar el script?

Nota: La siguiente solución solo funciona cuando se instala un archivo comprimido o tarball de distribución de código fuente, o se instala en modo editable desde un árbol de código fuente. Será no trabajar cuando se instala desde una rueda binario ( .whl)

Esta solución es más transparente:

Hará algunas adiciones setup.pyy no es necesario un archivo adicional.

También debe considerar dos posinstalaciones diferentes; uno para el modo de desarrollo / editable y el otro para el modo de instalación.

Agregue estas dos clases que incluyen su secuencia de comandos posterior a la instalación 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 inserte el cmdclassargumento para setup()funcionar en setup.py:

setup(
    ...

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

    ...
)

Incluso puede llamar a comandos de shell durante la instalación, como en este ejemplo que hace la preparación previa a la instalación:

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(
    ...

PD: no hay puntos de entrada de preinstalación disponibles en setuptools. Lea esta discusión si se pregunta por qué no hay ninguno.

Nota: La siguiente solución solo funciona cuando se instala un archivo comprimido o tarball de distribución de código fuente, o se instala en modo editable desde un árbol de código fuente. Será no trabajar cuando se instala desde una rueda binario ( .whl)

Esta es la única estrategia que me ha funcionado cuando el script posterior a la instalación requiere que las dependencias del paquete ya se hayan instalado:

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: La siguiente solución solo funciona cuando se instala un archivo comprimido o tarball de distribución de código fuente, o se instala en modo editable desde un árbol de código fuente. Será no trabajar cuando se instala desde una rueda binario ( .whl)

Una solución podría ser incluir un directorio post_setup.pyin setup.py. post_setup.pycontendrá una función que realiza la instalación posterior y setup.pysolo la importará y ejecutará en el momento adecuado.

En 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},
        ...
    )

En post_setup.py:

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

if __name__ == '__main__':
    main()

Con la idea común de iniciar setup.pydesde su directorio, podrá importar, de lo post_setup.pycontrario, lanzará una función vacía.

En post_setup.py, la if __name__ == '__main__':declaración le permite iniciar manualmente la instalación posterior desde la línea de comandos.

Combinando las respuestas de @Apalala, @Zulu y @mertyildiran; esto funcionó para mí en un entorno 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},
...

Esto también le da acceso a la ruta de instalación del paquete en install_path, para hacer un trabajo de shell.

Creo que la forma más fácil de realizar la posinstalación y mantener los requisitos es decorar la llamada a 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=['...
    )
)

Esto se ejecutará setup()al declarar setup. Una vez que haya terminado con la instalación de los requisitos, ejecutará la _post_install()función, que ejecutará la función interna _post_actions().

Si usa atexit, no es necesario crear una nueva clase cmd. Simplemente puede crear su registro atexit justo antes de la llamada setup (). Hace la misma cosa.

Además, si necesita que se instalen las dependencias primero, esto no funciona con la instalación de pip, ya que se llamará a su controlador atexit antes de que pip mueva los paquetes a su lugar.

No pude resolver un problema con ninguna de las recomendaciones presentadas, así que esto es lo que me ayudó.

Puede llamar a la función que desea ejecutar después de la instalación justo después setup()de setup.py, así:

from setuptools import setup

def _post_install():
    <your code>

setup(...)

_post_install()