setuptools setup.py 파일의 install_requires kwarg에 대한 참조 requirements.txt

requirements.txtTravis-CI와 함께 사용 중인 파일이 있습니다. 모두의 요구 사항을 복제하는 어리석은 것 requirements.txt와 setup.py난에 파일 핸들을 전달하기 위해 기대했다, 그래서 install_requires에서 kwarg setuptools.setup.

이게 가능해? 그렇다면 어떻게해야합니까?

내 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

당신은 그것을 주위를 뒤집어 목록에서 종속성을 수 setup.py및 단일 문자가 - 점을 .에 - requirements.txt대신.

또는 권장 requirements.txt하지 않더라도 (다음으로 테스트 한 pip 9.0.1) 해킹을 사용 하여 파일 (URL로 외부 요구 사항을 참조하지 않는 경우) 을 파싱 할 수 있습니다 .

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

그러나 환경 마커 는 필터링하지 않습니다 .

이전 버전의 pip, 특히 6.0보다 오래된 버전에서는 이를 달성하는 데 사용할 수있는 공개 API가 있습니다. 요구 사항 파일은 주석 ( #)을 포함 할 수 있으며 다른 파일 ( --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
)

그것의 얼굴에, 그 보이지 않는 requirements.txt및 setup.py바보 중복, 그러나 그것은 형태가 유사한 반면, 의도 한 기능이 매우 다르다는 것을 이해하는 것이 중요합니다.

종속성을 지정할 때 패키지 작성자의 목표는 "이 패키지를 설치할 때마다이 패키지가 작동하기 위해 필요한 다른 패키지입니다"라고 말하는 것입니다.

반대로 배포 작성자 (다른 시간에 같은 사람 일 수 있음)는 "우리가 함께 모아서 테스트하여 설치해야하는 패키지 목록이 있습니다"라는 점에서 다른 역할을합니다.

패키지 작성자는 다양한 시나리오에 대해 작성합니다. 그들이 알지 못하는 방식으로 작업을 수행하고 패키지와 함께 어떤 패키지가 설치 될지 알 수 없기 때문입니다. 좋은 이웃이되고 다른 패키지와의 종속성 버전 충돌을 피하려면 가능한 한 다양한 종속성 버전을 지정해야합니다. 이것이하는 일 install_requires입니다 setup.py.

배포 작성자는 매우 다른 매우 구체적인 목표, 즉 특정 컴퓨터에 설치된 설치된 응용 프로그램 또는 서비스의 단일 인스턴스를 작성합니다. 배포를 정확하게 제어하고 올바른 패키지를 테스트하고 배포하려면 배포 작성자가 종속성 및 종속성의 종속성을 포함하여 설치할 모든 패키지의 정확한 버전과 소스 위치를 지정해야합니다. 이 사양을 사용하면 배포를 여러 컴퓨터에 반복적으로 적용하거나 테스트 컴퓨터에서 테스트 할 수 있으며 배포 작성자는 매번 동일한 패키지가 배포 될 것을 확신 할 수 있습니다. 이것이 무엇을 하는가 requirements.txt입니다.

패키지와 버전의 큰 목록처럼 보이지만이 두 가지 작업은 매우 다릅니다. 그리고 이것을 섞어서 틀리게 만드는 것은 확실히 쉽습니다! 그러나 이것을 생각하는 올바른 방법 requirements.txt은 모든 다양한 setup.py패키지 파일 의 요구 사항에 의해 제기 된 "질문"에 대한 "답변" 입니다. 직접 작성하는 대신, pip에게 setup.py원하는 패키지 세트의 모든 파일 을보고, 모든 요구 사항에 맞는 패키지 세트를 찾은 다음, 설치 후 "고정"으로 생성하여 생성됩니다. "해당 패키지 목록을 텍스트 파일로 저장합니다 (여기서 pip freeze이름이 나오는 곳).

따라서 테이크 아웃 :

• setup.py여전히 실행 가능한 가장 느슨한 종속성 버전을 선언해야합니다. 그 작업은 특정 패키지가 작동 할 수있는 것을 말하는 것입니다.
• requirements.txt전체 설치 작업을 정의하는 배포 매니페스트이며 어떤 패키지에 묶여 있다고 생각해서는 안됩니다. 배포 작업을 수행하는 데 필요한 모든 패키지의 전체 목록을 선언해야합니다.
• 이 두 가지 내용은 기존과 다른 내용과 이유를 가지고 있기 때문에 서로를 단순히 복사하는 것은 불가능합니다.

참고 문헌 :

• Python 패키징 사용자 안내서의 install_requires 및 요구 사항 파일

파일 핸들을 사용할 수 없습니다. install_requires인수는 수 만 문자열이나 문자열 목록 수 .

