Riferimento requisito.txt per install_requires kwarg nel file setuptools setup.py

Ho un requirements.txtfile che sto usando con Travis-CI. Sembra sciocco duplicare i requisiti in entrambi requirements.txte setup.py, quindi speravo di passare un handle di file al install_requireskwarg in setuptools.setup.

È possibile? In tal caso, come devo fare per farlo?

Ecco il mio requirements.txtfile:

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

Puoi capovolgerlo ed elencare le dipendenze setup.pye avere un solo carattere - un punto .- in requirements.txtinvece.

In alternativa, anche se non consigliato, è ancora possibile analizzare il requirements.txtfile (se non fa riferimento a requisiti esterni tramite URL) con il seguente hack (testato con pip 9.0.1):

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

Questo però non filtra i marker di ambiente .

Nelle vecchie versioni di pip, in particolare più vecchie di 6.0 , esiste un'API pubblica che può essere utilizzata per raggiungere questo obiettivo. Un file di requisiti può contenere commenti ( #) e può includere altri file ( --requiremento -r). Quindi, se vuoi davvero analizzare un requirements.txtpuoi usare il pars pars :

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
)

Sulla faccia di esso, sembra che requirements.txte setup.pysono duplicati stupide, ma è importante capire che mentre la forma è simile, la funzione prevista è molto diversa.

L'obiettivo di un autore di pacchetti, quando si specificano le dipendenze, è di dire "ovunque si installi questo pacchetto, questi sono gli altri pacchetti necessari, affinché questo pacchetto funzioni".

Al contrario, l'autore della distribuzione (che potrebbe essere la stessa persona in un momento diverso) ha un lavoro diverso, in quanto dicono "ecco l'elenco dei pacchetti che abbiamo raccolto e testato e che ora devo installare".

L'autore del pacchetto scrive per un'ampia varietà di scenari, perché stanno facendo del loro lavoro là fuori per essere utilizzati in modi che potrebbero non conoscere e non hanno modo di sapere quali pacchetti verranno installati insieme al loro pacchetto. Per essere un buon vicino ed evitare conflitti di versione di dipendenza con altri pacchetti, devono specificare una gamma di versioni di dipendenza quanto più ampia possibile. Questo è ciò che install_requiresin setup.pyfa.

L'autore della distribuzione scrive per un obiettivo molto diverso e molto specifico: una singola istanza di un'applicazione o servizio installata, installata su un determinato computer. Per controllare con precisione una distribuzione ed essere sicuri che i pacchetti giusti siano testati e distribuiti, l'autore della distribuzione deve specificare la versione esatta e la posizione di origine di ogni pacchetto da installare, comprese le dipendenze e le dipendenze delle dipendenze. Con questa specifica, una distribuzione può essere ripetutamente applicata a più macchine o testata su una macchina di prova e l'autore della distribuzione può essere sicuro che gli stessi pacchetti vengano distribuiti ogni volta. Questo è ciò che requirements.txtfa.

Quindi puoi vedere che, mentre entrambi sembrano un grande elenco di pacchetti e versioni, queste due cose hanno lavori molto diversi. Ed è sicuramente facile mescolarlo e sbagliarlo! Ma il modo giusto di pensare a questo è che requirements.txtè una "risposta" alla "domanda" posta dai requisiti in tutti i vari setup.pyfile di pacchetto. Piuttosto che scriverlo a mano, viene spesso generato dicendo a pip di guardare tutti i setup.pyfile in un set di pacchetti desiderati, trovare un set di pacchetti che ritiene corrisponda a tutti i requisiti e quindi, dopo l'installazione, "bloccare "quell'elenco di pacchetti in un file di testo (da qui deriva il pip freezenome).

Quindi il takeaway:

• setup.pydovrebbe dichiarare le versioni di dipendenza più vaghe possibili che sono ancora praticabili. Il suo compito è quello di dire con cosa può funzionare un determinato pacchetto.
• requirements.txtè un manifest di distribuzione che definisce un intero processo di installazione e non deve essere considerato come legato a un singolo pacchetto. Il suo compito è di dichiarare un elenco esaustivo di tutti i pacchetti necessari per far funzionare una distribuzione.
• Poiché queste due cose hanno contenuti e ragioni di esistenza così diversi, non è possibile semplicemente copiarne una nell'altra.

Riferimenti:

• install_requires vs Requirements files dalla guida per l'utente del packaging Python.

Non può richiedere un handle di file. L' install_requiresargomento può essere solo una stringa o un elenco di stringhe .

Ovviamente puoi leggere il tuo file nello script di installazione e passarlo come un elenco di stringhe a install_requires.

import os
from setuptools import setup

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

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

I file dei requisiti utilizzano un formato pip espanso, utile solo se è necessario integrare i setup.pyvincoli più forti, ad esempio specificando gli URL esatti da cui devono provenire alcune dipendenze o l'output di pip freezecongelare l'intero pacchetto impostato su noto funzionante versioni. Se non sono necessari ulteriori vincoli, utilizzare solo a setup.py. Se ritieni di dover davvero effettuare una spedizione in requirements.txtogni caso, puoi trasformarlo in un'unica linea:

