Setuptools setup.py dosyasındaki install_requires kwarg için başvuru gereksinimleri.txt

Bir var requirements.txtTravis-CI ile kullanıyorum o dosyayı. Her ikisinde de gereksinimleri çoğaltmak aptalca görünüyor requirements.txtve setup.pybu yüzden install_requireskwarg'a bir dosya tanıtıcısı geçirmeyi umuyordum setuptools.setup.

Mümkün mü? Öyleyse, bunu nasıl yapmalıyım?

İşte benim requirements.txtdosya:

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

Bunu etrafında çevirmek ve liste içinde bağımlılıkları olabilir setup.pyve tek bir karaktere sahiptir - bir nokta .içinde - requirements.txtyerine.

Alternatif olarak, tavsiye edilmese bile, requirements.txtdosyayı (URL ile herhangi bir harici gereksinimi belirtmiyorsa) aşağıdaki saldırı ile (test edilmiş pip 9.0.1) ayrıştırmak hala mümkündür :

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

Bu, ortam belirteçlerini filtrelemez .

Pip'in eski sürümlerinde, özellikle 6.0'dan daha eski olanlarda , bunu başarmak için kullanılabilecek bir genel API vardır. Bir gereksinim dosyası yorum ( #) içerebilir ve diğer bazı dosyaları ( --requirementveya -r) içerebilir . Böylece, gerçekten ayrıştırmak requirements.txtistiyorsanız pip ayrıştırıcıyı kullanabilirsiniz:

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
)

Yüzünde, öyle görünüyor requirements.txtve setup.pyaptalca kopyalar, ancak form benzer olsa da, amaçlanan fonksiyonun çok farklı olduğunu anlamak önemlidir.

Bir paket yazarının amacı, bağımlılıkları belirtirken, "bu paketi her nereye yüklerseniz yükleyin, bu paketin çalışması için ihtiyacınız olan diğer paketlerdir" demektir.

Buna karşılık, dağıtım yazarı (farklı bir zamanda aynı kişi olabilir) farklı bir işe sahiptir, çünkü "burada topladığımız ve test ettiğimiz ve şimdi yüklemem gereken paketler listesi".

Paket yazarı çok çeşitli senaryolar için yazıyor, çünkü çalışmalarını bilmedikleri yollarla kullanılmak üzere ortaya koyuyorlar ve paketlerinin yanında hangi paketlerin kurulacağını bilmenin bir yolu yok. İyi bir komşu olmak ve diğer paketlerle bağımlılık sürümü çakışmalarını önlemek için, muhtemelen çalışabilecek kadar geniş bir bağımlılık sürümleri yelpazesi belirtmeleri gerekir. Bu ne install_requiresde setup.pyyapar.

Dağıtım yazarı çok farklı ve çok özel bir amaç için yazar: yüklü bir uygulamanın veya hizmetin belirli bir bilgisayara yüklenen tek bir örneği. Bir dağıtımı tam olarak denetlemek ve doğru paketlerin sınandığından ve dağıtıldığından emin olmak için, dağıtım yazarının, bağımlılıklar ve bağımlılık bağımlılıkları da dahil olmak üzere, yüklenecek her paketin tam sürümünü ve kaynak konumunu belirtmesi gerekir. Bu spesifikasyonla, bir dağıtım birkaç makineye tekrarlanabilir şekilde uygulanabilir veya bir test makinesinde test edilebilir ve dağıtım yazarı her seferinde aynı paketlerin konuşlandırıldığından emin olabilir. Bu, a'nın requirements.txtyaptığı şeydir .

