@ -1,9 +1,8 @@
#!/usr/ bin/python3 -s #!/usr/ libexec/platform-python
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
# #
# Copyright 2010 Per Øyvind Karlsen <proyvind@moondrake.org> # Copyright 2010 Per Øyvind Karlsen <proyvind@moondrake.org>
# Copyright 2015 Neal Gompa <ngompa13@gmail.com> # Copyright 2015 Neal Gompa <ngompa13@gmail.com>
# Copyright 2020 SUSE LLC
# #
# This program is free software. It may be redistributed and/or modified under # This program is free software. It may be redistributed and/or modified under
# the terms of the LGPL version 2.1 (or later). # the terms of the LGPL version 2.1 (or later).
@ -12,328 +11,79 @@
# #
from __future__ import print_function from __future__ import print_function
import argparse from getopt import getopt
from os . path import dirname , sep from os . path import basename , dirname , isdir , sep
import re from sys import argv , stdin , version
from sys import argv , stdin , stderr , version_info from distutils . sysconfig import get_python_lib
from sysconfig import get_path
from warnings import warn from warnings import warn
from packaging . requirements import Requirement as Requirement_
from packaging . version import parse
import packaging . markers
# Monkey patching packaging.markers to handle extras names in a opts , args = getopt (
# case-insensitive manner: argv [ 1 : ] , ' hPRrCEMmLl: ' ,
# pip considers dnspython[DNSSEC] and dnspython[dnssec] to be equal, but [ ' help ' , ' provides ' , ' requires ' , ' recommends ' , ' conflicts ' , ' extras ' , ' majorver-provides ' , ' majorver-provides-versions= ' , ' majorver-only ' , ' legacy-provides ' , ' legacy ' ] )
# packaging markers treat extras in a case-sensitive manner. To solve this
# issue, we introduce a comparison operator that compares case-insensitively Provides = False
# if both sides of the comparison are strings. And then we inject this Requires = False
# operator into packaging.markers to be used when comparing names of extras. Recommends = False
# Fedora BZ: https://bugzilla.redhat.com/show_bug.cgi?id=1936875 Conflicts = False
# Upstream issue: https://discuss.python.org/t/what-extras-names-are-treated-as-equal-and-why/7614 Extras = False
# - After it's established upstream what is the canonical form of an extras Provides_PyMajorVer_Variant = False
# name, we plan to open an issue with packaging to hopefully solve this Provides_PyMajorVer_Versions = None
# there without having to resort to monkeypatching. PyMajorVer_Deps = False
def str_lower_eq ( a , b ) : legacy_Provides = False
if isinstance ( a , str ) and isinstance ( b , str ) :
legacy = False
return a . lower ( ) == b . lower ( )
else :
for o , a in opts :
return a == b
if o in ( ' -h ' , ' --help ' ) :
packaging . markers . _operators [ " == " ] = str_lower_eq print ( ' -h, --help \t Print help ' )
print ( ' -P, --provides \t Print Provides ' )
try : print ( ' -R, --requires \t Print Requires ' )
from importlib . metadata import PathDistribution
print ( ' -r, --recommends \t Print Recommends ' )
except ImportError : print ( ' -C, --conflicts \t Print Conflicts ' )
from importlib_metadata import PathDistribution
print ( ' -E, --extras \t Print Extras ' )
print ( ' -M, --majorver-provides \t Print extra Provides with Python major version only for all Python versions ' )
try : print ( ' --majorver-provides-versions VERSIONS \n '
from pathlib import Path
' \t Print extra Provides with Python major version only for listed Python VERSIONS (comma separated, no spaces, e.g. 2.7,3.6) ' )
except ImportError : print ( ' -m, --majorver-only \t Print Provides/Requires with Python major version only ' )
from pathlib2 import Path
print ( ' -L, --legacy-provides \t Print extra legacy pythonegg Provides ' )
print ( ' -l, --legacy \t Print legacy pythonegg Provides/Requires instead ' )
exit ( 1 )
def normalize_name ( name ) : elif o in ( ' -P ' , ' --provides ' ) :
""" https://www.python.org/dev/peps/pep-0503/#normalized-names """
Provides = True
return re . sub ( r ' [-_.]+ ' , ' - ' , name ) . lower ( )
elif o in ( ' -R ' , ' --requires ' ) :
Requires = True
elif o in ( ' -r ' , ' --recommends ' ) :
def legacy_normalize_name ( name ) : Recommends = True
""" Like pkg_resources Distribution.key property """
elif o in ( ' -C ' , ' --conflicts ' ) :
return re . sub ( r ' [-_]+ ' , ' - ' , name ) . lower ( )
Conflicts = True
elif o in ( ' -E ' , ' --extras ' ) :
Extras = True
class Requirement ( Requirement_ ) : elif o in ( ' -M ' , ' --majorver-provides ' ) :
def __init__ ( self , requirement_string ) :
Provides_PyMajorVer_Variant = True
super ( Requirement , self ) . __init__ ( requirement_string )
elif o in ( ' --majorver-provides-versions ' ) :
self . normalized_name = normalize_name ( self . name )
Provides_PyMajorVer_Versions = a . split ( " , " )
self . legacy_normalized_name = legacy_normalize_name ( self . name )
elif o in ( ' -m ' , ' --majorver-only ' ) :
PyMajorVer_Deps = True
elif o in ( ' -L ' , ' --legacy-provides ' ) :
class Distribution ( PathDistribution ) : legacy_Provides = True
def __init__ ( self , path ) :
elif o in ( ' -l ' , ' --legacy ' ) :
super ( Distribution , self ) . __init__ ( Path ( path ) )
legacy = True
self . normalized_name = normalize_name ( self . name )
self . legacy_normalized_name = legacy_normalize_name ( self . name )
if Provides_PyMajorVer_Variant and Provides_PyMajorVer_Versions :
self . requirements = [ Requirement ( r ) for r in self . requires or [ ] ]
print ( " Error, options --majorver-provides and --majorver-provides-versions are mutually incompatible. " )
self . extras = [
exit ( 2 )
v . lower ( ) for k , v in self . metadata . items ( ) if k == ' Provides-Extra ' ]
self . py_version = self . _parse_py_version ( path )
if Requires :
py_abi = True
# `name` is defined as a property exactly like this in Python 3.10 in the
else :
# PathDistribution class. Due to that we can't redefine `name` as a normal
py_abi = False
# attribute. So we copied the Python 3.10 definition here into the code so
py_deps = { }
# that it works also on previous Python/importlib_metadata versions.
if args :
@property
files = args
def name ( self ) :
else :
""" Return the ' Name ' metadata for the distribution package. """
files = stdin . readlines ( )
return self . metadata [ ' Name ' ]
def _parse_py_version ( self , path ) :
# Try to parse the Python version from the path the metadata
# resides at (e.g. /usr/lib/pythonX.Y/site-packages/...)
res = re . search ( r " /python(?P<pyver> \ d+ \ . \ d+)/ " , path )
if res :
return res . group ( ' pyver ' )
# If that hasn't worked, attempt to parse it from the metadata
# directory name
res = re . search ( r " -py(?P<pyver> \ d+. \ d+)[.-]egg-info$ " , path )
if res :
return res . group ( ' pyver ' )
return None
def requirements_for_extra ( self , extra ) :
extra_deps = [ ]
for req in self . requirements :
if not req . marker :
continue
if req . marker . evaluate ( get_marker_env ( self , extra ) ) :
extra_deps . append ( req )
return extra_deps
def __repr__ ( self ) :
return ' {} from {} ' . format ( self . name , self . _path )
class RpmVersion ( ) :
def __init__ ( self , version_id ) :
version = parse ( version_id )
if isinstance ( version . _version , str ) :
self . version = version . _version
else :
self . epoch = version . _version . epoch
self . version = list ( version . _version . release )
self . pre = version . _version . pre
self . dev = version . _version . dev
self . post = version . _version . post
def increment ( self ) :
self . version [ - 1 ] + = 1
self . pre = None
self . dev = None
self . post = None
return self
def __str__ ( self ) :
if isinstance ( self . version , str ) :
return self . version
if self . epoch :
rpm_epoch = str ( self . epoch ) + ' : '
else :
rpm_epoch = ' '
while len ( self . version ) > 1 and self . version [ - 1 ] == 0 :
self . version . pop ( )
rpm_version = ' . ' . join ( str ( x ) for x in self . version )
if self . pre :
rpm_suffix = ' ~ {} ' . format ( ' ' . join ( str ( x ) for x in self . pre ) )
elif self . dev :
rpm_suffix = ' ~~ {} ' . format ( ' ' . join ( str ( x ) for x in self . dev ) )
elif self . post :
rpm_suffix = ' ^post {} ' . format ( self . post [ 1 ] )
else :
rpm_suffix = ' '
return ' {} {} {} ' . format ( rpm_epoch , rpm_version , rpm_suffix )
def convert_compatible ( name , operator , version_id ) :
if version_id . endswith ( ' .* ' ) :
print ( " *** INVALID_REQUIREMENT_ERROR___SEE_STDERR *** " )
print ( ' Invalid requirement: {} {} {} ' . format ( name , operator , version_id ) , file = stderr )
exit ( 65 ) # os.EX_DATAERR
version = RpmVersion ( version_id )
if len ( version . version ) == 1 :
print ( " *** INVALID_REQUIREMENT_ERROR___SEE_STDERR *** " )
print ( ' Invalid requirement: {} {} {} ' . format ( name , operator , version_id ) , file = stderr )
exit ( 65 ) # os.EX_DATAERR
upper_version = RpmVersion ( version_id )
upper_version . version . pop ( )
upper_version . increment ( )
return ' ( {} >= {} with {} < {} ) ' . format (
name , version , name , upper_version )
def convert_equal ( name , operator , version_id ) :
if version_id . endswith ( ' .* ' ) :
version_id = version_id [ : - 2 ] + ' .0 '
return convert_compatible ( name , ' ~= ' , version_id )
version = RpmVersion ( version_id )
return ' {} = {} ' . format ( name , version )
def convert_arbitrary_equal ( name , operator , version_id ) :
if version_id . endswith ( ' .* ' ) :
print ( " *** INVALID_REQUIREMENT_ERROR___SEE_STDERR *** " )
print ( ' Invalid requirement: {} {} {} ' . format ( name , operator , version_id ) , file = stderr )
exit ( 65 ) # os.EX_DATAERR
version = RpmVersion ( version_id )
return ' {} = {} ' . format ( name , version )
def convert_not_equal ( name , operator , version_id ) :
if version_id . endswith ( ' .* ' ) :
version_id = version_id [ : - 2 ]
version = RpmVersion ( version_id )
lower_version = RpmVersion ( version_id ) . increment ( )
else :
version = RpmVersion ( version_id )
lower_version = version
return ' ( {} < {} or {} > {} ) ' . format (
name , version , name , lower_version )
def convert_ordered ( name , operator , version_id ) :
if version_id . endswith ( ' .* ' ) :
# PEP 440 does not define semantics for prefix matching
# with ordered comparisons
version_id = version_id [ : - 2 ]
version = RpmVersion ( version_id )
if operator == ' > ' :
# distutils will allow a prefix match with '>'
operator = ' >= '
if operator == ' <= ' :
# distutils will not allow a prefix match with '<='
operator = ' < '
else :
version = RpmVersion ( version_id )
return ' {} {} {} ' . format ( name , operator , version )
OPERATORS = { ' ~= ' : convert_compatible ,
' == ' : convert_equal ,
' === ' : convert_arbitrary_equal ,
' != ' : convert_not_equal ,
' <= ' : convert_ordered ,
' < ' : convert_ordered ,
' >= ' : convert_ordered ,
' > ' : convert_ordered }
def convert ( name , operator , version_id ) :
try :
return OPERATORS [ operator ] ( name , operator , version_id )
except Exception as exc :
raise RuntimeError ( " Cannot process Python package version ` {} ` for name ` {} ` " .
format ( version_id , name ) ) from exc
def get_marker_env ( dist , extra ) :
# packaging uses a default environment using
# platform.python_version to evaluate if a dependency is relevant
# based on environment markers [1],
# e.g. requirement `argparse;python_version<"2.7"`
#
# Since we're running this script on one Python version while
# possibly evaluating packages for different versions, we
# set up an environment with the version we want to evaluate.
#
# [1] https://www.python.org/dev/peps/pep-0508/#environment-markers
return { " python_full_version " : dist . py_version ,
" python_version " : dist . py_version ,
" extra " : extra }
if __name__ == " __main__ " :
""" To allow this script to be importable (and its classes/functions
reused ) , actions are performed only when run as a main script . """
parser = argparse . ArgumentParser ( prog = argv [ 0 ] )
group = parser . add_mutually_exclusive_group ( required = True )
group . add_argument ( ' -P ' , ' --provides ' , action = ' store_true ' , help = ' Print Provides ' )
group . add_argument ( ' -R ' , ' --requires ' , action = ' store_true ' , help = ' Print Requires ' )
group . add_argument ( ' -r ' , ' --recommends ' , action = ' store_true ' , help = ' Print Recommends ' )
group . add_argument ( ' -C ' , ' --conflicts ' , action = ' store_true ' , help = ' Print Conflicts ' )
group . add_argument ( ' -E ' , ' --extras ' , action = ' store_true ' , help = ' [Unused] Generate spec file snippets for extras subpackages ' )
group_majorver = parser . add_mutually_exclusive_group ( )
group_majorver . add_argument ( ' -M ' , ' --majorver-provides ' , action = ' store_true ' , help = ' Print extra Provides with Python major version only ' )
group_majorver . add_argument ( ' --majorver-provides-versions ' , action = ' append ' ,
help = ' Print extra Provides with Python major version only for listed '
' Python VERSIONS (appended or comma separated without spaces, e.g. 2.7,3.9) ' )
parser . add_argument ( ' -m ' , ' --majorver-only ' , action = ' store_true ' , help = ' Print Provides/Requires with Python major version only ' )
parser . add_argument ( ' -n ' , ' --normalized-names-format ' , action = ' store ' ,
default = " legacy-dots " , choices = [ " pep503 " , " legacy-dots " ] ,
help = ' Format of normalized names according to pep503 or legacy format that allows dots [default] ' )
parser . add_argument ( ' --normalized-names-provide-both ' , action = ' store_true ' ,
help = ' Provide both `pep503` and `legacy-dots` format of normalized names (useful for a transition period) ' )
parser . add_argument ( ' -L ' , ' --legacy-provides ' , action = ' store_true ' , help = ' Print extra legacy pythonegg Provides ' )
parser . add_argument ( ' -l ' , ' --legacy ' , action = ' store_true ' , help = ' Print legacy pythonegg Provides/Requires instead ' )
parser . add_argument ( ' --console-scripts-nodep-setuptools-since ' , action = ' store ' ,
help = ' An optional Python version (X.Y), at least 3.8. '
' For that version and any newer version, '
' a dependency on " setuptools " WILL NOT be generated for packages with console_scripts/gui_scripts entry points. '
' By setting this flag, you guarantee that setuptools >= 47.2.0 is used '
' during the build of packages for this and any newer Python version. ' )
parser . add_argument ( ' --require-extras-subpackages ' , action = ' store_true ' ,
help = " If there is a dependency on a package with extras functionality, require the extras subpackage " )
parser . add_argument ( ' --package-name ' , action = ' store ' , help = " Name of the RPM package that ' s being inspected. Required for extras requires/provides to work. " )
parser . add_argument ( ' files ' , nargs = argparse . REMAINDER , help = " Files from the RPM package that are to be inspected, can also be supplied on stdin " )
args = parser . parse_args ( )
py_abi = args . requires
py_deps = { }
if args . majorver_provides_versions :
# Go through the arguments (can be specified multiple times),
# and parse individual versions (can be comma-separated)
args . majorver_provides_versions = [ v for vstring in args . majorver_provides_versions
for v in vstring . split ( " , " ) ]
# If normalized_names_require_pep503 is True we require the pep503
# normalized name, if it is False we provide the legacy normalized name
normalized_names_require_pep503 = args . normalized_names_format == " pep503 "
# If normalized_names_provide_pep503/legacy is True we provide the
# pep503/legacy normalized name, if it is False we don't
normalized_names_provide_pep503 = \
args . normalized_names_format == " pep503 " or args . normalized_names_provide_both
normalized_names_provide_legacy = \
args . normalized_names_format == " legacy-dots " or args . normalized_names_provide_both
# At least one type of normalization must be provided
assert normalized_names_provide_pep503 or normalized_names_provide_legacy
if args . console_scripts_nodep_setuptools_since :
nodep_setuptools_pyversion = parse ( args . console_scripts_nodep_setuptools_since )
if nodep_setuptools_pyversion < parse ( " 3.8 " ) :
print ( " Only version 3.8+ is supported in --console-scripts-nodep-setuptools-since " , file = stderr )
print ( " *** PYTHON_EXTRAS_ARGUMENT_ERROR___SEE_STDERR *** " )
exit ( 65 ) # os.EX_DATAERR
else :
nodep_setuptools_pyversion = None
# Is this script being run for an extras subpackage?
extras_subpackage = None
if args . package_name and ' + ' in args . package_name :
# The extras names are encoded in the package names after the + sign.
# We take the part after the rightmost +, ignoring when empty,
# this allows packages like nicotine+ or c++ to work fine.
# While packages with names like +spam or foo+bar would break,
# names started with the plus sign are not very common
# and pluses in the middle can be easily replaced with dashes.
# Python extras names don't contain pluses according to PEP 508.
package_name_parts = args . package_name . rpartition ( ' + ' )
extras_subpackage = package_name_parts [ 2 ] . lower ( ) or None
for f in ( args . files or stdin . readlines ( ) ) : for f in files :
f = f . strip ( )
f = f . strip ( )
lower = f . lower ( )
lower = f . lower ( )
name = ' python(abi) '
name = ' python(abi) '
@ -341,9 +91,8 @@ if __name__ == "__main__":
if py_abi and ( lower . endswith ( ' .py ' ) or lower . endswith ( ' .pyc ' ) or lower . endswith ( ' .pyo ' ) ) :
if py_abi and ( lower . endswith ( ' .py ' ) or lower . endswith ( ' .pyc ' ) or lower . endswith ( ' .pyo ' ) ) :
if name not in py_deps :
if name not in py_deps :
py_deps [ name ] = [ ]
py_deps [ name ] = [ ]
running_python_version = ' {} . {} ' . format ( * version_info [ : 2 ] )
purelib = get_python_lib ( standard_lib = 0 , plat_specific = 0 ) . split ( version [ : 3 ] ) [ 0 ]
purelib = get_path ( ' purelib ' ) . split ( running_python_version ) [ 0 ]
platlib = get_python_lib ( standard_lib = 0 , plat_specific = 1 ) . split ( version [ : 3 ] ) [ 0 ]
platlib = get_path ( ' platlib ' ) . split ( running_python_version ) [ 0 ]
for lib in ( purelib , platlib ) :
for lib in ( purelib , platlib ) :
if lib in f :
if lib in f :
spec = ( ' == ' , f . split ( lib ) [ 1 ] . split ( sep ) [ 0 ] )
spec = ( ' == ' , f . split ( lib ) [ 1 ] . split ( sep ) [ 0 ] )
@ -361,84 +110,69 @@ if __name__ == "__main__":
if lower . endswith ( ' .egg ' ) or \
if lower . endswith ( ' .egg ' ) or \
lower . endswith ( ' .egg-info ' ) or \
lower . endswith ( ' .egg-info ' ) or \
lower . endswith ( ' .dist-info ' ) :
lower . endswith ( ' .dist-info ' ) :
dist = Distribution ( f )
# This import is very slow, so only do it if needed
from pkg_resources import Distribution , FileMetadata , PathMetadata
dist_name = basename ( f )
if isdir ( f ) :
path_item = dirname ( f )
metadata = PathMetadata ( path_item , f )
else :
path_item = f
metadata = FileMetadata ( f )
dist = Distribution . from_location ( path_item , dist_name , metadata )
# Check if py_version is defined in the metadata file/directory name
if not dist . py_version :
if not dist . py_version :
# Try to parse the Python version from the path the metadata
# resides at (e.g. /usr/lib/pythonX.Y/site-packages/...)
import re
res = re . search ( r " /python(?P<pyver> \ d+ \ . \ d+)/ " , path_item )
if res :
dist . py_version = res . group ( ' pyver ' )
else :
warn ( " Version for {!r} has not been found " . format ( dist ) , RuntimeWarning )
warn ( " Version for {!r} has not been found " . format ( dist ) , RuntimeWarning )
continue
continue
# If processing an extras subpackage:
# XXX: https://github.com/pypa/setuptools/pull/1275
# Check that the extras name is declared in the metadata, or
import platform
# that there are some dependencies associated with the extras
platform . python_version = lambda : dist . py_version
# name in the requires.txt (this is an outdated way to declare
# extras packages).
# - If there is an extras package declared only in requires.txt
# without any dependencies, this check will fail. In that case
# make sure to use updated metadata and declare the extras
# package there.
if extras_subpackage and extras_subpackage not in dist . extras and not dist . requirements_for_extra ( extras_subpackage ) :
print ( " *** PYTHON_EXTRAS_NOT_FOUND_ERROR___SEE_STDERR *** " )
print ( f " \n Error: The package name contains an extras name ` { extras_subpackage } ` that was not found in the metadata. \n "
" Check if the extras were removed from the project. If so, consider removing the subpackage and obsoleting it from another. \n " , file = stderr )
exit ( 65 ) # os.EX_DATAERR
if args . majorver_provides or args . majorver_provides_versions or \
if Provides_PyMajorVer_Variant or PyMajorVer_Deps or legacy_Provides or legacy or Provides_PyMajorVer_Versions :
args . majorver_only or args . legacy_provides or args . legacy :
# Get the Python major version
# Get the Python major version
pyver_major = dist . py_version . split ( ' . ' ) [ 0 ]
pyver_major = dist . py_version . split ( ' . ' ) [ 0 ]
if args . provides :
if Provides :
extras_suffix = f " [ { extras_subpackage } ] " if extras_subpackage else " "
# If egg/dist metadata says package name is python, we provide python(abi)
# If egg/dist metadata says package name is python, we provide python(abi)
if dist . normalized_name == ' python ' :
if dist . key == ' python ' :
name = ' python(abi) '
name = ' python(abi) '
if name not in py_deps :
if name not in py_deps :
py_deps [ name ] = [ ]
py_deps [ name ] = [ ]
py_deps [ name ] . append ( ( ' == ' , dist . py_version ) )
py_deps [ name ] . append ( ( ' == ' , dist . py_version ) )
if not args . legacy or not args . majorver_only :
if not legacy or not PyMajorVer_Deps :
if normalized_names_provide_legacy :
name = ' python {} dist( {} ) ' . format ( dist . py_version , dist . key )
name = ' python {} dist( {} {} ) ' . format ( dist . py_version , dist . legacy_normalized_name , extras_suffix )
if name not in py_deps :
if name not in py_deps :
py_deps [ name ] = [ ]
py_deps [ name ] = [ ]
if normalized_names_provide_pep503 :
if Provides_PyMajorVer_Variant or PyMajorVer_Deps or \
name_ = ' python {} dist( {} {} ) ' . format ( dist . py_version , dist . normalized_name , extras_suffix )
( Provides_PyMajorVer_Versions and dist . py_version in Provides_PyMajorVer_Versions ) :
if name_ not in py_deps :
pymajor_name = ' python {} dist( {} ) ' . format ( pyver_major , dist . key )
py_deps [ name_ ] = [ ]
if args . majorver_provides or args . majorver_only or \
( args . majorver_provides_versions and dist . py_version in args . majorver_provides_versions ) :
if normalized_names_provide_legacy :
pymajor_name = ' python {} dist( {} {} ) ' . format ( pyver_major , dist . legacy_normalized_name , extras_suffix )
if pymajor_name not in py_deps :
if pymajor_name not in py_deps :
py_deps [ pymajor_name ] = [ ]
py_deps [ pymajor_name ] = [ ]
if normalized_names_provide_pep503 :
if legacy or legacy_Provides :
pymajor_name_ = ' python {} dist( {} {} ) ' . format ( pyver_major , dist . normalized_name , extras_suffix )
legacy_name = ' pythonegg( {} )( {} ) ' . format ( pyver_major , dist . key )
if pymajor_name_ not in py_deps :
py_deps [ pymajor_name_ ] = [ ]
if args . legacy or args . legacy_provides :
legacy_name = ' pythonegg( {} )( {} ) ' . format ( pyver_major , dist . legacy_normalized_name )
if legacy_name not in py_deps :
if legacy_name not in py_deps :
py_deps [ legacy_name ] = [ ]
py_deps [ legacy_name ] = [ ]
if dist . version :
if dist . version :
version = dist . version
spec = ( ' == ' , dist . version )
spec = ( ' == ' , version )
if normalized_names_provide_legacy :
if spec not in py_deps [ name ] :
if spec not in py_deps [ name ] :
if not legacy :
py_deps [ name ] . append ( spec )
py_deps [ name ] . append ( spec )
if args . majorver_provides or \
if Provides_PyMajorVer_Variant or \
( args . majorver_provides_versions and dist . py_version in args . majorver_provides_v ersions) :
( Provides_PyMajorVer_Versions and dist . py_version in Provides_PyMajorVer_V ) :
py_deps [ pymajor_name ] . append ( spec )
py_deps [ pymajor_name ] . append ( spec )
if normalized_names_provide_pep503 :
if legacy or legacy_Provides :
if spec not in py_deps [ name_ ] :
py_deps [ name_ ] . append ( spec )
if args . majorver_provides or \
( args . majorver_provides_versions and dist . py_version in args . majorver_provides_versions ) :
py_deps [ pymajor_name_ ] . append ( spec )
if args . legacy or args . legacy_provides :
if spec not in py_deps [ legacy_name ] :
py_deps [ legacy_name ] . append ( spec )
py_deps [ legacy_name ] . append ( spec )
if args . requires or ( args . r ecommends and dist . extras ) :
if Requires or ( Recommends and dist . extras ) :
name = ' python(abi) '
name = ' python(abi) '
# If egg/dist metadata says package name is python, we don't add dependency on python(abi)
# If egg/dist metadata says package name is python, we don't add dependency on python(abi)
if dist . normalized_name == ' python ' :
if dist . key == ' python ' :
py_abi = False
py_abi = False
if name in py_deps :
if name in py_deps :
py_deps . pop ( name )
py_deps . pop ( name )
@ -448,99 +182,75 @@ if __name__ == "__main__":
spec = ( ' == ' , dist . py_version )
spec = ( ' == ' , dist . py_version )
if spec not in py_deps [ name ] :
if spec not in py_deps [ name ] :
py_deps [ name ] . append ( spec )
py_deps [ name ] . append ( spec )
deps = dist . requires ( )
if extras_subpackage :
if Recommends :
deps = [ d for d in dist . requirements_for_extra ( extras_subpackage ) ]
depsextras = dist . requires ( extras = dist . extras )
else :
if not Requires :
deps = dist . requirements
for dep in reversed ( depsextras ) :
if dep in deps :
# console_scripts/gui_scripts entry points needed pkg_resources from setuptools
depsextras . remove ( dep )
# on new Python/setuptools versions, this is no longer required
deps = depsextras
if nodep_setuptools_pyversion is None or parse ( dist . py_version ) < nodep_setuptools_pyversion :
if ( dist . entry_points and
( lower . endswith ( ' .egg ' ) or
lower . endswith ( ' .egg-info ' ) ) ) :
groups = { ep . group for ep in dist . entry_points }
if { " console_scripts " , " gui_scripts " } & groups :
# stick them first so any more specific requirement
# overrides it
deps . insert ( 0 , Requirement ( ' setuptools ' ) )
# add requires/recommends based on egg/dist metadata
# add requires/recommends based on egg/dist metadata
for dep in deps :
for dep in deps :
# Even if we're requiring `foo[bar]`, also require `foo`
if legacy :
# to be safe, and to make it discoverable through
name = ' pythonegg( {} )( {} ) ' . format ( pyver_major , dep . key )
# `repoquery --whatrequires`
extras_suffixes = [ " " ]
if args . require_extras_subpackages and dep . extras :
# A dependency can have more than one extras,
# i.e. foo[bar,baz], so let's go through all of them
extras_suffixes + = [ f " [ { e . lower ( ) } ] " for e in dep . extras ]
for extras_suffix in extras_suffixes :
if normalized_names_require_pep503 :
dep_normalized_name = dep . normalized_name
else :
dep_normalized_name = dep . legacy_normalized_name
if args . legacy :
name = ' pythonegg( {} )( {} ) ' . format ( pyver_major , dep . legacy_normalized_name )
else :
else :
if args . majorver_only :
if PyMajorVer_Deps :
name = ' python {} dist( {} {} ) ' . format ( pyver_major , dep _normalized_name, extras_suffix )
name = ' python {} dist( {} ) ' . format ( pyver_major , dep . key )
else :
else :
name = ' python {} dist( {} {} ) ' . format ( dist . py_version , dep_normalized_name , extras_suffix )
name = ' python {} dist( {} ) ' . format ( dist . py_version , dep . key )
for spec in dep . specs :
if dep . marker and not args . recommends and not extras_subpackage :
if spec [ 0 ] != ' != ' :
if not dep . marker . evaluate ( get_marker_env ( dist , ' ' ) ) :
continue
if name not in py_deps :
if name not in py_deps :
py_deps [ name ] = [ ]
py_deps [ name ] = [ ]
for spec in dep . specifier :
if spec not in py_deps [ name ] :
if ( spec . operator , spec . version ) not in py_deps [ name ] :
py_deps [ name ] . append ( spec )
py_deps [ name ] . append ( ( spec . operator , spec . version ) )
if not dep . specs :
py_deps [ name ] = [ ]
# Unused, for automatic sub-package generation based on 'extras' from egg/dist metadata
# Unused, for automatic sub-package generation based on 'extras' from egg/dist metadata
# TODO: implement in rpm later, or...?
# TODO: implement in rpm later, or...?
if args . extras :
if Extras :
print ( dist . extras )
deps = dist . requires ( )
for extra in dist . extras :
extras = dist . extras
print ( extras )
for extra in extras :
print ( ' %% package \t extras- {} ' . format ( extra ) )
print ( ' %% package \t extras- {} ' . format ( extra ) )
print ( ' Summary: \t {} extra for {} python package ' . format ( extra , dist . legacy_normalized_name ) )
print ( ' Summary: \t {} extra for {} python package ' . format ( extra , dist . key ) )
print ( ' Group: \t \t Development/Python ' )
print ( ' Group: \t \t Development/Python ' )
for dep in dist . requirements_for_extra ( extra ) :
depsextras = dist . requires ( extras = [ extra ] )
for spec in dep . specifier :
for dep in reversed ( depsextras ) :
if spec . operator == ' != ' :
if dep in deps :
print ( ' Conflicts: \t {} {} {} ' . format ( dep . legacy_normalized_name , ' == ' , spec . version ) )
depsextras . remove ( dep )
deps = depsextras
for dep in deps :
for spec in dep . specs :
if spec [ 0 ] == ' != ' :
print ( ' Conflicts: \t {} {} {} ' . format ( dep . key , ' == ' , spec [ 1 ] ) )
else :
else :
print ( ' Requires: \t {} {} {} ' . format ( dep . legacy_normalized_name , spec . operator , spec . version ) )
print ( ' Requires: \t {} {} {} ' . format ( dep . key, spec [ 0 ] , spec [ 1 ] ) )
print ( ' %% description \t {} ' . format ( extra ) )
print ( ' %% description \t {} ' . format ( extra ) )
print ( ' {} extra for {} python package ' . format ( extra , dist . legacy_normalized_name ) )
print ( ' {} extra for {} python package ' . format ( extra , dist . key ) )
print ( ' %% files \t \t extras- {} \n ' . format ( extra ) )
print ( ' %% files \t \t extras- {} \n ' . format ( extra ) )
if args . c onflicts:
if C :
# Should we really add conflicts for extras?
# Should we really add conflicts for extras?
# Creating a meta package per extra with recommends on, which has
# Creating a meta package per extra with recommends on, which has
# the requires/conflicts in stead might be a better solution...
# the requires/conflicts in stead might be a better solution...
for dep in dist . requirements :
for dep in dist . requires ( extras = dist . extras ) :
for spec in dep . specifier :
name = dep . key
if spec . operator == ' != ' :
for spec in dep . specs :
if dep . legacy_normalized_name not in py_deps :
if spec [ 0 ] == ' != ' :
py_deps [ dep . legacy_normalized_name ] = [ ]
if name not in py_deps :
spec = ( ' == ' , spec . version )
py_deps [ name ] = [ ]
if spec not in py_deps [ dep . legacy_normalized_name ] :
spec = ( ' == ' , spec [ 1 ] )
py_deps [ dep . legacy_normalized_name ] . append ( spec )
if spec not in py_deps [ name ] :
py_deps [ name ] . append ( spec )
for name in sorted ( py_deps ) :
names = list ( py_deps . keys ( ) )
names . sort ( )
for name in names :
if py_deps [ name ] :
if py_deps [ name ] :
# Print out versioned provides, requires, recommends, conflicts
# Print out versioned provides, requires, recommends, conflicts
spec_list = [ ]
for spec in py_deps [ name ] :
for spec in py_deps [ name ] :
spec_list . append ( convert ( name , spec [ 0 ] , spec [ 1 ] ) )
print ( ' {} {} {} ' . format ( name , spec [ 0 ] , spec [ 1 ] ) )
if len ( spec_list ) == 1 :
print ( spec_list [ 0 ] )
else :
# Sort spec_list so that the results can be tested easily
print ( ' ( {} ) ' . format ( ' with ' . join ( sorted ( spec_list ) ) ) )
else :
else :
# Print out unversioned provides, requires, recommends, conflicts
# Print out unversioned provides, requires, recommends, conflicts
print ( name )
print ( name )