.

Sarà valido e si riferirà esattamente al contenuto di quello setup.pyche si trova nella stessa directory.

Pur non essendo una risposta esatta alla domanda, raccomando il post sul blog di Donald Stufft all'indirizzo https://caremad.io/2013/07/setup-vs-requirement/ per una buona questo problema. L'ho usato con grande successo.

In breve, requirements.txtnon è setup.pyun'alternativa, ma un complemento di distribuzione. Mantenere un'astrazione appropriata delle dipendenze dei pacchetti in setup.py. Impostatorequirements.txt o più di questi per recuperare versioni specifiche delle dipendenze dei pacchetti per lo sviluppo, i test o la produzione.

Ad esempio, con i pacchetti inclusi nel repository in deps/:

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

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

pip esegue i pacchetti setup.pye installa le versioni specifiche delle dipendenze dichiarate ininstall_requires . Non c'è duplicità e lo scopo di entrambi i manufatti viene preservato.

L'uso parse_requirementsè problematico perché l'API pip non è documentata e supportata pubblicamente. Nel pip 1.6, quella funzione si sta effettivamente spostando, quindi è probabile che gli usi esistenti di essa vengano interrotti.

Un modo più affidabile per eliminare la duplicazione tra setup.pye requirements.txtè quello di specificare le proprie dipendenze setup.pye quindi inserirle -e .nel requirements.txtfile. Alcune informazioni di uno degli pipsviluppatori sul perché sia ​​un modo migliore per andare sono disponibili qui: https://caremad.io/blog/setup-vs-requirement/

La maggior parte delle altre risposte precedenti non funziona con la versione corrente dell'API di pip. Ecco il modo corretto * per farlo con la versione corrente di pip (6.0.8 al momento della scrittura, funzionava anche in 7.1.2. Puoi controllare la tua versione con 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
    ....
)

* Corretto, in quanto è il modo di usare parse_requirements con l'attuale pip. Probabilmente non è ancora il modo migliore per farlo, poiché, come dicevano i poster sopra, pip non mantiene davvero un'API.

Installa il pacchetto corrente in Travis. Questo evita l'uso di un requirements.txtfile. Per esempio:

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

from pip.req import parse_requirements non ha funzionato per me e penso che sia per le righe vuote nel mio requisito.txt, ma questa funzione funziona

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

Se non vuoi forzare gli utenti a installare pip, puoi emularne il comportamento con questo:

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

La seguente interfaccia è diventata obsoleta nel pip 10:

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

Quindi l'ho passato solo al semplice analisi del testo:

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

Questo semplice approccio legge il file dei requisiti da setup.py. È una variazione della risposta di Dmitiry S .. Questa risposta è compatibile solo con Python 3.6+.

Per DS , requirements.txtpuò documentare requisiti concreti con numeri di versione specifici, mentre setup.pypuò documentare requisiti astratti con intervalli di versioni non validi.

Di seguito è riportato un mio estratto 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'),
   ...)

Si noti che distutils.text_file.TextFileeliminerà i commenti. Inoltre, secondo la mia esperienza, apparentemente non è necessario fare alcun passo speciale per raggruppare il file dei requisiti.

ATTENZIONE AL parse_requirementsCOMPORTAMENTO!

Si noti che pip.req.parse_requirementscambierà i trattini bassi in trattini. Questo mi ha fatto infuriare per alcuni giorni prima che lo scoprissi. Esempio dimostrativo:

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

produce

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

Ho creato una funzione riutilizzabile per questo. Effettivamente analizza un'intera directory di file dei requisiti e li imposta su extras_require.

Le ultime sempre disponibili qui: 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 <github@trevor.joynson,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)

Un'altra possibile soluzione ...

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

e poi usare ...

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

Non consiglierei di fare una cosa del genere. Come accennato più volte install_requirese requirements.txtsicuramente non dovrebbero essere la stessa lista. Ma dal momento che ci sono molte risposte fuorvianti che coinvolgono API interne private di pip , potrebbe valere la pena cercare alternative più sane ...

Non è necessario che pip analizzi un requirements.txtfile da uno script setuptools setup.py . Il progetto setuptools contiene già tutti gli strumenti necessari nel suo pacchetto di livello superiorepkg_resources .

Potrebbe più o meno apparire così:

#!/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,
)

Pubblicazione incrociata della mia risposta da questa domanda SO per un'altra soluzione semplice, a prova di versione 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],
        ...
    )

Quindi inserisci tutti i requisiti nella requirements.txtdirectory principale del progetto.

L'ho fatto:

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

Ancora un altro parse_requirementstrucco che analizza anche i marcatori di ambiente in 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
)

Dovrebbe supportare dists binarie e binarie.

Come affermato da altri, parse_requirementsha diverse carenze, quindi questo non è ciò che dovresti fare su progetti pubblici, ma potrebbe essere sufficiente per progetti interni / personali.

Ecco un hack completo (testato con pip 9.0.1) basato sulla risposta di Romain che analizza requirements.txte filtra in base agli attuali marker di ambiente :

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)