From ca157761005846ac67e896acd57a9e7e91950313 Mon Sep 17 00:00:00 2001 From: Krzesimir Nowak Date: Tue, 14 Sep 2021 12:25:24 +0200 Subject: [PATCH] eclass/python-single-r1: Sync with gentoo It's from gentoo commit 1aefe31e9b1d54ce085b18455e8cbf60fc39abd0. --- .../eclass/python-single-r1.eclass | 360 ++++++++---------- 1 file changed, 159 insertions(+), 201 deletions(-) diff --git a/sdk_container/src/third_party/portage-stable/eclass/python-single-r1.eclass b/sdk_container/src/third_party/portage-stable/eclass/python-single-r1.eclass index 8ac17b7815..228c66a77a 100644 --- a/sdk_container/src/third_party/portage-stable/eclass/python-single-r1.eclass +++ b/sdk_container/src/third_party/portage-stable/eclass/python-single-r1.eclass @@ -1,4 +1,4 @@ -# Copyright 1999-2018 Gentoo Foundation +# Copyright 1999-2021 Gentoo Authors # Distributed under the terms of the GNU General Public License v2 # @ECLASS: python-single-r1.eclass @@ -7,17 +7,23 @@ # @AUTHOR: # Author: Michał Górny # Based on work of: Krzysztof Pawlik -# @SUPPORTED_EAPIS: 5 6 7 +# @SUPPORTED_EAPIS: 6 7 8 +# @PROVIDES: python-utils-r1 # @BLURB: An eclass for Python packages not installed for multiple implementations. # @DESCRIPTION: # An extension of the python-r1 eclass suite for packages which # don't support being installed for multiple Python implementations. -# This mostly includes tools embedding Python. +# This mostly includes tools embedding Python and packages using foreign +# build systems. # -# This eclass extends the IUSE and REQUIRED_USE set by python-r1 -# to request the PYTHON_SINGLE_TARGET when the inheriting ebuild -# can be supported by more than one Python implementation. It also -# replaces PYTHON_USEDEP and PYTHON_DEPS with a more suitable form. +# This eclass sets correct IUSE. It also provides PYTHON_DEPS +# and PYTHON_REQUIRED_USE that need to be added to appropriate ebuild +# metadata variables. +# +# The eclass exports PYTHON_SINGLE_USEDEP that is suitable for depending +# on other packages using the eclass. Dependencies on packages using +# python-r1 should be created via python_gen_cond_dep() function, +# using PYTHON_USEDEP placeholder. # # Please note that packages support multiple Python implementations # (using python-r1 eclass) can not depend on packages not supporting @@ -28,15 +34,14 @@ # in the packages using python-single-r1, and there is no need ever # to inherit both. # -# For more information, please see the wiki: -# https://wiki.gentoo.org/wiki/Project:Python/python-single-r1 +# For more information, please see the Python Guide: +# https://dev.gentoo.org/~mgorny/python-guide/ case "${EAPI:-0}" in - 0|1|2|3|4) + [0-5]) die "Unsupported EAPI=${EAPI:-0} (too old) for ${ECLASS}" ;; - 5|6|7) - # EAPI=5 is required for sane USE_EXPAND dependencies + [6-8]) ;; *) die "Unsupported EAPI=${EAPI} (unknown) for ${ECLASS}" @@ -75,7 +80,8 @@ EXPORT_FUNCTIONS pkg_setup # @CODE # @ECLASS-VARIABLE: PYTHON_COMPAT_OVERRIDE -# @INTERNAL +# @USER_VARIABLE +# @DEFAULT_UNSET # @DESCRIPTION: # This variable can be used when working with ebuilds to override # the in-ebuild PYTHON_COMPAT. It is a string naming the implementation @@ -84,9 +90,9 @@ EXPORT_FUNCTIONS pkg_setup # # It should be noted that in order to preserve metadata immutability, # PYTHON_COMPAT_OVERRIDE does not affect IUSE nor dependencies. -# The state of PYTHON_TARGETS and PYTHON_SINGLE_TARGET is ignored, -# and the implementation in PYTHON_COMPAT_OVERRIDE is built instead. -# Dependencies need to be satisfied manually. +# The state of PYTHON_SINGLE_TARGET is ignored, and the implementation +# in PYTHON_COMPAT_OVERRIDE is built instead. Dependencies need to be +# satisfied manually. # # Example: # @CODE @@ -114,6 +120,7 @@ EXPORT_FUNCTIONS pkg_setup # @CODE # @ECLASS-VARIABLE: PYTHON_DEPS +# @OUTPUT_VARIABLE # @DESCRIPTION: # This is an eclass-generated Python dependency string for all # implementations listed in PYTHON_COMPAT. @@ -124,42 +131,60 @@ EXPORT_FUNCTIONS pkg_setup # @CODE # RDEPEND="${PYTHON_DEPS} # dev-foo/mydep" -# DEPEND="${RDEPEND}" +# BDEPEND="${PYTHON_DEPS}" # @CODE # # Example value: # @CODE # dev-lang/python-exec:= # python_single_target_python2_7? ( dev-lang/python:2.7[gdbm] ) -# python_single_target_pypy? ( virtual/pypy[gdbm] ) +# python_single_target_pypy? ( dev-python/pypy[gdbm] ) # @CODE -# @ECLASS-VARIABLE: PYTHON_USEDEP +# @ECLASS-VARIABLE: PYTHON_SINGLE_USEDEP +# @OUTPUT_VARIABLE # @DESCRIPTION: # This is an eclass-generated USE-dependency string which can be used to -# depend on another Python package being built for the same Python -# implementations. +# depend on another python-single-r1 package being built for the same +# Python implementations. # -# The generate USE-flag list is compatible with packages using python-r1, -# python-single-r1 and python-distutils-ng eclasses. It must not be used -# on packages using python.eclass. +# If you need to depend on a multi-impl (python-r1) package, use +# python_gen_cond_dep with PYTHON_USEDEP placeholder instead. # # Example use: # @CODE -# RDEPEND="dev-python/foo[${PYTHON_USEDEP}]" +# RDEPEND="dev-python/foo[${PYTHON_SINGLE_USEDEP}]" # @CODE # # Example value: # @CODE -# python_targets_python2_7(-)?,python_single_target_python3_4(+)? +# python_single_target_python3_4(-)? +# @CODE + +# @ECLASS-VARIABLE: PYTHON_USEDEP +# @OUTPUT_VARIABLE +# @DESCRIPTION: +# This is a placeholder variable supported by python_gen_cond_dep, +# in order to depend on python-r1 packages built for the same Python +# implementations. +# +# Example use: +# @CODE +# RDEPEND="$(python_gen_cond_dep ' +# dev-python/foo[${PYTHON_USEDEP}] +# ')" +# @CODE +# +# Example value: +# @CODE +# python_targets_python3_4(-) # @CODE # @ECLASS-VARIABLE: PYTHON_REQUIRED_USE +# @OUTPUT_VARIABLE # @DESCRIPTION: -# This is an eclass-generated required-use expression which ensures the following -# when more than one python implementation is possible: -# 1. Exactly one PYTHON_SINGLE_TARGET value has been enabled. -# 2. The selected PYTHON_SINGLE_TARGET value is enabled in PYTHON_TARGETS. +# This is an eclass-generated required-use expression which ensures +# that exactly one PYTHON_SINGLE_TARGET value has been enabled. # # This expression should be utilized in an ebuild by including it in # REQUIRED_USE, optionally behind a use flag. @@ -171,65 +196,38 @@ EXPORT_FUNCTIONS pkg_setup # # Example value: # @CODE -# python_single_target_python2_7? ( python_targets_python2_7 ) -# python_single_target_python3_3? ( python_targets_python3_3 ) # ^^ ( python_single_target_python2_7 python_single_target_python3_3 ) # @CODE _python_single_set_globals() { _python_set_impls - local i PYTHON_PKG_DEP - - local flags_mt=( "${_PYTHON_SUPPORTED_IMPLS[@]/#/python_targets_}" ) local flags=( "${_PYTHON_SUPPORTED_IMPLS[@]/#/python_single_target_}" ) - local unflags=( "${_PYTHON_UNSUPPORTED_IMPLS[@]/#/-python_single_target_}" ) - local optflags=${flags_mt[@]/%/(-)?},${unflags[@]/%/(-)} - - IUSE="${flags_mt[*]}" - - local deps requse usedep if [[ ${#_PYTHON_SUPPORTED_IMPLS[@]} -eq 1 ]]; then - # There is only one supported implementation; set IUSE and other - # variables without PYTHON_SINGLE_TARGET. - requse=${flags_mt[*]} - python_export "${_PYTHON_SUPPORTED_IMPLS[0]}" PYTHON_PKG_DEP - deps="${flags_mt[*]}? ( ${PYTHON_PKG_DEP} ) " - # Force on the python_single_target_* flag for this impl, so - # that any dependencies that inherit python-single-r1 and - # happen to have multiple implementations will still need - # to bound by the implementation used by this package. - optflags+=,${flags[0]/%/(+)} + # if only one implementation is supported, use IUSE defaults + # to avoid requesting the user to enable it + IUSE="+${flags[0]}" else - # Multiple supported implementations; honor PYTHON_SINGLE_TARGET. - IUSE+=" ${flags[*]}" - requse="^^ ( ${flags[*]} )" - # Ensure deps honor the same python_single_target_* flag as is set - # on this package. - optflags+=,${flags[@]/%/(+)?} - - for i in "${_PYTHON_SUPPORTED_IMPLS[@]}"; do - # The chosen targets need to be in PYTHON_TARGETS as well. - # This is in order to enforce correct dependencies on packages - # supporting multiple implementations. - requse+=" python_single_target_${i}? ( python_targets_${i} )" - - python_export "${i}" PYTHON_PKG_DEP - deps+="python_single_target_${i}? ( ${PYTHON_PKG_DEP} ) " - done + IUSE="${flags[*]}" fi - usedep=${optflags// /,} - # 1) well, python-exec would suffice as an RDEP - # but no point in making this overcomplex, BDEP doesn't hurt anyone - # 2) python-exec should be built with all targets forced anyway - # but if new targets were added, we may need to force a rebuild - if [[ ${_PYTHON_WANT_PYTHON_EXEC2} == 0 ]]; then - die "python-exec:0 is no longer supported, please fix your ebuild to work with python-exec:2" - else - deps+=">=dev-lang/python-exec-2:=[${usedep}]" - fi + local requse="^^ ( ${flags[*]} )" + local single_flags="${flags[@]/%/(-)?}" + local single_usedep=${single_flags// /,} + + local deps= i PYTHON_PKG_DEP + for i in "${_PYTHON_SUPPORTED_IMPLS[@]}"; do + _python_export "${i}" PYTHON_PKG_DEP + # 1) well, python-exec would suffice as an RDEP + # but no point in making this overcomplex, BDEP doesn't hurt anyone + # 2) python-exec should be built with all targets forced anyway + # but if new targets were added, we may need to force a rebuild + deps+="python_single_target_${i}? ( + ${PYTHON_PKG_DEP} + >=dev-lang/python-exec-2:=[python_targets_${i}] + ) " + done if [[ ${PYTHON_DEPS+1} ]]; then if [[ ${PYTHON_DEPS} != "${deps}" ]]; then @@ -247,17 +245,19 @@ _python_single_set_globals() { die "PYTHON_REQUIRED_USE integrity check failed" fi - if [[ ${PYTHON_USEDEP} != "${usedep}" ]]; then - eerror "PYTHON_USEDEP have changed between inherits!" - eerror "Before: ${PYTHON_USEDEP}" - eerror "Now : ${usedep}" - die "PYTHON_USEDEP integrity check failed" + if [[ ${PYTHON_SINGLE_USEDEP} != "${single_usedep}" ]]; then + eerror "PYTHON_SINGLE_USEDEP have changed between inherits!" + eerror "Before: ${PYTHON_SINGLE_USEDEP}" + eerror "Now : ${single_usedep}" + die "PYTHON_SINGLE_USEDEP integrity check failed" fi else PYTHON_DEPS=${deps} PYTHON_REQUIRED_USE=${requse} - PYTHON_USEDEP=${usedep} - readonly PYTHON_DEPS PYTHON_REQUIRED_USE PYTHON_USEDEP + PYTHON_USEDEP='%PYTHON_USEDEP-NEEDS-TO-BE-USED-IN-PYTHON_GEN_COND_DEP%' + PYTHON_SINGLE_USEDEP=${single_usedep} + readonly PYTHON_DEPS PYTHON_REQUIRED_USE PYTHON_SINGLE_USEDEP \ + PYTHON_USEDEP fi } _python_single_set_globals @@ -265,43 +265,30 @@ unset -f _python_single_set_globals if [[ ! ${_PYTHON_SINGLE_R1} ]]; then -# @FUNCTION: python_gen_usedep -# @USAGE: [...] +# @FUNCTION: _python_gen_usedep +# @USAGE: [...] +# @INTERNAL # @DESCRIPTION: # Output a USE dependency string for Python implementations which # are both in PYTHON_COMPAT and match any of the patterns passed # as parameters to the function. # -# The patterns can be either fnmatch-style patterns (matched via bash -# == operator against PYTHON_COMPAT values) or '-2' / '-3' to indicate -# appropriately all enabled Python 2/3 implementations (alike -# python_is_python3). Remember to escape or quote the fnmatch patterns -# to prevent accidental shell filename expansion. +# The patterns are fnmatch-style patterns (matched via bash +# == operator against PYTHON_COMPAT values). Remember to escape +# or quote the fnmatch patterns to prevent accidental shell filename +# expansion. # -# When all implementations are requested, please use ${PYTHON_USEDEP} -# instead. Please also remember to set an appropriate REQUIRED_USE -# to avoid ineffective USE flags. -# -# Example: -# @CODE -# PYTHON_COMPAT=( python{2_7,3_4} ) -# DEPEND="doc? ( dev-python/epydoc[$(python_gen_usedep 'python2*')] )" -# @CODE -# -# It will cause the dependency to look like: -# @CODE -# DEPEND="doc? ( dev-python/epydoc[python_targets_python2_7(-)?,...] )" -# @CODE -python_gen_usedep() { +# This is an internal function used to implement python_gen_cond_dep. +_python_gen_usedep() { debug-print-function ${FUNCNAME} "${@}" local impl matches=() + _python_verify_patterns "${@}" for impl in "${_PYTHON_SUPPORTED_IMPLS[@]}"; do if _python_impl_matches "${impl}" "${@}"; then matches+=( - "python_targets_${impl}(-)?" - "python_single_target_${impl}(+)?" + "python_single_target_${impl}(-)?" ) fi done @@ -313,17 +300,16 @@ python_gen_usedep() { } # @FUNCTION: python_gen_useflags -# @USAGE: [...] +# @USAGE: [...] # @DESCRIPTION: # Output a list of USE flags for Python implementations which # are both in PYTHON_COMPAT and match any of the patterns passed # as parameters to the function. # -# The patterns can be either fnmatch-style patterns (matched via bash -# == operator against PYTHON_COMPAT values) or '-2' / '-3' to indicate -# appropriately all enabled Python 2/3 implementations (alike -# python_is_python3). Remember to escape or quote the fnmatch patterns -# to prevent accidental shell filename expansion. +# The patterns are fnmatch-style patterns (matched via bash +# == operator against PYTHON_COMPAT values). Remember to escape +# or quote the fnmatch patterns to prevent accidental shell filename +# expansion. # # Example: # @CODE @@ -338,17 +324,12 @@ python_gen_usedep() { python_gen_useflags() { debug-print-function ${FUNCNAME} "${@}" - local flag_prefix impl matches=() - - if [[ ${#_PYTHON_SUPPORTED_IMPLS[@]} -eq 1 ]]; then - flag_prefix=python_targets - else - flag_prefix=python_single_target - fi + local impl matches=() + _python_verify_patterns "${@}" for impl in "${_PYTHON_SUPPORTED_IMPLS[@]}"; do if _python_impl_matches "${impl}" "${@}"; then - matches+=( "${flag_prefix}_${impl}" ) + matches+=( "python_single_target_${impl}" ) fi done @@ -356,22 +337,21 @@ python_gen_useflags() { } # @FUNCTION: python_gen_cond_dep -# @USAGE: [...] +# @USAGE: [...] # @DESCRIPTION: # Output a list of -ies made conditional to USE flags # of Python implementations which are both in PYTHON_COMPAT and match # any of the patterns passed as the remaining parameters. # -# The patterns can be either fnmatch-style patterns (matched via bash -# == operator against PYTHON_COMPAT values) or '-2' / '-3' to indicate -# appropriately all enabled Python 2/3 implementations (alike -# python_is_python3). Remember to escape or quote the fnmatch patterns -# to prevent accidental shell filename expansion. +# The patterns are fnmatch-style patterns (matched via bash +# == operator against PYTHON_COMPAT values). Remember to escape +# or quote the fnmatch patterns to prevent accidental shell filename +# expansion. # # In order to enforce USE constraints on the packages, verbatim -# '${PYTHON_USEDEP}' (quoted!) may be placed in the dependency -# specification. It will get expanded within the function into a proper -# USE dependency string. +# '${PYTHON_SINGLE_USEDEP}' and '${PYTHON_USEDEP}' (quoted!) may +# be placed in the dependency specification. It will get expanded within +# the function into a proper USE dependency string. # # Example: # @CODE @@ -390,28 +370,32 @@ python_gen_useflags() { python_gen_cond_dep() { debug-print-function ${FUNCNAME} "${@}" - local flag_prefix impl matches=() - - if [[ ${#_PYTHON_SUPPORTED_IMPLS[@]} -eq 1 ]]; then - flag_prefix=python_targets - else - flag_prefix=python_single_target - fi + local impl matches=() local dep=${1} shift + _python_verify_patterns "${@}" for impl in "${_PYTHON_SUPPORTED_IMPLS[@]}"; do if _python_impl_matches "${impl}" "${@}"; then - # substitute ${PYTHON_USEDEP} if used - # (since python_gen_usedep() will not return ${PYTHON_USEDEP} - # the code is run at most once) - if [[ ${dep} == *'${PYTHON_USEDEP}'* ]]; then - local usedep=$(python_gen_usedep "${@}") - dep=${dep//\$\{PYTHON_USEDEP\}/${usedep}} + # substitute ${PYTHON_SINGLE_USEDEP} if used + # (since python_gen_usedep() will not return + # ${PYTHON_SINGLE_USEDEP}, the code is run at most once) + if [[ ${dep} == *'${PYTHON_SINGLE_USEDEP}'* ]]; then + local usedep=$(_python_gen_usedep "${@}") + dep=${dep//\$\{PYTHON_SINGLE_USEDEP\}/${usedep}} + fi + local multi_usedep="python_targets_${impl}(-)" + + if [[ ${EAPI} != [67] ]]; then + if [[ ${dep} == *\$\{PYTHON_MULTI_USEDEP\}* ]]; then + die "Replace PYTHON_MULTI_USEDEP with PYTHON_USEDEP in EAPI ${EAPI}" + fi fi - matches+=( "${flag_prefix}_${impl}? ( ${dep} )" ) + local subdep=${dep//\$\{PYTHON_MULTI_USEDEP\}/${multi_usedep}} + matches+=( "python_single_target_${impl}? ( + ${subdep//\$\{PYTHON_USEDEP\}/${multi_usedep}} )" ) fi done @@ -427,11 +411,10 @@ python_gen_cond_dep() { # patterns are passed, the output dependencies will be generated only # for the implementations matching them. # -# The patterns can be either fnmatch-style patterns (matched via bash -# == operator against PYTHON_COMPAT values) or '-2' / '-3' to indicate -# appropriately all enabled Python 2/3 implementations (alike -# python_is_python3). Remember to escape or quote the fnmatch patterns -# to prevent accidental shell filename expansion. +# The patterns are fnmatch-style patterns (matched via bash +# == operator against PYTHON_COMPAT values). Remember to escape +# or quote the fnmatch patterns to prevent accidental shell filename +# expansion. # # Use this function when you need to request different USE flags # on the Python interpreter depending on package's USE flags. If you @@ -455,24 +438,18 @@ python_gen_cond_dep() { python_gen_impl_dep() { debug-print-function ${FUNCNAME} "${@}" - local impl pattern + local impl local matches=() - if [[ ${#_PYTHON_SUPPORTED_IMPLS[@]} -eq 1 ]]; then - flag_prefix=python_targets - else - flag_prefix=python_single_target - fi - local PYTHON_REQ_USE=${1} shift - local patterns=( "${@-*}" ) + _python_verify_patterns "${@}" for impl in "${_PYTHON_SUPPORTED_IMPLS[@]}"; do - if _python_impl_matches "${impl}" "${patterns[@]}"; then + if _python_impl_matches "${impl}" "${@}"; then local PYTHON_PKG_DEP - python_export "${impl}" PYTHON_PKG_DEP - matches+=( "${flag_prefix}_${impl}? ( ${PYTHON_PKG_DEP} )" ) + _python_export "${impl}" PYTHON_PKG_DEP + matches+=( "python_single_target_${impl}? ( ${PYTHON_PKG_DEP} )" ) fi done @@ -500,57 +477,38 @@ python_setup() { ewarn ewarn "Dependencies won't be satisfied, and PYTHON_SINGLE_TARGET flags will be ignored." - python_export "${impls[0]}" EPYTHON PYTHON - python_wrapper_setup + _python_export "${impls[0]}" EPYTHON PYTHON + _python_wrapper_setup + einfo "Using ${EPYTHON} to build" return fi - if [[ ${#_PYTHON_SUPPORTED_IMPLS[@]} -eq 1 ]]; then - if use "python_targets_${_PYTHON_SUPPORTED_IMPLS[0]}"; then - # Only one supported implementation, enable it explicitly - python_export "${_PYTHON_SUPPORTED_IMPLS[0]}" EPYTHON PYTHON - python_wrapper_setup - fi - else - local impl - for impl in "${_PYTHON_SUPPORTED_IMPLS[@]}"; do - if use "python_single_target_${impl}"; then - if [[ ${EPYTHON} ]]; then - eerror "Your PYTHON_SINGLE_TARGET setting lists more than a single Python" - eerror "implementation. Please set it to just one value. If you need" - eerror "to override the value for a single package, please use package.env" - eerror "or an equivalent solution (man 5 portage)." - echo - die "More than one implementation in PYTHON_SINGLE_TARGET." - fi - - if ! use "python_targets_${impl}"; then - eerror "The implementation chosen as PYTHON_SINGLE_TARGET must be added" - eerror "to PYTHON_TARGETS as well. This is in order to ensure that" - eerror "dependencies are satisfied correctly. We're sorry" - eerror "for the inconvenience." - echo - die "Build target (${impl}) not in PYTHON_TARGETS." - fi - - python_export "${impl}" EPYTHON PYTHON - python_wrapper_setup + local impl + for impl in "${_PYTHON_SUPPORTED_IMPLS[@]}"; do + if use "python_single_target_${impl}"; then + if [[ ${EPYTHON} ]]; then + eerror "Your PYTHON_SINGLE_TARGET setting lists more than a single Python" + eerror "implementation. Please set it to just one value. If you need" + eerror "to override the value for a single package, please use package.env" + eerror "or an equivalent solution (man 5 portage)." + echo + die "More than one implementation in PYTHON_SINGLE_TARGET." fi - done - fi + + _python_export "${impl}" EPYTHON PYTHON + _python_wrapper_setup + einfo "Using ${EPYTHON} to build" + fi + done if [[ ! ${EPYTHON} ]]; then eerror "No Python implementation selected for the build. Please set" - if [[ ${#_PYTHON_SUPPORTED_IMPLS[@]} -eq 1 ]]; then - eerror "the PYTHON_TARGETS variable in your make.conf to include one" - else - eerror "the PYTHON_SINGLE_TARGET variable in your make.conf to one" - fi + eerror "the PYTHON_SINGLE_TARGET variable in your make.conf to one" eerror "of the following values:" eerror eerror "${_PYTHON_SUPPORTED_IMPLS[@]}" echo - die "No supported Python implementation in PYTHON_SINGLE_TARGET/PYTHON_TARGETS." + die "No supported Python implementation in PYTHON_SINGLE_TARGET." fi }