물론 설정 스크립트에서 파일을 읽고 문자열 목록으로 전달할 수 install_requires있습니다.

import os
from setuptools import setup

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

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

요구 사항 파일은 확장 된 pip 형식을 사용합니다. setup.py예를 들어 일부 종속 항목의 정확한 URL을 지정하거나 pip freeze전체 패키지 세트를 알려진 작업으로 고정하는 출력을 지정하는 등보다 강력한 제한 조건 으로 보완해야하는 경우에만 유용 합니다. 버전. 추가 제약이 필요하지 않은 경우을 사용하십시오 setup.py. requirements.txt어쨌든 실제로 배송해야 한다고 생각되면 한 줄로 만들 수 있습니다.

.

유효하며 setup.py동일한 디렉토리에있는 내용을 정확하게 참조하십시오 .

이 질문에 대한 정확한 대답은 아니지만 이 문제를 잘 이해 하려면 Donald Stufft의 블로그 게시물 ( https://caremad.io/2013/07/setup-vs-requirement/) 을 추천합니다. 나는 그것을 큰 성공을 위해 사용하고 있습니다.

즉, requirements.txt아닌 setup.py다른,하지만 배포 보완. 에 패키지 종속성의 적절한 추상화를 유지하십시오 setup.py. requirements.txt개발, 테스트 또는 프로덕션을 위해 특정 버전의 패키지 종속성을 가져 오도록 설정하십시오 .

예를 들어 아래의 저장소에 패키지가 포함 된 경우 deps/:

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

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

pip는 패키지를 실행 setup.py하고에 선언 된 특정 버전의 종속성을 설치합니다 install_requires. 이중성이 없으며 두 아티팩트의 목적이 유지됩니다.

parse_requirementspip API가 공개적으로 문서화되고 지원되지 않기 때문에 사용 에 문제가 있습니다. pip 1.6에서는 해당 기능이 실제로 이동하므로 기존 기능을 사용하기가 어려울 수 있습니다.

더 신뢰할 수있는 방법 사이의 중복을 제거하기 setup.py및 requirements.txt특정에 당신의 종속성을에 setup.py다음 넣어 -e .당신에 requirements.txt파일. pip왜 더 좋은 방법인지 에 대한 개발자 중 한 사람의 정보는 https://caremad.io/blog/setup-vs-requirement/에서 확인할 수 있습니다.

위의 다른 답변 대부분은 현재 버전의 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
    ....
)

* 현재 pip와 함께 parse_requirements를 사용하는 방법이라는 점에서 정확합니다. 위의 포스터가 말했듯이 pip는 실제로 API를 유지 관리하지 않기 때문에 여전히 최선의 방법은 아닙니다.

Travis에 현재 패키지를 설치하십시오. 이것은 requirements.txt파일 사용을 피 합니다. 예를 들면 다음과 같습니다.

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

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

사용자가 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'))
)

다음 인터페이스는 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 != ''
    ]

이 간단한 접근 방식은에서 요구 사항 파일을 읽습니다 setup.py. Dmitiry S 의 답변의 변형입니다 . . 이 답변은 Python 3.6 이상에서만 호환됩니다.

당 DS , 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이 제거됩니다. 또한 내 경험에 따라 요구 사항 파일에 번들하기 위해 특별한 단계를 수행 할 필요는 없습니다.

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

이를 위해 재사용 가능한 함수를 만들었습니다. 실제로 요구 사항 파일의 전체 디렉토리를 구문 분석하여 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)

또 다른 가능한 해결책은 ...

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

나는 그런 일을하지 않는 것이 좋습니다. 여러 번 언급 한 바와 같이 install_requires하고 requirements.txt확실히 동일한 목록 있어야되지 않습니다. 그러나 pip의 개인 내부 API와 관련하여 오해의 소지가 많은 답변이 있기 때문에 더 멋진 대안을 살펴볼 가치가 있습니다 ...

필요가 없습니다 piprequirements.txt 는 setuptools setup.py 스크립트 에서 파일 을 구문 분석 . 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,
)

이 간단한 질문에 대한 답변을 교차 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프로젝트 루트 디렉토리 아래에 모든 요구 사항을 입력하십시오 .

나는 이걸했다:

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

parse_requirements환경 마커를 파싱하는 또 다른 해킹 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와 binary dists를 모두 지원해야합니다.

다른 사람들이 말했듯 parse_requirements이 몇 가지 단점이 있으므로 이것은 공공 프로젝트에서해야 할 일이 아니지만 내부 / 개인 프로젝트에는 충분할 수 있습니다.

다음은 현재 환경 마커 에 따라 구문 분석 하고 필터링하는 Romain의 답변 을 pip 9.0.1기반으로 한 완전한 해킹 (으로 테스트 )입니다 .requirements.txt

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)