Requerimientos de referencia.txt para install_requires kwarg en el archivo setuptools setup.py

Tengo un requirements.txtarchivo que estoy usando con Travis-CI. Parece tonto duplicar los requisitos en ambos requirements.txty setup.py, por lo tanto, esperaba pasar un identificador de archivo al install_requireskwarg setuptools.setup.

es posible? Si es así, ¿cómo debo hacerlo?

Aquí está mi requirements.txtarchivo:

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

Puede darle la vuelta y enumerar las dependencias setup.pyy tener un solo carácter, un punto ., en su requirements.txtlugar.

Alternativamente, incluso si no se recomienda, aún es posible analizar el requirements.txtarchivo (si no hace referencia a ningún requisito externo por URL) con el siguiente truco (probado con pip 9.0.1):

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

Sin embargo, esto no filtra los marcadores del entorno .

En versiones antiguas de pip, más específicamente anteriores a 6.0 , hay una API pública que se puede utilizar para lograr esto. Un archivo de requisitos puede contener comentarios ( #) y puede incluir algunos otros archivos ( --requiremento -r). Por lo tanto, si realmente desea analizar un requirements.txtpuede usar el analizador de 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
)

En vista de ello, parece que requirements.txty setup.pyson duplicados tontas, pero es importante entender que mientras que la forma es similar, la función prevista es muy diferente.

El objetivo del autor de un paquete, al especificar dependencias, es decir "donde sea que instale este paquete, estos son los otros paquetes que necesita para que este paquete funcione".

Por el contrario, el autor de la implementación (que puede ser la misma persona en un momento diferente) tiene un trabajo diferente, ya que dice "aquí está la lista de paquetes que hemos reunido y probado y que ahora necesito instalar".

El autor del paquete escribe para una amplia variedad de escenarios, porque están poniendo su trabajo ahí fuera para que lo usen de formas que quizás no conozcan, y no tienen forma de saber qué paquetes se instalarán junto con su paquete. Para ser un buen vecino y evitar conflictos de versiones de dependencia con otros paquetes, necesitan especificar una gama tan amplia de versiones de dependencia como pueda funcionar. Esto es lo que install_requiresen setup.pysí.

El autor de la implementación escribe para un objetivo muy diferente y muy específico: una única instancia de una aplicación o servicio instalado, instalado en una computadora en particular. Para controlar con precisión una implementación y asegurarse de que los paquetes correctos se prueben e implementen, el autor de la implementación debe especificar la versión exacta y la ubicación de origen de cada paquete que se instalará, incluidas las dependencias y las dependencias de la dependencia. Con esta especificación, una implementación se puede aplicar repetidamente a varias máquinas, o probarse en una máquina de prueba, y el autor de la implementación puede estar seguro de que los mismos paquetes se implementan cada vez. Esto es lo que requirements.txthace.

Entonces puede ver que, si bien ambos parecen una gran lista de paquetes y versiones, estas dos cosas tienen trabajos muy diferentes. ¡Y definitivamente es fácil mezclar esto y equivocarse! Pero la forma correcta de pensar en esto es que requirements.txtes una "respuesta" a la "pregunta" planteada por los requisitos en todos los diversos setup.pyarchivos de paquete. En lugar de escribirlo a mano, a menudo se genera diciéndole a pip que mire todos los setup.pyarchivos en un conjunto de paquetes deseados, encuentre un conjunto de paquetes que considere que cumple con todos los requisitos y luego, una vez instalados, "congele "esa lista de paquetes en un archivo de texto (de aquí pip freezeproviene el nombre).

Entonces la comida para llevar:

• setup.pydebería declarar las versiones de dependencia más flojas posibles que aún sean viables. Su trabajo es decir con qué puede funcionar un paquete en particular.
• requirements.txtes un manifiesto de implementación que define un trabajo de instalación completo y no debe considerarse vinculado a ningún paquete. Su trabajo es declarar una lista exhaustiva de todos los paquetes necesarios para que una implementación funcione.
• Debido a que estas dos cosas tienen un contenido y razones tan diferentes para existir, no es factible simplemente copiar una en la otra.

Referencias

• install_requires vs Requisitos archivos de la guía del usuario de empaquetado de Python.

No puede tomar un identificador de archivo. El install_requiresargumento solo puede ser una cadena o una lista de cadenas .

Por supuesto, puede leer su archivo en el script de configuración y pasarlo como una lista de cadenas a install_requires.

import os
from setuptools import setup

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

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

Los archivos de requisitos usan un formato de pip expandido, que solo es útil si necesita complementarlo setup.pycon restricciones más fuertes, por ejemplo, especificando las URL exactas de las que deben proceder algunas de las dependencias, o la salida de pip freezecongelar todo el conjunto de paquetes a trabajo conocido versiones. Si no necesita restricciones adicionales, use solo a setup.py. Si siente que realmente necesita enviar un requirements.txtcorreo electrónico de todos modos, puede hacerlo en una sola línea:

