Referenzanforderungen.txt für install_requires kwarg in der Datei setuptools setup.py

Ich habe eine requirements.txtDatei, die ich mit Travis-CI verwende. Es scheint albern, die Anforderungen in beiden zu duplizieren, requirements.txtund setup.pyso hatte ich gehofft, ein install_requiresDateihandle an das kwarg in zu übergeben setuptools.setup.

Ist das möglich? Wenn ja, wie soll ich vorgehen?

Hier ist meine requirements.txtDatei:

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

Sie können es umdrehen und die Abhängigkeiten setup.pyauflisten .und requirements.txtstattdessen ein einzelnes Zeichen - einen Punkt - einfügen.

Alternativ ist es auch dann möglich, die requirements.txtDatei mit dem folgenden Hack (getestet mit pip 9.0.1) zu analysieren, wenn dies nicht empfohlen wird (wenn keine externen Anforderungen per URL angegeben werden ):

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

Dies filtert jedoch keine Umgebungsmarkierungen .

In alten Versionen von pip, insbesondere älter als 6.0 , gibt es eine öffentliche API, mit der dies erreicht werden kann. Eine Anforderungsdatei kann Kommentare ( #) und einige andere Dateien ( --requirementoder -r) enthalten. Wenn Sie also wirklich a analysieren möchten, requirements.txtkönnen Sie den Pip-Parser verwenden:

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
)

Auf den ersten Blick scheint es so, requirements.txtals setup.pywären es alberne Duplikate, aber es ist wichtig zu verstehen, dass die beabsichtigte Funktion sehr unterschiedlich ist, obwohl die Form ähnlich ist.

Das Ziel eines Paketautors bei der Angabe von Abhängigkeiten besteht darin, zu sagen: "Wo immer Sie dieses Paket installieren, sind dies die anderen Pakete, die Sie benötigen, damit dieses Paket funktioniert."

Im Gegensatz dazu hat der Bereitstellungsautor (der zu einem anderen Zeitpunkt dieselbe Person sein kann) einen anderen Job, da er sagt: "Hier ist die Liste der Pakete, die wir zusammengestellt und getestet haben und die ich jetzt installieren muss."

Der Paketautor schreibt für eine Vielzahl von Szenarien, da sie ihre Arbeit dort einsetzen, um sie auf eine Weise zu verwenden, von der sie möglicherweise nichts wissen, und nicht wissen können, welche Pakete neben ihrem Paket installiert werden. Um ein guter Nachbar zu sein und Konflikte mit Abhängigkeitsversionen mit anderen Paketen zu vermeiden, müssen sie eine möglichst große Anzahl von Abhängigkeitsversionen angeben, die möglicherweise funktionieren. Dies ist, was install_requiresin setup.pytut.

Der Bereitstellungsautor schreibt für ein ganz anderes, sehr spezifisches Ziel: eine einzelne Instanz einer installierten Anwendung oder eines installierten Dienstes, die auf einem bestimmten Computer installiert ist. Um eine Bereitstellung genau zu steuern und sicherzustellen, dass die richtigen Pakete getestet und bereitgestellt werden, muss der Bereitstellungsautor die genaue Version und den Quellspeicherort jedes zu installierenden Pakets angeben, einschließlich der Abhängigkeiten und Abhängigkeiten der Abhängigkeiten. Mit dieser Spezifikation kann eine Bereitstellung wiederholt auf mehrere Computer angewendet oder auf einem Testcomputer getestet werden, und der Bereitstellungsautor kann sicher sein, dass jedes Mal dieselben Pakete bereitgestellt werden. Das macht ein requirements.txt.

Sie sehen also, dass beide Dinge wie eine große Liste von Paketen und Versionen aussehen, diese beiden Dinge jedoch sehr unterschiedliche Aufgaben haben. Und es ist definitiv einfach, dies zu verwechseln und falsch zu verstehen! Der richtige Weg, darüber nachzudenken, requirements.txtist jedoch eine "Antwort" auf die "Frage", die sich aus den Anforderungen in allen verschiedenen setup.pyPaketdateien ergibt. Anstatt es von Hand zu schreiben, wird es häufig generiert, indem pip angewiesen wird, alle setup.pyDateien in einer Reihe gewünschter Pakete zu betrachten, eine Reihe von Paketen zu finden, von denen es glaubt, dass sie alle Anforderungen erfüllen, und dann, nachdem sie installiert wurden, "einzufrieren" "diese Liste von Paketen in eine Textdatei (hier kommt der pip freezeName her).

