setuptools setup.py 文件中 install_requires kwarg 的参考 requirements.txt

Question

我有一个与 Travis-CI 一起使用的 requirements.txt 文件。在requirements.txt 和setup.py 中重复要求似乎很愚蠢，所以我希望将文件句柄传递给setuptools.setup 中的install_requires kwarg。

这可能吗？如果是这样，我应该怎么做？

这是我的requirements.txt 文件：

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

Answer 1

我不建议这样做。正如多次提到的install_requires 和requirements.txt 绝对不应该是同一个列表。但是，由于涉及到 pip 的私有内部 API 存在很多误导性答案，因此可能值得寻找更明智的替代方案...

pip 不需要从 setuptools setup.py 脚本解析 requirements.txt 文件。 setuptools 项目已经在其顶级 包pkg_resources 中包含所有必要的工具。

它或多或少看起来像这样：

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

---

注意事项：

• 另请参阅其他答案：https://stackoverflow.com/a/59971236/11138259

Answer 2

这种简单的方法从setup.py 读取需求文件。这是Dmitiry S. 答案的变体。此答案仅与 Python 3.6+ 兼容。

根据D.S.，requirements.txt 可以记录具有特定版本号的具体要求，而setup.py 可以记录具有松散版本范围的抽象要求。

以下是我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'),
   ...)

请注意，distutils.text_file.TextFile 将剥离 cmets。此外，根据我的经验，您显然不需要采取任何特殊步骤来捆绑需求文件。

Answer 3

以下接口在 pip 10 中被弃用：

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

所以我将它切换为简单的文本解析：

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

Answer 4

我这样做了：

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

Answer 5

我为此创建了一个可重用的函数。它实际上解析了需求文件的整个目录并将它们设置为 extras_require。

最新的总是在这里：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)

Answer 6

从this SO question 交叉发布我的答案以获得另一个简单的 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],
        ...
    )

然后在项目根目录下的requirements.txt 下输入所有需求。

Answer 7

您可以翻转它并在 setup.py 中列出依赖关系，并在 requirements.txt 中使用单个字符 - 一个点 .。

---

或者，即使不建议，仍然可以使用以下 hack 解析 requirements.txt 文件（如果它没有通过 URL 引用任何外部要求）（使用 pip 9.0.1 测试）：

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

这不会过滤environment markers。

---

在旧版本的 pip 中，更具体地说是older than 6.0，有一个公共 API 可用于实现此目的。需求文件可以包含 cmets (#) 并且可以包含一些其他文件 (--requirement 或 -r)。因此，如果你真的想解析 requirements.txt，你可以使用 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
)

Answer 8

另一种可能的解决方案...

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

然后使用...

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

Answer 9

如果你不想强迫你的用户安装 pip，你可以用这个来模拟它的行为：

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

Answer 10

另一个parse_requirements hack 也将环境标记解析为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
)

它应该支持 sdist 和二进制文件。

正如其他人所说，parse_requirements 有几个缺点，所以这不是您在公共项目中应该做的，但对于内部/个人项目可能就足够了。

Answer 11

这是一个基于 Romain's answer 的完整 hack（使用 pip 9.0.1 测试），它解析 requirements.txt 并根据当前的 environment markers 对其进行过滤：

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)

Answer 12

从表面上看，requirements.txt 和 setup.py 似乎是愚蠢的重复，但重要的是要理解，虽然形式相似，但预期的功能却大不相同。

在指定依赖项时，包作者的目标是说“无论您在何处安装此包，这些都是您需要的其他包，以使此包正常工作。”

相比之下，部署作者（可能是不同时间的同一个人）有不同的工作，因为他们说“这是我们收集并测试的包列表，我现在需要安装”。

包作者针对各种各样的场景进行了编写，因为他们将自己的工作以他们可能不知道的方式使用，并且无法知道哪些包将与他们的包一起安装。为了成为一个好邻居并避免与其他包的依赖版本冲突，他们需要指定尽可能广泛的依赖版本。这就是install_requires in setup.py 所做的。

