Référence requirements.txt pour le kwarg install_requires dans le fichier setuptools setup.py

J'ai un requirements.txtfichier que j'utilise avec Travis-CI. Il semble stupide de dupliquer les exigences dans les deux requirements.txtet setup.py, donc j'espérais passer un install_requiresdescripteur de fichier au kwarg dans setuptools.setup.

Est-ce possible? Si oui, comment dois-je procéder?

Voici mon requirements.txtdossier:

guessit>=0.5.2
tvdb_api>=1.8.2
hachoir-metadata>=1.3.3
hachoir-core>=1.3.3
hachoir-parser>=1.3.4

Vous pouvez le retourner et répertorier les dépendances dans setup.pyet avoir un seul caractère - un point .- à la requirements.txtplace.

Alternativement, même si cela n'est pas conseillé, il est toujours possible d'analyser le requirements.txtfichier (s'il ne fait référence à aucune exigence externe par URL) avec le hack suivant (testé avec pip 9.0.1):

install_reqs = parse_requirements('requirements.txt', session='hack')

Cependant, cela ne filtre pas les marqueurs d'environnement .

Dans les anciennes versions de pip, plus spécifiquement antérieures à 6.0 , il existe une API publique qui peut être utilisée pour y parvenir. Un fichier d'exigences peut contenir des commentaires ( #) et peut inclure d'autres fichiers ( --requirementou -r). Ainsi, si vous voulez vraiment analyser un, requirements.txtvous pouvez utiliser l'analyseur pip:

from pip.req import parse_requirements

# parse_requirements() returns generator of pip.req.InstallRequirement objects
install_reqs = parse_requirements(<requirements_path>)

# reqs is a list of requirement
# e.g. ['django==1.5.1', 'mezzanine==1.4.6']
reqs = [str(ir.req) for ir in install_reqs]

setup(
    ...
    install_requires=reqs
)

A première vue, il ne semble que requirements.txtet setup.pysont des doublons stupides, mais il est important de comprendre que si la forme est similaire, la fonction prévue est très différente.

Le but d'un auteur de package, lors de la spécification des dépendances, est de dire "partout où vous installez ce package, ce sont les autres packages dont vous avez besoin, pour que ce package fonctionne."

En revanche, l'auteur du déploiement (qui peut être la même personne à un moment différent) a un travail différent, en ce sens qu'il dit "voici la liste des packages que nous avons rassemblés et testés et que je dois maintenant installer".

L'auteur du package écrit pour une grande variété de scénarios, car ils mettent leur travail à disposition de manière qu'ils ne connaissent peut-être pas et n'ont aucun moyen de savoir quels packages seront installés à côté de leur package. Afin d'être un bon voisin et d'éviter les conflits de versions de dépendances avec d'autres packages, ils doivent spécifier une gamme de versions de dépendances aussi large que possible. C'est ce que install_requiresdans le setup.pyfait.

L'auteur du déploiement écrit pour un objectif très différent et très spécifique: une seule instance d'une application ou d'un service installé, installé sur un ordinateur particulier. Afin de contrôler précisément un déploiement et d'être sûr que les bons packages sont testés et déployés, l'auteur du déploiement doit spécifier la version exacte et l'emplacement source de chaque package à installer, y compris les dépendances et les dépendances des dépendances. Avec cette spécification, un déploiement peut être appliqué de manière répétée à plusieurs machines, ou testé sur une machine de test, et l'auteur du déploiement peut être sûr que les mêmes packages sont déployés à chaque fois. C'est ce que requirements.txtfait un .

Vous pouvez donc voir que, bien qu'ils ressemblent tous les deux à une grande liste de packages et de versions, ces deux choses ont des tâches très différentes. Et c'est vraiment facile de mélanger cela et de se tromper! Mais la bonne façon de penser à cela est que requirements.txtc'est une "réponse" à la "question" posée par les exigences dans tous les différents setup.pyfichiers de package. Plutôt que de l'écrire à la main, il est souvent généré en disant à pip de regarder tous les setup.pyfichiers dans un ensemble de packages souhaités, de trouver un ensemble de packages qui, selon lui, répond à toutes les exigences, puis, après leur installation, "geler" "cette liste de packages dans un fichier texte (c'est de là que pip freezevient le nom).

Donc, le point à retenir:

• setup.pydevrait déclarer les versions de dépendances les plus lâches qui sont toujours utilisables. Son travail consiste à dire avec quoi un package particulier peut fonctionner.
• requirements.txtest un manifeste de déploiement qui définit un travail d'installation complet et ne doit pas être considéré comme lié à un seul package. Son travail consiste à déclarer une liste exhaustive de tous les packages nécessaires pour faire fonctionner un déploiement.
• Parce que ces deux choses ont un contenu et des raisons d'exister si différents, il n'est pas possible de simplement copier l'une dans l'autre.

Références:

• install_requires vs Requirements files du guide de l'utilisateur de l'empaquetage Python.

Il ne peut pas prendre de descripteur de fichier. L' install_requiresargument ne peut être qu'une chaîne ou une liste de chaînes .

Vous pouvez bien sûr lire votre fichier dans le script de configuration et le transmettre sous forme de liste de chaînes à install_requires.

import os
from setuptools import setup

with open('requirements.txt') as f:
    required = f.read().splitlines()

setup(...
install_requires=required,
...)

Les fichiers d'exigences utilisent un format pip étendu, qui n'est utile que si vous avez besoin de compléter votre setup.pyavec des contraintes plus fortes, par exemple en spécifiant les URL exactes dont certaines dépendances doivent provenir, ou la sortie de pip freezepour figer l'ensemble du package en mode connu. versions. Si vous n'avez pas besoin des contraintes supplémentaires, utilisez uniquement a setup.py. Si vous sentez que vous avez vraiment besoin d'en expédier un de requirements.txttoute façon, vous pouvez en faire une seule ligne:

.

Il sera valide et fera exactement référence au contenu de celui setup.pyqui se trouve dans le même répertoire.

Bien que ce ne soit pas une réponse exacte à la question, je recommande le billet de blog de Donald Stufft à https://caremad.io/2013/07/setup-vs-requirement/ pour une bonne interprétation de ce problème. Je l'utilise avec beaucoup de succès.

Bref, ce requirements.txtn'est pas une setup.pyalternative, mais un complément de déploiement. Conservez une abstraction appropriée des dépendances des packages dans setup.py. Définissez un requirements.txtou plusieurs d'entre eux pour récupérer des versions spécifiques des dépendances de package pour le développement, les tests ou la production.

Par exemple, avec des packages inclus dans le repo sous deps/:

# fetch specific dependencies
--no-index
--find-links deps/

# install package
# NOTE: -e . for editable mode
.

pip exécute les packages setup.pyet installe les versions spécifiques des dépendances déclarées dans install_requires. Il n'y a aucune duplicité et le but des deux artefacts est préservé.

L'utilisation parse_requirementsest problématique car l'API pip n'est pas documentée et prise en charge publiquement. Dans le pip 1.6, cette fonction est en train de se déplacer, de sorte que les utilisations existantes de celle-ci risquent de se casser.

Un moyen plus fiable pour éliminer la duplication entre setup.pyet requirements.txtconsiste à spécifier vos dépendances dans setup.py, puis à les placer -e .dans votre requirements.txtfichier. Certaines informations d'un des pipdéveloppeurs sur les raisons pour lesquelles c'est une meilleure façon de procéder sont disponibles ici: https://caremad.io/blog/setup-vs-requirement/

La plupart des autres réponses ci-dessus ne fonctionnent pas avec la version actuelle de l'API de pip. Voici la façon * correcte de le faire avec la version actuelle de pip (6.0.8 au moment de la rédaction, fonctionnait également en 7.1.2. Vous pouvez vérifier votre version avec pip -V).

from pip.req import parse_requirements
from pip.download import PipSession

install_reqs = parse_requirements(<requirements_path>, session=PipSession())

reqs = [str(ir.req) for ir in install_reqs]

setup(
    ...
    install_requires=reqs
    ....
)

* Correct, en ce sens que c'est la façon d'utiliser parse_requirements avec le pip actuel. Ce n'est probablement pas la meilleure façon de le faire, car, comme l'ont indiqué les affiches ci-dessus, pip ne maintient pas vraiment une API.

Installez le package actuel dans Travis. Cela évite l'utilisation d'un requirements.txtfichier. Par exemple:

language: python
python:
  - "2.7"
  - "2.6"
install:
  - pip install -q -e .
script:
  - python runtests.py

from pip.req import parse_requirements n'a pas fonctionné pour moi et je pense que c'est pour les lignes vides dans mon requirements.txt, mais cette fonction fonctionne

def parse_requirements(requirements):
    with open(requirements) as f:
        return [l.strip('\n') for l in f if l.strip('\n') and not l.startswith('#')]

reqs = parse_requirements(<requirements_path>)

setup(
    ...
    install_requires=reqs,
    ...
)

Si vous ne voulez pas forcer vos utilisateurs à installer pip, vous pouvez émuler son comportement avec ceci:

import sys

from os import path as p

try:
    from setuptools import setup, find_packages
except ImportError:
    from distutils.core import setup, find_packages


def read(filename, parent=None):
    parent = (parent or __file__)

    try:
        with open(p.join(p.dirname(parent), filename)) as f:
            return f.read()
    except IOError:
        return ''


def parse_requirements(filename, parent=None):
    parent = (parent or __file__)
    filepath = p.join(p.dirname(parent), filename)
    content = read(filename, parent)

    for line_number, line in enumerate(content.splitlines(), 1):
        candidate = line.strip()

        if candidate.startswith('-r'):
            for item in parse_requirements(candidate[2:].strip(), filepath):
                yield item
        else:
            yield candidate

setup(
...
    install_requires=list(parse_requirements('requirements.txt'))
)

L'interface suivante est devenue obsolète dans pip 10:

from pip.req import parse_requirements
from pip.download import PipSession

Je l'ai donc commuté juste en simple analyse de texte:

with open('requirements.txt', 'r') as f:
    install_reqs = [
        s for s in [
            line.split('#', 1)[0].strip(' \t\n') for line in f
        ] if s != ''
    ]

Cette approche simple lit le fichier des exigences à partir de setup.py. Il s'agit d'une variante de la réponse de Dmitiry S .. Cette réponse est compatible uniquement avec Python 3.6+.

Par DS , requirements.txtpeut documenter des exigences concrètes avec des numéros de version spécifiques, tandis que setup.pypeut documenter des exigences abstraites avec des plages de versions lâches.

Ci-dessous est un extrait de mon setup.py.

import distutils.text_file
from pathlib import Path
from typing import List

def _parse_requirements(filename: str) -> List[str]:
    """Return requirements from requirements file."""
    # Ref: https://stackoverflow.com/a/42033122/
    return distutils.text_file.TextFile(filename=str(Path(__file__).with_name(filename))).readlines()

setup(...
      install_requires=_parse_requirements('requirements.txt'),
   ...)

Notez que distutils.text_file.TextFilecela supprimera les commentaires. De plus, d'après mon expérience, vous n'avez apparemment pas besoin de prendre de mesure spéciale pour regrouper le fichier des exigences.

ATTENTION AU parse_requirementsCOMPORTEMENT!

Veuillez noter que pip.req.parse_requirementsles traits de soulignement seront remplacés par des tirets. Cela me rendait furieux pendant quelques jours avant de le découvrir. Exemple démontrant:

from pip.req import parse_requirements  # tested with v.1.4.1

reqs = '''
example_with_underscores
example-with-dashes
'''

with open('requirements.txt', 'w') as f:
    f.write(reqs)

req_deps = parse_requirements('requirements.txt')
result = [str(ir.req) for ir in req_deps if ir.req is not None]
print result

produit

['example-with-underscores', 'example-with-dashes']

J'ai créé une fonction réutilisable pour cela. Il analyse en fait tout un répertoire de fichiers d'exigences et les définit sur extras_require.

Le dernier toujours disponible ici: https://gist.github.com/akatrevorjay/293c26fefa24a7b812f5

import glob
import itertools
import os

# This is getting ridiculous
try:
    from pip._internal.req import parse_requirements
    from pip._internal.network.session import PipSession
except ImportError:
    try:
        from pip._internal.req import parse_requirements
        from pip._internal.download import PipSession
    except ImportError:
        from pip.req import parse_requirements
        from pip.download import PipSession


def setup_requirements(
        patterns=[
            'requirements.txt', 'requirements/*.txt', 'requirements/*.pip'
        ],
        combine=True):
    """
    Parse a glob of requirements and return a dictionary of setup() options.
    Create a dictionary that holds your options to setup() and update it using this.
    Pass that as kwargs into setup(), viola

    Any files that are not a standard option name (ie install, tests, setup) are added to extras_require with their
    basename minus ext. An extra key is added to extras_require: 'all', that contains all distinct reqs combined.

    Keep in mind all literally contains `all` packages in your extras.
    This means if you have conflicting packages across your extras, then you're going to have a bad time.
    (don't use all in these cases.)

    If you're running this for a Docker build, set `combine=True`.
    This will set `install_requires` to all distinct reqs combined.

    Example:

    >>> import setuptools
    >>> _conf = dict(
    ...     name='mainline',
    ...     version='0.0.1',
    ...     description='Mainline',
    ...     author='Trevor Joynson <[email protected],io>',
    ...     url='https://trevor.joynson.io',
    ...     namespace_packages=['mainline'],
    ...     packages=setuptools.find_packages(),
    ...     zip_safe=False,
    ...     include_package_data=True,
    ... )
    >>> _conf.update(setup_requirements())
    >>> # setuptools.setup(**_conf)

    :param str pattern: Glob pattern to find requirements files
    :param bool combine: Set True to set install_requires to extras_require['all']
    :return dict: Dictionary of parsed setup() options
    """
    session = PipSession()

    # Handle setuptools insanity
    key_map = {
        'requirements': 'install_requires',
        'install': 'install_requires',
        'tests': 'tests_require',
        'setup': 'setup_requires',
    }
    ret = {v: set() for v in key_map.values()}
    extras = ret['extras_require'] = {}
    all_reqs = set()

    files = [glob.glob(pat) for pat in patterns]
    files = itertools.chain(*files)

    for full_fn in files:
        # Parse
        reqs = {
            str(r.req)
            for r in parse_requirements(full_fn, session=session)
            # Must match env marker, eg:
            #   yarl ; python_version >= '3.0'
            if r.match_markers()
        }
        all_reqs.update(reqs)

        # Add in the right section
        fn = os.path.basename(full_fn)
        barefn, _ = os.path.splitext(fn)
        key = key_map.get(barefn)

        if key:
            ret[key].update(reqs)
            extras[key] = reqs

        extras[barefn] = reqs

    if 'all' not in extras:
        extras['all'] = list(all_reqs)

    if combine:
        extras['install'] = ret['install_requires']
        ret['install_requires'] = list(all_reqs)

    def _listify(dikt):
        ret = {}

        for k, v in dikt.items():
            if isinstance(v, set):
                v = list(v)
            elif isinstance(v, dict):
                v = _listify(v)
            ret[k] = v

        return ret

    ret = _listify(ret)

    return ret


__all__ = ['setup_requirements']

if __name__ == '__main__':
    reqs = setup_requirements()
    print(reqs)

Une autre solution possible ...

def gather_requirements(top_path=None):
    """Captures requirements from repo.

    Expected file format is: requirements[-_]<optional-extras>.txt

    For example:

        pip install -e .[foo]

    Would require:

        requirements-foo.txt

        or

        requirements_foo.txt

    """
    from pip.download import PipSession
    from pip.req import parse_requirements
    import re

    session = PipSession()
    top_path = top_path or os.path.realpath(os.getcwd())
    extras = {}
    for filepath in tree(top_path):
        filename = os.path.basename(filepath)
        basename, ext = os.path.splitext(filename)
        if ext == '.txt' and basename.startswith('requirements'):
            if filename == 'requirements.txt':
                extra_name = 'requirements'
            else:
                _, extra_name = re.split(r'[-_]', basename, 1)
            if extra_name:
                reqs = [str(ir.req) for ir in parse_requirements(filepath, session=session)]
                extras.setdefault(extra_name, []).extend(reqs)
    all_reqs = set()
    for key, values in extras.items():
        all_reqs.update(values)
    extras['all'] = list(all_reqs)
    return extras

et ensuite utiliser ...

reqs = gather_requirements()
install_reqs = reqs.pop('requirements', [])
test_reqs = reqs.pop('test', [])
...
setup(
    ...
    'install_requires': install_reqs,
    'test_requires': test_reqs,
    'extras_require': reqs,
    ...
)

Je ne recommanderais pas de faire une telle chose. Comme mentionné plusieurs fois install_requireset ne requirements.txtsont certainement pas censés être la même liste. Mais comme il y a beaucoup de réponses trompeuses tout autour impliquant des API internes privées de pip , il pourrait être utile de chercher des alternatives plus sûres ...

Il n'est pas nécessaire que pip analyse un requirements.txtfichier à partir d'un script setuptools setup.py . Le projet setuptools contient déjà tous les outils nécessaires dans son package de niveau supérieurpkg_resources .

Cela pourrait plus ou moins ressembler à ceci:

#!/usr/bin/env python3

import pathlib

import pkg_resources
import setuptools

with pathlib.Path('requirements.txt').open() as requirements_txt:
    install_requires = [
        str(requirement)
        for requirement
        in pkg_resources.parse_requirements(requirements_txt)
    ]

setuptools.setup(
    install_requires=install_requires,
)

Cross poster ma réponse de cette question SO pour une autre solution simple, à l'épreuve de la version pip.

try:  # for pip >= 10
    from pip._internal.req import parse_requirements
    from pip._internal.download import PipSession
except ImportError:  # for pip <= 9.0.3
    from pip.req import parse_requirements
    from pip.download import PipSession

requirements = parse_requirements(os.path.join(os.path.dirname(__file__), 'requirements.txt'), session=PipSession())

if __name__ == '__main__':
    setup(
        ...
        install_requires=[str(requirement.req) for requirement in requirements],
        ...
    )

Ensuite, ajoutez simplement toutes vos exigences sous le requirements.txtrépertoire racine du projet.

J'ai fait ça:

import re

def requirements(filename):
    with open(filename) as f:
        ll = f.read().splitlines()
    d = {}
    for l in ll:
        k, v = re.split(r'==|>=', l)
        d[k] = v
    return d

def packageInfo():
    try:
        from pip._internal.operations import freeze
    except ImportError:
        from pip.operations import freeze

    d = {}
    for kv in freeze.freeze():
        k, v = re.split(r'==|>=', kv)
        d[k] = v
    return d

req = getpackver('requirements.txt')
pkginfo = packageInfo()

for k, v in req.items():
    print(f'{k:<16}: {v:<6} -> {pkginfo[k]}')

Encore un autre parse_requirementshack qui analyse également les marqueurs d'environnement en extras_require:

from collections import defaultdict
from pip.req import parse_requirements

requirements = []
extras = defaultdict(list)
for r in parse_requirements('requirements.txt', session='hack'):
    if r.markers:
        extras[':' + str(r.markers)].append(str(r.req))
    else:
        requirements.append(str(r.req))

setup(
    ...,
    install_requires=requirements,
    extras_require=extras
)

Il devrait prendre en charge les distances sdist et binaires.

Comme indiqué par d'autres, parse_requirementsprésente plusieurs lacunes, ce n'est donc pas ce que vous devez faire sur des projets publics, mais cela peut suffire pour des projets internes / personnels.

Voici un hack complet (testé avec pip 9.0.1) basé sur la réponse de Romain qui l'analyse requirements.txtet le filtre en fonction des marqueurs d'environnement actuels :

from pip.req import parse_requirements

requirements = []
for r in parse_requirements('requirements.txt', session='hack'):
    # check markers, such as
    #
    #     rope_py3k    ; python_version >= '3.0'
    #
    if r.match_markers():
        requirements.append(str(r.req))

print(requirements)