Script di post-installazione con strumenti di installazione Python

È possibile specificare un file di script Python post-installazione come parte del file setuptools setup.py in modo che un utente possa eseguire il comando:

python setup.py install

su un archivio di file di progetto locale o

pip install <name>

per un progetto PyPI e lo script verrà eseguito al completamento dell'installazione di setuptools standard? Sto cercando di eseguire attività di post-installazione che possono essere codificate in un singolo file di script Python (ad esempio, fornire un messaggio post-installazione personalizzato all'utente, estrarre file di dati aggiuntivi da un repository di origine remota diverso).

Mi sono imbattuto in questa risposta SO di diversi anni fa che affronta l'argomento e sembra che il consenso in quel momento fosse che è necessario creare un sottocomando di installazione. Se è ancora così, sarebbe possibile per qualcuno fornire un esempio di come farlo in modo che non sia necessario che l'utente inserisca un secondo comando per eseguire lo script?

Nota: la soluzione seguente funziona solo quando si installa uno zip di distribuzione dei sorgenti o un tarball, oppure si installa in modalità modificabile da un albero dei sorgenti. Esso non funziona durante l'installazione da una ruota binario ( .whl)

Questa soluzione è più trasparente:

Farai alcune aggiunte a setup.pye non è necessario un file aggiuntivo.

Inoltre è necessario considerare due diverse post-installazioni; uno per la modalità di sviluppo / modificabile e l'altro per la modalità di installazione.

Aggiungi queste due classi che includono lo script di post-installazione a 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 inserisci l' cmdclassargomento per setup()funzionare in setup.py:

setup(
    ...

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

    ...
)

Puoi anche chiamare i comandi della shell durante l'installazione, come in questo esempio che fa la preparazione pre-installazione:

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 non ci sono punti di ingresso pre-installazione disponibili su setuptools. Leggi questa discussione se ti stai chiedendo perché non ce n'è.

Nota: la soluzione seguente funziona solo quando si installa uno zip di distribuzione dei sorgenti o un tarball, oppure si installa in modalità modificabile da un albero dei sorgenti. Esso non funziona durante l'installazione da una ruota binario ( .whl)

Questa è l'unica strategia che ha funzionato per me quando lo script di post-installazione richiede che le dipendenze del pacchetto siano già state installate:

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 soluzione seguente funziona solo quando si installa uno zip di distribuzione dei sorgenti o un tarball, oppure si installa in modalità modificabile da un albero dei sorgenti. Esso non funziona durante l'installazione da una ruota binario ( .whl)

Una soluzione potrebbe essere quella di includere una post_setup.pynella setup.pydirectory 's. post_setup.pyconterrà una funzione che esegue la post-installazione e setup.pyla importerà e la avvierà solo al momento opportuno.

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

In post_setup.py:

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

if __name__ == '__main__':
    main()

Con l'idea comune di lanciare setup.pydalla sua directory, sarai in grado di importare post_setup.pyaltrimenti lancerà una funzione vuota.

In post_setup.py, ilif __name__ == '__main__': istruzione consente di avviare manualmente la post-installazione dalla riga di comando.

Combinando le risposte di @Apalala, @Zulu e @mertyildiran; questo ha funzionato per me in un 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},
...

Questo ti dà anche accesso al percorso di installazione del pacchetto in install_path, su cui lavorare sulla shell.

Penso che il modo più semplice per eseguire la post-installazione e mantenere i requisiti sia decorare la chiamata 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=['...
    )
)

Questo verrà eseguito setup()durante la dichiarazione setup. Una volta completata l'installazione dei requisiti, verrà eseguita la _post_install()funzione, che eseguirà la funzione interna _post_actions().

Se si utilizza atexit, non è necessario creare una nuova cmdclass. Puoi semplicemente creare il tuo registro atexit subito prima della chiamata setup (). Fa la stessa cosa.

Inoltre, se è necessario installare prima le dipendenze, ciò non funziona con pip install poiché il gestore atexit verrà chiamato prima che pip sposti i pacchetti in posizione.

Non sono stato in grado di risolvere un problema con i consigli presentati, quindi ecco cosa mi ha aiutato.

È possibile chiamare la funzione, che si desidera eseguire dopo l'installazione subito dopo setup()in setup.py, così:

from setuptools import setup

def _post_install():
    <your code>

setup(...)

_post_install()