Tham chiếu yêu cầu.txt cho tệp kwarg cài đặt trong tệp setuptools setup.py

Tôi có một requirements.txttệp mà tôi đang sử dụng với Travis-CI. Có vẻ ngớ ngẩn khi sao chép các yêu cầu trong cả hai requirements.txtvà setup.py, vì vậy tôi đã hy vọng chuyển một xử lý tệp cho install_requireskwarg trong setuptools.setup.

Điều này có thể không? Nếu vậy, tôi nên làm thế nào về nó?

Đây là requirements.txttập tin của tôi :

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

Bạn có thể lật nó xung quanh và liệt kê các phụ thuộc vào setup.pyvà có một ký tự duy nhất - một dấu chấm .- requirements.txtthay vào đó.

Ngoài ra, ngay cả khi không được thông báo, vẫn có thể phân tích requirements.txttệp (nếu nó không đưa ra bất kỳ yêu cầu bên ngoài nào bằng URL) với bản hack sau (đã được thử nghiệm pip 9.0.1):

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

Điều này không lọc các dấu môi trường mặc dù.

Trong các phiên bản cũ của pip, cụ thể hơn cũ hơn 6.0 , có một API công khai có thể được sử dụng để đạt được điều này. Một tệp yêu cầu có thể chứa ý kiến ​​( #) và có thể bao gồm một số tệp khác ( --requirementhoặc -r). Vì vậy, nếu bạn thực sự muốn phân tích cú pháp, requirements.txtbạn có thể sử dụng trình phân tích cú pháp 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
)

Trên khuôn mặt của nó, nó dường như đó requirements.txtvà setup.pylà bản sao ngớ ngẩn, nhưng điều quan trọng là phải hiểu rằng trong khi các hình thức tương tự, chức năng dự định là rất khác nhau.

Mục tiêu của một tác giả gói, khi chỉ định các phụ thuộc, là nói "bất cứ nơi nào bạn cài đặt gói này, đây là các gói khác bạn cần, để gói này hoạt động."

Ngược lại, tác giả triển khai (có thể là cùng một người vào một thời điểm khác nhau) có một công việc khác, trong đó họ nói "đây là danh sách các gói chúng tôi đã tập hợp lại và thử nghiệm và bây giờ tôi cần cài đặt".

Tác giả gói viết cho nhiều tình huống khác nhau, bởi vì họ đang đưa tác phẩm của mình ra ngoài để sử dụng theo những cách họ có thể không biết và không có cách nào biết gói nào sẽ được cài đặt cùng với gói của họ. Để trở thành hàng xóm tốt và tránh xung đột phiên bản phụ thuộc với các gói khác, họ cần chỉ định phạm vi phiên bản phụ thuộc càng rộng càng tốt. Đây là những gì install_requirestrong setup.pylàm.

Tác giả triển khai viết cho một mục tiêu rất khác, rất cụ thể: một phiên bản duy nhất của một ứng dụng hoặc dịch vụ được cài đặt, được cài đặt trên một máy tính cụ thể. Để kiểm soát chính xác việc triển khai và chắc chắn rằng các gói phù hợp đã được kiểm tra và triển khai, tác giả triển khai phải chỉ định phiên bản chính xác và vị trí nguồn của mỗi gói sẽ được cài đặt, bao gồm cả phụ thuộc và phụ thuộc. Với thông số kỹ thuật này, việc triển khai có thể được áp dụng lặp lại cho một số máy hoặc được thử nghiệm trên máy thử nghiệm và tác giả triển khai có thể tự tin rằng các gói tương tự được triển khai mỗi lần. Đây là những gì a requirements.txtlàm.

Vì vậy, bạn có thể thấy rằng, trong khi cả hai đều trông giống như một danh sách lớn các gói và phiên bản, hai thứ này có công việc rất khác nhau. Và thật dễ dàng để trộn nó lên và hiểu sai! Nhưng cách đúng đắn để suy nghĩ về điều này là requirements.txt"câu trả lời" cho "câu hỏi" được đặt ra bởi các yêu cầu trong tất cả các setup.pytệp gói khác nhau . Thay vì viết nó bằng tay, nó thường được tạo bằng cách yêu cầu pip xem tất cả các setup.pytệp trong một tập các gói mong muốn, tìm một tập các gói mà nó cho là phù hợp với tất cả các yêu cầu, và sau đó, sau khi chúng được cài đặt, "đóng băng "Danh sách các gói đó thành một tệp văn bản (đây là pip freezetên của nguồn gốc).