Also zum Mitnehmen:

• setup.pysollte die lockersten möglichen Abhängigkeitsversionen deklarieren, die noch funktionsfähig sind. Seine Aufgabe ist es zu sagen, womit ein bestimmtes Paket funktionieren kann.
• requirements.txtist ein Bereitstellungsmanifest, das einen gesamten Installationsjob definiert und nicht als an ein Paket gebunden angesehen werden sollte. Seine Aufgabe ist es, eine vollständige Liste aller erforderlichen Pakete zu deklarieren, damit eine Bereitstellung funktioniert.
• Da diese beiden Dinge so unterschiedliche Inhalte und Gründe für ihre Existenz haben, ist es nicht möglich, sie einfach ineinander zu kopieren.

Verweise:

• install_requires vs Requirements-Dateien aus dem Python-Paketierungshandbuch.

Es kann kein Dateihandle aufnehmen. Das install_requiresArgument kann nur eine Zeichenfolge oder eine Liste von Zeichenfolgen sein .

Sie können Ihre Datei natürlich im Setup-Skript lesen und als Liste von Zeichenfolgen an übergeben install_requires.

import os
from setuptools import setup

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

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

Anforderungsdateien verwenden ein erweitertes Pip-Format, das nur dann nützlich ist, wenn Sie Ihre setup.pymit stärkeren Einschränkungen ergänzen müssen , z. B. indem Sie die genauen URLs angeben, von denen einige der Abhängigkeiten stammen müssen, oder die Ausgabe von pip freeze, um das gesamte Paketset auf bekanntes Funktionieren einzufrieren Versionen. Wenn Sie die zusätzlichen Einschränkungen nicht benötigen, verwenden Sie nur a setup.py. Wenn Sie das Gefühl haben, dass Sie wirklich eine requirements.txtversenden müssen, können Sie daraus eine einzelne Zeile machen:

.

Es ist gültig und bezieht sich genau auf den Inhalt von, der setup.pysich im selben Verzeichnis befindet.

Obwohl dies keine genaue Antwort auf die Frage ist, empfehle ich Donald Stuffts Blog-Post unter https://caremad.io/2013/07/setup-vs-requirement/, um dieses Problem gut zu lösen. Ich habe es mit großem Erfolg eingesetzt.

Kurz gesagt, requirements.txtist keine setup.pyAlternative, sondern eine Ergänzung zur Bereitstellung. Behalten Sie eine angemessene Abstraktion der Paketabhängigkeiten in bei setup.py. Legen Sie requirements.txtmindestens mehrere fest, um bestimmte Versionen von Paketabhängigkeiten für Entwicklung, Test oder Produktion abzurufen.

ZB mit Paketen im Repo unter deps/:

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

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

pip führt Pakete aus setup.pyund installiert die spezifischen Versionen der in deklarierten Abhängigkeiten install_requires. Es gibt keine Duplizität und der Zweck beider Artefakte bleibt erhalten.

Die Verwendung parse_requirementsist problematisch, da die pip-API nicht öffentlich dokumentiert und unterstützt wird. In Pip 1.6 bewegt sich diese Funktion tatsächlich, sodass bestehende Verwendungen davon wahrscheinlich nicht mehr funktionieren.

Eine zuverlässigere Möglichkeit, Doppelarbeit zwischen setup.pyund requirements.txtzu vermeiden, besteht darin, Ihre Abhängigkeiten in Ihrer Datei anzugeben setup.pyund diese dann -e .in Ihre requirements.txtDatei einzufügen. Einige Informationen von einem der pipEntwickler darüber, warum dies ein besserer Weg ist, finden Sie hier: https://caremad.io/blog/setup-vs-requirement/