部署作者写了一个非常不同的、非常具体的目标：安装在特定计算机上的已安装应用程序或服务的单个实例。为了精确控制部署，并确保测试和部署正确的包，部署作者必须指定要安装的每个包的确切版本和源位置，包括依赖项和依赖项的依赖项。有了这个规范，一个部署可以重复地应用到多台机器上，或者在一台测试机器上进行测试，并且部署作者可以确信每次都部署了相同的包。这就是requirements.txt 的作用。

所以你可以看到，虽然它们看起来都像一个很大的包和版本列表，但这两个东西有非常不同的工作。而且很容易把它弄混并弄错！但正确的思考方式是requirements.txt 是对所有各种setup.py 包文件中的要求所提出的“问题”的“答案”。它不是手动编写的，它通常是通过告诉 pip 查看一组所需包中的所有setup.py 文件，找到一组它认为符合所有要求的包，然后在它们安装后生成的, 将该软件包列表“冻结”到一个文本文件中（这是 pip freeze 名称的来源）。

所以要点：

• setup.py 应该声明仍然可行的最松散的可能依赖版本。它的工作是说明特定包可以使用什么。
• requirements.txt 是一个部署清单，它定义了整个安装作业，不应被认为与任何一个包相关联。它的工作是声明一份详尽的清单，列出所有必要的包以使部署工作。
• 因为这两个东西有如此不同的内容和存在的原因，简单地把一个复制到另一个是行不通的。

参考资料：

• install_requires vs Requirements files 来自 Python 打包用户指南。

Answer 13

虽然不是这个问题的确切答案，但我推荐 Donald Stufft 在https://caremad.io/2013/07/setup-vs-requirement/ 的博客文章，以便很好地解决这个问题。我一直在使用它取得了巨大的成功。

简而言之，requirements.txt 不是setup.py 的替代品，而是部署的补充。在setup.py 中保留适当的包依赖抽象。设置 requirements.txt 或更多它们以获取特定版本的包依赖项以用于开发、测试或生产。

例如包含在deps/ 下的 repo 中的软件包：

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

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

pip 执行包的setup.py 并安装在install_requires 中声明的特定版本的依赖项。没有重复性，并且保留了两个工件的用途。

Answer 14

上面的大多数其他答案都不适用于当前版本的 pip API。这是使用当前版本的 pip 的正确*方法（撰写本文时为 6.0.8，也适用于 7.1.2。您可以使用 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
    ....
)

* 正确，因为这是将 parse_requirements 与当前 pip 一起使用的方式。它仍然可能不是最好的方法，因为正如上面的海报所说，pip 并没有真正维护 API。

Answer 15

提防parse_requirements行为！

请注意pip.req.parse_requirements 会将下划线更改为破折号。在我发现它之前，这让我愤怒了几天。示例演示：

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

生产

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

Answer 16

使用parse_requirements 是有问题的，因为 pip API 没有公开记录和支持。在 pip 1.6 中，该功能实际上正在移动，因此它的现有用途可能会中断。

消除setup.py 和requirements.txt 之间重复的更可靠方法是在setup.py 中指定您的依赖关系，然后将-e . 放入您的requirements.txt 文件中。来自pip 开发人员之一的一些关于为什么这是一种更好的方法的信息可在此处获得：https://caremad.io/blog/setup-vs-requirement/

Answer 17

from pip.req import parse_requirements 对我不起作用，我认为它适用于我的 requirements.txt 中的空白行，但此功能确实有效

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

Answer 18

需求文件使用扩展的 pip 格式，仅当您需要用更强的约束来补充您的 setup.py 时才有用，例如指定某些依赖项必须来自的确切 url，或 pip freeze 的输出到将整个包集冻结为已知工作版本。如果您不需要额外的约束，请仅使用setup.py。如果您觉得确实需要发送requirements.txt，您可以将其设置为一行：

.

它将是有效的，并且完全引用同一目录中setup.py 的内容。

Answer 19

在 Travis 中安装当前包。这避免了使用requirements.txt 文件。 例如：

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

Answer 20

它不能接受文件句柄。 install_requires 参数可以only be a string or a list of strings。

当然，您可以在安装脚本中读取文件并将其作为字符串列表传递给install_requires。

import os
from setuptools import setup

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

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