Vì vậy, các takeaway:

• setup.pynên khai báo các phiên bản phụ thuộc lỏng lẻo nhất có thể vẫn hoạt động được. Công việc của nó là nói những gì một gói cụ thể có thể làm việc với.
• requirements.txtlà một bảng kê khai triển khai xác định toàn bộ công việc cài đặt và không nên được coi là gắn liền với bất kỳ một gói nào. Công việc của nó là khai báo một danh sách đầy đủ tất cả các gói cần thiết để thực hiện công việc triển khai.
• Bởi vì hai điều này có nội dung và lý do khác nhau như vậy, nên việc sao chép cái này sang cái kia là không khả thi.

Người giới thiệu:

• các tệp install_Vquires vs Yêu cầu từ hướng dẫn sử dụng bao bì Python.

Nó không thể xử lý tập tin. Đối install_requiressố chỉ có thể là một chuỗi hoặc một danh sách các chuỗi .

Tất nhiên, bạn có thể đọc tệp của mình trong tập lệnh thiết lập và chuyển nó dưới dạng danh sách các chuỗi install_requires.

import os
from setuptools import setup

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

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

Các tệp yêu cầu sử dụng định dạng pip mở rộng, chỉ hữu ích nếu bạn cần bổ sung cho các setup.pyràng buộc mạnh hơn, ví dụ: chỉ định các url chính xác mà một số phụ thuộc phải xuất phát hoặc đầu ra pip freezeđể đóng băng toàn bộ gói được đặt thành hoạt động đã biết phiên bản. Nếu bạn không cần các ràng buộc thêm, chỉ sử dụng a setup.py. Nếu bạn cảm thấy như bạn thực sự cần phải gửi một requirements.txtdù sao, bạn có thể làm cho nó một dòng duy nhất:

.

Nó sẽ hợp lệ và tham khảo chính xác các nội dung setup.pytrong cùng một thư mục.

Mặc dù không có câu trả lời chính xác cho câu hỏi, tôi khuyên bạn nên đăng bài viết trên blog của Donald Stufft tại https://caremad.io/2013/07/setup-vs-requirement/ để giải quyết vấn đề này. Tôi đã sử dụng nó để thành công lớn.

Nói tóm lại, requirements.txtkhông phải là một setup.pysự thay thế, mà là một bổ sung triển khai. Giữ một sự trừu tượng thích hợp của các phụ thuộc gói trong setup.py. Đặt requirements.txthoặc nhiều hơn để tìm nạp các phiên bản cụ thể của các phụ thuộc gói để phát triển, thử nghiệm hoặc sản xuất.

Ví dụ: với các gói được bao gồm trong repo dưới deps/:

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

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

Pip thực thi gói setup.pyvà cài đặt các phiên bản cụ thể của các phụ thuộc được khai báo install_requires. Không có sự trùng lặp và mục đích của cả hai hiện vật được bảo tồn.

Việc sử dụng parse_requirementslà có vấn đề vì API pip không được ghi lại và hỗ trợ công khai. Trong pip 1.6, chức năng đó thực sự đang di chuyển, vì vậy việc sử dụng hiện tại của nó có khả năng bị phá vỡ.

Một cách đáng tin cậy hơn để loại bỏ sự trùng lặp giữa setup.pyvà requirements.txtlà cụ thể các phụ thuộc của bạn setup.pyvà sau đó đưa -e .vào requirements.txttệp của bạn . Một số thông tin từ một trong những pipnhà phát triển về lý do tại sao đó là cách tốt hơn để có sẵn tại đây: https://caremad.io/blog/setup-vs-requirement/

Hầu hết các câu trả lời khác ở trên không hoạt động với phiên bản API hiện tại của pip. Đây là cách * chính xác để làm điều đó với phiên bản hiện tại của pip (6.0.8 tại thời điểm viết, cũng hoạt động trong 7.1.2. Bạn có thể kiểm tra phiên bản của mình với 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
    ....
)