Die meisten der oben genannten Antworten funktionieren nicht mit der aktuellen Version der Pip-API. Hier ist die richtige * Methode, um dies mit der aktuellen Version von pip zu tun (6.0.8 zum Zeitpunkt des Schreibens, ebenfalls in 7.1.2. Sie können Ihre Version mit pip -V überprüfen).

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

* Richtig, da es die Art ist, parse_requirements mit dem aktuellen Pip zu verwenden. Es ist wahrscheinlich immer noch nicht der beste Weg, dies zu tun, da pip, wie oben auf den Postern erwähnt, keine API verwaltet.

Installieren Sie das aktuelle Paket in Travis. Dies vermeidet die Verwendung einer requirements.txtDatei. Zum Beispiel:

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

from pip.req import parse_requirements hat bei mir nicht funktioniert und ich denke, es ist für die Leerzeilen in meiner Anforderung.txt, aber diese Funktion funktioniert

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

Wenn Sie Ihre Benutzer nicht zwingen möchten, pip zu installieren, können Sie das folgende Verhalten emulieren:

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'))
)

Die folgende Schnittstelle wurde in Pip 10 veraltet:

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

Also habe ich es einfach auf einfaches Parsen von Text umgestellt:

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 != ''
    ]

Dieser einfache Ansatz liest die Anforderungsdatei aus setup.py. Es ist eine Variation der Antwort von Dmitiry S. . Diese Antwort ist nur mit Python 3.6+ kompatibel.

Pro DS , requirements.txtkönnen konkrete Anforderungen mit spezifischen Versionsnummern dokumentieren, währendsetup.py abstrakte Anforderungen mit loser Version Bereichen dokumentieren.

Unten ist ein Auszug von mir 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'),
   ...)

Beachten Sie, dass distutils.text_file.TextFileKommentare entfernt werden. Nach meiner Erfahrung müssen Sie anscheinend keine besonderen Schritte unternehmen, um die Anforderungsdatei zu bündeln.

Hüten Sie sich vor dem parse_requirementsVerhalten!

Bitte beachten Sie, dass dadurch pip.req.parse_requirementsUnterstriche in Bindestriche umgewandelt werden. Das machte mich ein paar Tage lang wütend, bevor ich es entdeckte. Beispiel zur Demonstration:

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

produziert

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

Ich habe dafür eine wiederverwendbare Funktion erstellt. Es analysiert tatsächlich ein ganzes Verzeichnis von Anforderungsdateien und setzt sie auf extras_require.

Neueste immer hier verfügbar: 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)

Eine andere mögliche Lösung ...

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

und dann zu benutzen ...

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

Ich würde so etwas nicht empfehlen. Wie mehrfach erwähnt install_requiresund requirements.txtsollen definitiv nicht die gleiche Liste sein. Aber da es viele irreführende Antworten gibt, die private interne APIs von pip betreffen betreffen, lohnt es sich möglicherweise, nach vernünftigeren Alternativen zu suchen ...

Es besteht keine Notwendigkeit für pip eine parsen requirements.txtDatei von einem Setuptool setup.py Skript. Das setuptools- Projekt enthält bereits alle erforderlichen Tools in seinem Top-Level- Paket pkg_resources.

Es könnte mehr oder weniger so aussehen:

#!/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-Posting meiner Antwort von dieser SO-Frage für eine andere einfache, pip-versionssichere Lösung.

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],
        ...
    )

Dann geben Sie einfach alle Ihre Anforderungen requirements.txtunter Projektstammverzeichnis ein.

Ich war das:

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]}')

Ein weiterer parse_requirementsHack, der auch Umgebungsmarkierungen analysiert 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
)

Es sollte sowohl sdist als auch binäre Dists unterstützen.

Wie von anderen angegeben, parse_requirementsweist es mehrere Mängel auf, sodass Sie dies bei öffentlichen Projekten nicht tun sollten, dies kann jedoch für interne / persönliche Projekte ausreichen.

Hier ist ein vollständiger Hack (getestet mit pip 9.0.1) basierend auf Romains Antwort , der requirements.txtihn gemäß den aktuellen Umgebungsmarkierungen analysiert und filtert :

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)