Skrypt poinstalacyjny z setuptools Pythona

Czy można określić plik skryptowy języka Python po instalacji jako część pliku setuptools setup.py, aby użytkownik mógł uruchomić polecenie:

python setup.py install

w lokalnym archiwum plików projektu lub

pip install <name>

dla projektu PyPI, a skrypt zostanie uruchomiony po zakończeniu standardowej instalacji setuptools? Chcę wykonać zadania poinstalacyjne, które można zakodować w jednym pliku skryptu Pythona (np. Dostarczyć użytkownikowi niestandardową wiadomość po instalacji, pobrać dodatkowe pliki danych z innego repozytorium zdalnego źródła).

Natknąłem się na tę odpowiedź SO z kilku lat temu, która dotyczy tego tematu i wygląda na to, że w tamtym czasie konsensus był taki, że musisz utworzyć komendę instalacji. Jeśli nadal tak jest, czy ktoś mógłby podać przykład, jak to zrobić, aby użytkownik nie musiał wprowadzać drugiego polecenia, aby uruchomić skrypt?

Uwaga: Poniższe rozwiązanie działa tylko podczas instalowania archiwum źródłowego ZIP lub TARBULL albo instalowania w trybie edytowalnym z drzewa źródłowego. To będzie nie działa podczas instalacji z kołem binarnym ( .whl)

To rozwiązanie jest bardziej przejrzyste:

Dodasz kilka dodatków setup.pyi nie potrzebujesz dodatkowego pliku.

Musisz także wziąć pod uwagę dwie różne czynności po instalacji; jeden dla trybu deweloperskiego / edytowalnego, a drugi dla trybu instalacji.

Dodaj te dwie klasy, które zawierają twój skrypt poinstalacyjny, do 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

i wstaw cmdclassargument do setup()funkcji w setup.py:

setup(
    ...

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

    ...
)

Możesz nawet wywołać polecenia powłoki podczas instalacji, jak w tym przykładzie, który wykonuje przygotowanie przed instalacją:

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 w setuptools nie ma żadnych punktów wejścia do instalacji wstępnej. Przeczytaj tę dyskusję, jeśli zastanawiasz się, dlaczego nie ma.

Uwaga: Poniższe rozwiązanie działa tylko podczas instalowania archiwum źródłowego ZIP lub TARBULL albo instalowania w trybie edytowalnym z drzewa źródłowego. To będzie nie działa podczas instalacji z kołem binarnym ( .whl)

To jedyna strategia, która zadziałała, gdy skrypt poinstalacyjny wymaga, aby zależności pakietów zostały już zainstalowane:

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},

Uwaga: Poniższe rozwiązanie działa tylko podczas instalowania archiwum źródłowego ZIP lub TARBULL albo instalowania w trybie edytowalnym z drzewa źródłowego. To będzie nie działa podczas instalacji z kołem binarnym ( .whl)

Rozwiązaniem może być obejmują post_setup.pyw setup.pykatalogu „s. post_setup.pybędzie zawierał funkcję, która wykonuje instalację po instalacji i setup.pytylko zaimportuje ją i uruchomi w odpowiednim czasie.

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

W post_setup.py:

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

if __name__ == '__main__':
    main()

Przy typowym pomyśle uruchamiania setup.pyz jego katalogu, będziesz mógł zaimportować post_setup.py, w przeciwnym razie uruchomi pustą funkcję.

W post_setup.pyprogramie if __name__ == '__main__':instrukcja umożliwia ręczne uruchomienie po instalacji z wiersza poleceń.

Łącząc odpowiedzi z @Apalala, @Zulu i @mertyildiran; to działało dla mnie w środowisku 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},
...

Daje to również dostęp do ścieżki instalacyjnej pakietu w programie install_path, aby wykonać trochę pracy z powłoką.

Myślę, że najłatwiejszym sposobem na wykonanie post-instalacji i zachowanie wymagań jest udekorowanie wezwania do 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=['...
    )
)

Będzie to działać setup()podczas deklarowania setup. Po zakończeniu instalacji wymagań uruchomi _post_install()funkcję, która uruchomi funkcję wewnętrzną _post_actions().

Jeśli używasz atexit, nie ma potrzeby tworzenia nowej klasy cmdclass. Możesz po prostu utworzyć swój rejestr atexit tuż przed wywołaniem setup (). Robi to samo.

Ponadto, jeśli potrzebujesz najpierw zainstalować zależności, nie działa to z instalacją pip, ponieważ twoja procedura obsługi atexit zostanie wywołana, zanim pip przeniesie pakiety na miejsce.

Nie udało mi się rozwiązać problemu z żadnymi przedstawionymi zaleceniami, więc oto co mi pomogło.

Funkcję można nazwać, że chcesz uruchomić po instalacji po prostu setup()w setup.py, tak:

from setuptools import setup

def _post_install():
    <your code>

setup(...)

_post_install()