Gördüğünüz gibi, ikisi de büyük bir paket ve sürüm listesi gibi görünse de, bu iki şeyin çok farklı işleri var. Ve bunu karıştırmak ve yanlış yapmak kesinlikle kolay! Ancak bunu düşünmenin doğru yolu requirements.txt, çeşitli setup.pypaket dosyalarındaki gereksinimlerin ortaya koyduğu "soru" nun "cevabı" dır . Elle yazmak yerine, genellikle pip'e setup.py, istenen paketlerdeki tüm dosyalara bakmasını, tüm gereksinimlere uyduğunu düşündüğü bir paket kümesi bulmasını ve ardından kurulduktan sonra "dondurmasını söyleyerek üretilir. msgstr "bu paketlerin listesini bir metin dosyasına ( pip freezeadın geldiği yer).

Yani paket servisi olan restoran:

• setup.pyhala uygulanabilir olan en gevşek bağımlılık sürümlerini bildirmelidir. Görevi, belirli bir paketin neyle çalışabileceğini söylemek.
• requirements.txttüm kurulum işini tanımlayan ve herhangi bir pakete bağlı olduğu düşünülmemesi gereken bir dağıtım bildirimidir. Görevi, bir dağıtım işini yapmak için gerekli tüm paketlerin kapsamlı bir listesini bildirmektir.
• Bu iki şeyin çok farklı içeriği ve mevcut nedenleri olduğundan, birini diğerine kopyalamak mümkün değildir.

Referanslar:

• install_requires vs Gereksinimler dosyaları Python paketleme kullanıcı kılavuzundan.

Bir dosya tanıtıcısı alamaz. Bağımsız install_requiresdeğişken yalnızca bir dize veya bir dize listesi olabilir .

Elbette dosyanızı kurulum komut dosyasında okuyabilir ve dizelerin bir listesi olarak iletebilirsiniz install_requires.

import os
from setuptools import setup

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

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

Gereksinim dosyaları, yalnızca setup.pydaha güçlü kısıtlamalarla tamamlamanız gerektiğinde yararlı olan genişletilmiş bir pip biçimi kullanır ; örneğin, bazı bağımlılıkların gelmesi gereken kesin URL'leri veya pip freezetüm paket setini bilinen çalışana dondurmak için çıktısını belirtme sürümleri. Ekstra kısıtlamalara ihtiyacınız yoksa yalnızca a kullanın setup.py. Gerçekten bir şekilde göndermeniz gerektiğini düşünüyorsanız requirements.txt, bunu tek bir hat haline getirebilirsiniz:

.

Geçerli olacak ve tam olarak setup.pyaynı dizindeki içeriğe atıfta bulunacaktır .

Soruya kesin bir cevap olmasa da , bu sorunu iyi bir şekilde ele almak için https://caremad.io/2013/07/setup-vs-requirement/ adresinde Donald Stufft'ın blog gönderisini öneriyorum . Büyük başarı için kullanıyorum.

Kısacası, requirements.txtbir setup.pyalternatif değil , bir dağıtım tamamlayıcısıdır. İçindeki paket bağımlılıklarını uygun bir şekilde saklayın setup.py. requirements.txtGeliştirme, test veya üretim için paket bağımlılıklarının belirli sürümlerini getirecek şekilde ayarlayın .

Örneğin aşağıdaki repoya dahil olan paketler deps/:

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

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

pip, paketleri yürütür setup.pyve bildirilen bağımlılıkların belirli sürümlerini yükler install_requires. Hiçbir kopya yoktur ve her iki eserin amacı korunur.

Kullanılması parse_requirementspip API genel olarak belgelenen ve desteklenmediği için problemlidir. Pip 1.6'da, bu fonksiyon aslında hareket ediyor, bu yüzden mevcut kullanımları kırılacak.

Daha güvenilir yolu arasındaki tekrarını ortadan kaldırmak setup.pyve requirements.txtspesifik etmektir bağımlılıkları içinde setup.pyve daha sonra koyun -e .senin içine requirements.txtdosyası. pipGeliştiricilerin birinden, bunun neden daha iyi bir yol olduğu hakkında bazı bilgileri burada bulabilirsiniz: https://caremad.io/blog/setup-vs-requirement/