.

Será válido y se referirá exactamente al contenido del setup.pyque está en el mismo directorio.

Si bien no es una respuesta exacta a la pregunta, recomiendo la publicación del blog de Donald Stufft en https://caremad.io/2013/07/setup-vs-requirement/ para una buena interpretación de este problema. Lo he estado usando con gran éxito.

En resumen, requirements.txtno es una setup.pyalternativa, sino un complemento de implementación. Mantenga una abstracción adecuada de las dependencias del paquete en setup.py. Configure requirements.txto más de ellos para obtener versiones específicas de dependencias de paquetes para desarrollo, prueba o producción.

Por ejemplo, con los paquetes incluidos en el repositorio bajo deps/:

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

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

pip ejecuta paquetes setup.pye instala las versiones específicas de dependencias declaradas en install_requires. No hay duplicidad y se preserva el propósito de ambos artefactos.

El uso parse_requirementses problemático porque la API de pip no está documentada y soportada públicamente. En el pip 1.6, esa función en realidad se está moviendo, por lo que es probable que los usos existentes se rompan.

Una forma más confiable de eliminar la duplicación entre setup.pyy requirements.txtes especificar sus dependencias setup.pyy luego ponerlas -e .en su requirements.txtarchivo. pipAquí encontrará información de uno de los desarrolladores sobre por qué es una mejor manera de hacerlo: https://caremad.io/blog/setup-vs-requirement/

La mayoría de las otras respuestas anteriores no funcionan con la versión actual de la API de pip. Aquí está la forma correcta * de hacerlo con la versión actual de pip (6.0.8 en el momento de la escritura, también funcionaba en 7.1.2. Puede verificar su versión 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
    ....
)

* Correcto, ya que es la forma de usar parse_requirements con el pip actual. Probablemente todavía no sea la mejor manera de hacerlo, ya que, como decían los carteles anteriores, pip realmente no mantiene una API.

Instale el paquete actual en Travis. Esto evita el uso de un requirements.txtarchivo. Por ejemplo:

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

from pip.req import parse_requirements no funcionó para mí y creo que es para las líneas en blanco en mis requerimientos.txt, pero esta función sí funciona

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 no desea obligar a sus usuarios a instalar pip, puede emular su comportamiento con esto:

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 siguiente interfaz quedó obsoleta en pip 10:

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

Así que lo cambié a un simple análisis de texto:

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

Este enfoque simple lee el archivo de requisitos de setup.py. Es una variación de la respuesta de Dmitiry S. .. Esta respuesta es compatible solo con Python 3.6+.

Por DS , requirements.txtpuede documentar requisitos concretos con números de versión específicos, mientras que setup.pypuede documentar requisitos abstractos con rangos de versiones sueltas.

A continuación hay un extracto de mi 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'),
   ...)

Tenga en cuenta que distutils.text_file.TextFileeliminará los comentarios. Además, según mi experiencia, aparentemente no es necesario que realice ningún paso especial para agrupar el archivo de requisitos.

¡CUIDADO CON EL parse_requirementsCOMPORTAMIENTO!

Tenga en cuenta que pip.req.parse_requirementscambiará los guiones bajos a guiones. Esto me enfureció durante unos días antes de descubrirlo. Ejemplo que demuestra:

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

Creé una función reutilizable para esto. En realidad, analiza un directorio completo de archivos de requisitos y los establece en extras_require.

Lo último siempre disponible aquí: 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)

Otra posible solución ...

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

y luego usar ...

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

No recomendaría hacer tal cosa. Como se mencionó varias veces install_requiresy requirements.txtdefinitivamente no se supone que sea la misma lista. Pero dado que hay muchas respuestas engañosas que involucran API privadas internas de pip , podría valer la pena buscar alternativas más sensatas ...

No es necesario que pip analice un requirements.txtarchivo desde un script setuptools setup.py . El proyecto setuptools ya contiene todas las herramientas necesarias en su paquete de nivel superiorpkg_resources .

Podría verse más o menos así:

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

Cruce la publicación de mi respuesta de esta pregunta SO para otra solución simple de prueba de versión 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],
        ...
    )

Luego, solo incluya todos sus requisitos en el requirements.txtdirectorio raíz del proyecto.

Hice esto:

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

Otro parse_requirementstruco que también analiza los marcadores ambientales 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
)

Debería admitir discos sdist y binarios.

Según lo declarado por otros, parse_requirementstiene varias deficiencias, por lo que esto no es lo que debe hacer en proyectos públicos, pero puede ser suficiente para proyectos internos / personales.

Aquí hay un truco completo (probado con pip 9.0.1) basado en la respuesta de Romain que lo analiza requirements.txty filtra de acuerdo con los marcadores actuales del entorno :

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)