* Chính xác, trong đó là cách sử dụng parse numquirements với pip hiện tại. Đây có lẽ vẫn chưa phải là cách tốt nhất để làm điều đó, vì, như những người đăng ở trên đã nói, pip không thực sự duy trì API.

Cài đặt gói hiện tại trong Travis. Điều này tránh việc sử dụng một requirements.txttập tin. Ví dụ:

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

from pip.req import parse_requirements không hoạt động với tôi và tôi nghĩ rằng nó dành cho các dòng trống trong tệp.txt của tôi, nhưng chức năng này không hoạt động

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

Nếu bạn không muốn buộc người dùng của mình cài đặt pip, bạn có thể mô phỏng hành vi của nó bằng cách này:

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

Giao diện sau đây không được dùng trong pip 10:

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

Vì vậy, tôi chuyển nó chỉ để phân tích cú pháp văn bản đơn giản:

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

Cách tiếp cận đơn giản này đọc các tập tin yêu cầu từ setup.py. Đó là một biến thể của câu trả lời của Dmitiry S .. Câu trả lời này chỉ tương thích với Python 3.6+.

Trên mỗi DS , requirements.txtcó thể ghi lại các yêu cầu cụ thể với số phiên bản cụ thể, trong khi setup.pycó thể ghi lại các yêu cầu trừu tượng với phạm vi phiên bản lỏng lẻo.

Dưới đây là một đoạn trích của tôi 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'),
   ...)

Lưu ý rằng distutils.text_file.TextFilesẽ tước bình luận. Ngoài ra, theo kinh nghiệm của tôi, rõ ràng bạn không cần thực hiện bất kỳ bước đặc biệt nào để gói trong tệp yêu cầu.

HÃY THƯỞNG THỨC parse_requirements!

Xin lưu ý rằng pip.req.parse_requirementssẽ thay đổi dấu gạch dưới thành dấu gạch ngang. Điều này đã làm tôi tức giận trong vài ngày trước khi tôi phát hiện ra nó. Ví dụ minh họa:

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

sản xuất

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

Tôi đã tạo ra một chức năng tái sử dụng cho việc này. Nó thực sự phân tích toàn bộ thư mục của các tệp yêu cầu và đặt chúng thành ngoại lệ.

Mới nhất luôn có sẵn ở đây: 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)

Một giải pháp khả thi khác ...

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

và sau đó sử dụng ...

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

Tôi không khuyên bạn nên làm một điều như vậy. Như đã đề cập nhiều lần install_requiresvà requirements.txtchắc chắn không phải là cùng một danh sách. Nhưng vì có rất nhiều câu trả lời sai lệch xung quanh liên quan đến các API nội bộ riêng tư của pip , nên có thể đáng để xem xét các lựa chọn thay thế ...

Không cần pip để phân tích requirements.txttệp từ tập lệnh setuptools setup.py . Các setuptools dự án đã có chứa tất cả các công cụ cần thiết trong nó cấp cao nhất gói pkg_resources.

Nó có thể ít nhiều trông như thế này:

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

Đăng chéo câu trả lời của tôi từ câu hỏi SO này cho một giải pháp chứng minh phiên bản pip đơn giản khác.

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

Sau đó, chỉ cần ném vào tất cả các yêu cầu của bạn dưới requirements.txtthư mục gốc của dự án.

Tôi đã làm điều này:

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

Một parse_requirementshack khác cũng phân tích các dấu môi trường thành 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
)

Nó sẽ hỗ trợ cả sdist và dists nhị phân.

Như đã nêu của những người khác, parse_requirementscó một số thiếu sót, vì vậy đây không phải là điều bạn nên làm trong các dự án công cộng, nhưng nó có thể đủ cho các dự án nội bộ / cá nhân.

Đây là một bản hack hoàn chỉnh (đã được thử nghiệm pip 9.0.1) dựa trên câu trả lời của Romain để phân tích requirements.txtvà lọc nó theo các dấu môi trường hiện tại :

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)