Yukarıdaki diğer cevapların çoğu pip'in API'sinin mevcut sürümü ile çalışmaz. İşte pip'in geçerli sürümü ile yapmanın doğru * yolu (yazma sırasında 6.0.8, 7.1.2'de de çalıştı. Pip-V ile sürümünüzü kontrol edebilirsiniz).

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

* Doğru, geçerli pip ile parse_requirements kullanmanın yolu olmasıdır. Yine de muhtemelen bunu yapmanın en iyi yolu değil, çünkü yukarıdaki posterlerin söylediği gibi pip gerçekten bir API tutmuyor.

Geçerli paketi Travis'e yükleyin. Bu bir requirements.txtdosyanın kullanılmasını önler . Örneğin:

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

from pip.req import parse_requirements benim için çalışmadı ve bence gereksinimlerimdeki boş satırlar için. txt, ancak bu işlev işe yarıyor

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

Kullanıcılarınızı pip kurmaya zorlamak istemiyorsanız, davranışını şu şekilde taklit edebilirsiniz:

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

Aşağıdaki arabirim 10. pip'te kullanımdan kaldırıldı:

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

Bu yüzden sadece basit metin ayrıştırmaya geçtim:

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

Bu basit yaklaşım, ihtiyaçlar dosyasından okur setup.py. Bu cevap Dmitiry S. tarafından bir varyasyon . Bu cevap yalnızca Python 3.6+ ile uyumludur.

Başına DS , requirements.txtoysa belirli sürüm numaralarıyla somut şartları belgelenebilir setup.pygevşek versiyonu aralıklarına sahip soyut gereklerini karşılamak için gerekli olabilir.

Aşağıda benim bir alıntı 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.TextFileYorumların kaldırılacağını unutmayın . Ayrıca, tecrübelerime göre, görünüşe göre gereksinimler dosyasında paketlemek için herhangi bir özel adım atmanıza gerek yok.

parse_requirementsDAVRANIŞ DİKKAT EDİN !

pip.req.parse_requirementsAlt çizgileri tire işareti olarak değiştireceğinizi lütfen unutmayın . Bu onu keşfetmeden önce birkaç gün beni çok etkiledi. Gösteren örnek:

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

üretir

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

Bunun için yeniden kullanılabilir bir fonksiyon oluşturdum. Aslında gereksinim dosyalarının tüm dizinini ayrıştırır ve extras_require olarak ayarlar.

En son her zaman burada bulunabilir: 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)

Başka bir olası çözüm ...

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

ve sonra kullanmak için ...

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

Ben böyle bir şey yapmayı tavsiye etmem. Birden fazla kez belirtildiği gibi install_requiresve requirements.txtkesinlikle aynı liste olması gerekiyordu. Ancak, pip'in dahili dahili API'lerini içeren birçok yanıltıcı cevap olduğu için olduğu için, daha sağlıklı alternatiflere bakmaya değer olabilir ...

Gerek yoktur pip bir ayrıştırmak için requirements.txtbir dosyayı Setuptools setup.py senaryo. Setuptools zaten proje onun gerekli tüm araçları içerir üst düzey paketinde pkg_resources.

Aşağı yukarı böyle görünebilir:

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

Başka bir basit, pip sürüm kanıtı çözümü için bu SO soruya cevabımı çapraz gönderme .

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

Ardından, tüm gereksinimlerinizi requirements.txtproje kök dizini altına girin.

Bunu ben yaptım:

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Çevre belirteçlerini de ayrıştıran bir başka saldırı 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
)

Hem sdist hem de ikili dağıtımları desteklemelidir.

Başkaları tarafından belirtildiği gibi parse_requirements, bazı eksiklikler vardır, bu yüzden kamu projelerinde yapmanız gerekenler değildir, ancak iç / kişisel projeler için yeterli olabilir.

Romain'in cevabını mevcut ortam belirteçlerine göre ayrıştıran ve filtreleyen cevabınapip 9.0.1 dayanan tam bir saldırı (test edildi ) :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)