/[gentoo-x86]/eclass/python.eclass

Diff of /eclass/python.eclass

Parent Directory | Revision Log | View Patch Patch

Revision 1.84		Revision 1.135
1	# Copyright 1999-2010 Gentoo Foundation	1	# Copyright 1999-2011 Gentoo Foundation
2	# Distributed under the terms of the GNU General Public License v2	2	# Distributed under the terms of the GNU General Public License v2
3	# $Header: /var/cvsroot/gentoo-x86/eclass/python.eclass,v 1.84 2010/01/11 16:07:23 arfrever Exp $	3	# $Header: /var/cvsroot/gentoo-x86/eclass/python.eclass,v 1.135 2011/10/07 10:52:31 djc Exp $
4		4
5	# @ECLASS: python.eclass	5	# @ECLASS: python.eclass
6	# @MAINTAINER:	6	# @MAINTAINER:
7	# python@gentoo.org	7	# Gentoo Python Project <python@gentoo.org>
8	# @BLURB: A utility eclass that should be inherited by anything that deals with Python or Python modules.	8	# @BLURB: Eclass for Python packages
9	# @DESCRIPTION:	9	# @DESCRIPTION:
10	# Some useful functions for dealing with Python.	10	# The python eclass contains miscellaneous, useful functions for Python packages.
11		11
12	inherit multilib	12	inherit multilib
13		13
14	if ! has "${EAPI:-0}" 0 1 2; then	14	if ! has "${EAPI:-0}" 0 1 2 3; then
15	die "API of python.eclass in EAPI=\"${EAPI}\" not established"	15	die "API of python.eclass in EAPI=\"${EAPI}\" not established"
16	fi	16	fi
17		17
18	if [[ -n "${NEED_PYTHON}" ]]; then	18	_CPYTHON2_GLOBALLY_SUPPORTED_ABIS=(2.4 2.5 2.6 2.7)
19	PYTHON_ATOM=">=dev-lang/python-${NEED_PYTHON}"	19	_CPYTHON3_GLOBALLY_SUPPORTED_ABIS=(3.1 3.2)
20	DEPEND="${PYTHON_ATOM}"	20	_JYTHON_GLOBALLY_SUPPORTED_ABIS=(2.5-jython)
21	RDEPEND="${DEPEND}"	21	_PYPY_GLOBALLY_SUPPORTED_ABIS=(2.7-pypy-1.5)
22	else	22	_PYTHON_GLOBALLY_SUPPORTED_ABIS=(${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]} ${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]} ${_JYTHON_GLOBALLY_SUPPORTED_ABIS[@]} ${_PYPY_GLOBALLY_SUPPORTED_ABIS[@]})
23	PYTHON_ATOM="dev-lang/python"
24	fi
25		23
26	DEPEND+=" >=app-admin/eselect-python-20090804"	24	# ================================================================================================
		25	# ===================================== HANDLING OF METADATA =====================================
		26	# ================================================================================================
27		27
28	__python_eclass_test() {	28	_PYTHON_ABI_PATTERN_REGEX="([[:alnum:]]\|\.\|-\|\*\|\[\|\])+"
29	__python_version_extract 2.3
30	echo -n "2.3 -> PYVER: $PYVER PYVER_MAJOR: $PYVER_MAJOR"
31	echo " PYVER_MINOR: $PYVER_MINOR PYVER_MICRO: $PYVER_MICRO"
32	__python_version_extract 2.3.4
33	echo -n "2.3.4 -> PYVER: $PYVER PYVER_MAJOR: $PYVER_MAJOR"
34	echo " PYVER_MINOR: $PYVER_MINOR PYVER_MICRO: $PYVER_MICRO"
35	__python_version_extract 2.3.5
36	echo -n "2.3.5 -> PYVER: $PYVER PYVER_MAJOR: $PYVER_MAJOR"
37	echo " PYVER_MINOR: $PYVER_MINOR PYVER_MICRO: $PYVER_MICRO"
38	__python_version_extract 2.4
39	echo -n "2.4 -> PYVER: $PYVER PYVER_MAJOR: $PYVER_MAJOR"
40	echo " PYVER_MINOR: $PYVER_MINOR PYVER_MICRO: $PYVER_MICRO"
41	__python_version_extract 2.5b3
42	echo -n "2.5b3 -> PYVER: $PYVER PYVER_MAJOR: $PYVER_MAJOR"
43	echo " PYVER_MINOR: $PYVER_MINOR PYVER_MICRO: $PYVER_MICRO"
44	}
45		29
46	# @FUNCTION: python_version	30	_python_check_python_abi_matching() {
47	# @DESCRIPTION:	31	local pattern patterns patterns_list="0" PYTHON_ABI
48	# Run without arguments and it will export the version of python
49	# currently in use as $PYVER; sets PYVER/PYVER_MAJOR/PYVER_MINOR
50	__python_version_extract() {
51	local verstr=$1
52	export PYVER_MAJOR=${verstr:0:1}
53	export PYVER_MINOR=${verstr:2:1}
54	if [[ ${verstr:3:1} == . ]]; then
55	export PYVER_MICRO=${verstr:4}
56	fi
57	export PYVER="${PYVER_MAJOR}.${PYVER_MINOR}"
58	}
59
60	python_version() {
61	[[ -n "${PYVER}" ]] && return 0
62	local tmpstr
63	python=${python:-/usr/bin/python}
64	tmpstr="$(EPYTHON= ${python} -V 2>&1 )"
65	export PYVER_ALL="${tmpstr#Python }"
66	__python_version_extract $PYVER_ALL
67	}
68
69	# @FUNCTION: PYTHON
70	# @USAGE: [-2] [-3] [--ABI] [-A\|--active] [-a\|--absolute-path] [-f\|--final-ABI] [--] <Python_ABI="${PYTHON_ABI}">
71	# @DESCRIPTION:
72	# Get Python interpreter filename for specified Python ABI. If Python_ABI argument
73	# is ommitted, then PYTHON_ABI environment variable must be set and is used.
74	# If -2 option is specified, then active version of Python 2 is used.
75	# If -3 option is specified, then active version of Python 3 is used.
76	# If --active option is specified, then active version of Python is used.
77	# Active version of Python can be set by python_set_active_version().
78	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
79	# -2, -3, --active and --final-ABI options and Python_ABI argument cannot be specified simultaneously.
80	# If --ABI option is specified, then only specified Python ABI is printed instead of
81	# Python interpreter filename.
82	# --ABI and --absolute-path options cannot be specified simultaneously.
83	PYTHON() {
84	local ABI_output="0" absolute_path_output="0" active="0" final_ABI="0" python2="0" python3="0" slot=
85		32
86	while (($#)); do	33	while (($#)); do
87	case "$1" in	34	case "$1" in
88	-2)	35	--patterns-list)
89	python2="1"	36	patterns_list="1"
90	;;
91	-3)
92	python3="1"
93	;;
94	--ABI)
95	ABI_output="1"
96	;;
97	-A\|--active)
98	active="1"
99	;;
100	-a\|--absolute-path)
101	absolute_path_output="1"
102	;;
103	-f\|--final-ABI)
104	final_ABI="1"
105	;;	37	;;
106	--)	38	--)
		39	shift
107	break	40	break
108	;;	41	;;
109	-*)	42	-*)
110	die "${FUNCNAME}(): Unrecognized option '$1'"	43	die "${FUNCNAME}(): Unrecognized option '$1'"
111	;;	44	;;
…		…
114	;;	47	;;
115	esac	48	esac
116	shift	49	shift
117	done	50	done
118		51
119	if [[ "${ABI_output}" == "1" && "${absolute_path_output}" == "1" ]]; then
120	die "${FUNCNAME}(): '--ABI and '--absolute-path' options cannot be specified simultaneously"
121	fi
122
123	if [[ "$((${python2} + ${python3} + ${active} + ${final_ABI}))" -gt 1 ]]; then
124	die "${FUNCNAME}(): '-2', '-3', '--active' or '--final-ABI' options cannot be specified simultaneously"
125	fi
126
127	if [[ "$#" -eq 0 ]]; then	52	if [[ "$#" -ne 2 ]]; then
		53	die "${FUNCNAME}() requires 2 arguments"
		54	fi
		55
		56	PYTHON_ABI="$1"
		57
128	if [[ "${active}" == "1" ]]; then	58	if [[ "${patterns_list}" == "0" ]]; then
129	if [[ -n "${SUPPORT_PYTHON_ABIS}" ]]; then	59	pattern="$2"
130	die "${FUNCNAME}(): '--active' option cannot be used in ebuilds of packages supporting installation for multiple versions of Python"	60
131	fi	61	if [[ "${pattern}" == *"-cpython" ]]; then
132	slot="$(/usr/bin/python -c 'from sys import version_info; print(".".join([str(x) for x in version_info[:2]]))')"	62	[[ "${PYTHON_ABI}" =~ ^[[:digit:]]+\.[[:digit:]]+$ && "${PYTHON_ABI}" == ${pattern%-cpython} ]]
133	elif [[ "${final_ABI}" == "1" ]]; then	63	elif [[ "${pattern}" == *"-jython" ]]; then
134	validate_PYTHON_ABIS	64	[[ "${PYTHON_ABI}" == ${pattern} ]]
135	slot="${PYTHON_ABIS##* }"
136	elif [[ "${python2}" == "1" ]]; then	65	elif [[ "${pattern}" == "-pypy-" ]]; then
137	slot="$(eselect python show --python2)"	66	[[ "${PYTHON_ABI}" == ${pattern} ]]
138	if [[ -z "${slot}" ]]; then
139	die "${FUNCNAME}(): Active Python 2 interpreter not set"
140	elif [[ "${slot}" != "python2."* ]]; then
141	die "${FUNCNAME}(): Internal error in \`eselect python show --python2\`"
142	fi
143	slot="${slot#python}"
144	elif [[ "${python3}" == "1" ]]; then
145	slot="$(eselect python show --python3)"
146	if [[ -z "${slot}" ]]; then
147	die "${FUNCNAME}(): Active Python 3 interpreter not set"
148	elif [[ "${slot}" != "python3."* ]]; then
149	die "${FUNCNAME}(): Internal error in \`eselect python show --python3\`"
150	fi
151	slot="${slot#python}"
152	elif [[ -n "${PYTHON_ABI}" ]]; then
153	slot="${PYTHON_ABI}"
154	else	67	else
155	die "${FUNCNAME}(): Invalid usage"	68	if [[ "${PYTHON_ABI}" =~ ^[[:digit:]]+\.[[:digit:]]+$ ]]; then
		69	[[ "${PYTHON_ABI}" == ${pattern} ]]
		70	elif [[ "${PYTHON_ABI}" =~ ^[[:digit:]]+\.[[:digit:]]+-jython$ ]]; then
		71	[[ "${PYTHON_ABI%-jython}" == ${pattern} ]]
		72	elif [[ "${PYTHON_ABI}" =~ ^[[:digit:]]+\.[[:digit:]]+-pypy-[[:digit:]]+\.[[:digit:]]+$ ]]; then
		73	[[ "${PYTHON_ABI%-pypy-*}" == ${pattern} ]]
		74	else
		75	die "${FUNCNAME}(): Unrecognized Python ABI '${PYTHON_ABI}'"
156	fi	76	fi
157	elif [[ "$#" -eq 1 ]]; then	77	fi
158	if [[ "${active}" == "1" ]]; then	78	else
159	die "${FUNCNAME}(): '--active' option and Python ABI cannot be specified simultaneously"	79	patterns="${2// /$'\n'}"
		80
		81	while read pattern; do
		82	if _python_check_python_abi_matching "${PYTHON_ABI}" "${pattern}"; then
		83	return 0
160	fi	84	fi
161	if [[ "${final_ABI}" == "1" ]]; then	85	done <<< "${patterns}"
162	die "${FUNCNAME}(): '--final-ABI' option and Python ABI cannot be specified simultaneously"	86
		87	return 1
		88	fi
		89	}
		90
		91	_python_package_supporting_installation_for_multiple_python_abis() {
		92	if has "${EAPI:-0}" 0 1 2 3 4; then
		93	if [[ -n "${SUPPORT_PYTHON_ABIS}" ]]; then
		94	return 0
		95	else
		96	return 1
		97	fi
		98	else
		99	die "${FUNCNAME}(): Support for EAPI=\"${EAPI}\" not implemented"
		100	fi
		101	}
		102
		103	# @ECLASS-VARIABLE: PYTHON_DEPEND
		104	# @DESCRIPTION:
		105	# Specification of dependency on dev-lang/python.
		106	# Syntax:
		107	# PYTHON_DEPEND: [[!]USE_flag? ]<version_components_group>[ version_components_group]
		108	# version_components_group: <major_version[:[minimal_version][:maximal_version]]>
		109	# major_version: <2\|3\|*>
		110	# minimal_version: <minimal_major_version.minimal_minor_version>
		111	# maximal_version: <maximal_major_version.maximal_minor_version>
		112
		113	_python_parse_PYTHON_DEPEND() {
		114	local major_version maximal_version minimal_version python_all="0" python_maximal_version python_minimal_version python_versions=() python2="0" python2_maximal_version python2_minimal_version python3="0" python3_maximal_version python3_minimal_version USE_flag= version_components_group version_components_group_regex version_components_groups
		115
		116	version_components_group_regex="(2\|3\|\*)(:([[:digit:]]+\.[[:digit:]]+)?(:([[:digit:]]+\.[[:digit:]]+)?)?)?"
		117	version_components_groups="${PYTHON_DEPEND}"
		118
		119	if [[ "${version_components_groups}" =~ ^((\!)?[[:alnum:]_-]+\?\ )?${version_components_group_regex}(\ ${version_components_group_regex})?$ ]]; then
		120	if [[ "${version_components_groups}" =~ ^(\!)?[[:alnum:]_-]+\? ]]; then
		121	USE_flag="${version_components_groups%\? *}"
		122	version_components_groups="${version_components_groups#* }"
		123	fi
		124	if [[ "${version_components_groups}" =~ (""." "\|" "\|^2.\ (2\|\)\|^3.\ (3\|\*)) ]]; then
		125	die "Invalid syntax of PYTHON_DEPEND: Incorrectly specified groups of versions"
		126	fi
		127
		128	version_components_groups="${version_components_groups// /$'\n'}"
		129	while read version_components_group; do
		130	major_version="${version_components_group:0:1}"
		131	minimal_version="${version_components_group:2}"
		132	minimal_version="${minimal_version%:*}"
		133	maximal_version="${version_components_group:$((3 + ${#minimal_version}))}"
		134
		135	if [[ "${major_version}" =~ ^(2\|3)$ ]]; then
		136	if [[ -n "${minimal_version}" && "${major_version}" != "${minimal_version:0:1}" ]]; then
		137	die "Invalid syntax of PYTHON_DEPEND: Minimal version '${minimal_version}' not in specified group of versions"
		138	fi
		139	if [[ -n "${maximal_version}" && "${major_version}" != "${maximal_version:0:1}" ]]; then
		140	die "Invalid syntax of PYTHON_DEPEND: Maximal version '${maximal_version}' not in specified group of versions"
		141	fi
163	fi	142	fi
		143
		144	if [[ "${major_version}" == "2" ]]; then
		145	python2="1"
		146	python_versions=("${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}")
		147	python2_minimal_version="${minimal_version}"
		148	python2_maximal_version="${maximal_version}"
		149	elif [[ "${major_version}" == "3" ]]; then
		150	python3="1"
		151	python_versions=("${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}")
		152	python3_minimal_version="${minimal_version}"
		153	python3_maximal_version="${maximal_version}"
		154	else
		155	python_all="1"
		156	python_versions=("${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}" "${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}")
		157	python_minimal_version="${minimal_version}"
		158	python_maximal_version="${maximal_version}"
		159	fi
		160
		161	if [[ -n "${minimal_version}" ]] && ! has "${minimal_version}" "${python_versions[@]}"; then
		162	die "Invalid syntax of PYTHON_DEPEND: Unrecognized minimal version '${minimal_version}'"
		163	fi
		164	if [[ -n "${maximal_version}" ]] && ! has "${maximal_version}" "${python_versions[@]}"; then
		165	die "Invalid syntax of PYTHON_DEPEND: Unrecognized maximal version '${maximal_version}'"
		166	fi
		167
		168	if [[ -n "${minimal_version}" && -n "${maximal_version}" && "${minimal_version}" > "${maximal_version}" ]]; then
		169	die "Invalid syntax of PYTHON_DEPEND: Minimal version '${minimal_version}' greater than maximal version '${maximal_version}'"
		170	fi
		171	done <<< "${version_components_groups}"
		172
		173	_PYTHON_ATOMS=()
		174
		175	_append_accepted_versions_range() {
		176	local accepted_version="0" i
		177	for ((i = "${#python_versions[@]}"; i >= 0; i--)); do
		178	if [[ "${python_versions[${i}]}" == "${python_maximal_version}" ]]; then
		179	accepted_version="1"
		180	fi
		181	if [[ "${accepted_version}" == "1" ]]; then
		182	_PYTHON_ATOMS+=("=dev-lang/python-${python_versions[${i}]}*")
		183	fi
		184	if [[ "${python_versions[${i}]}" == "${python_minimal_version}" ]]; then
		185	accepted_version="0"
		186	fi
		187	done
		188	}
		189
164	if [[ "${python2}" == "1" ]]; then	190	if [[ "${python_all}" == "1" ]]; then
165	die "${FUNCNAME}(): '-2' option and Python ABI cannot be specified simultaneously"	191	if [[ -z "${python_minimal_version}" && -z "${python_maximal_version}" ]]; then
		192	_PYTHON_ATOMS+=("dev-lang/python")
		193	else
		194	python_versions=("${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}" "${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}")
		195	python_minimal_version="${python_minimal_version:-${python_versions[0]}}"
		196	python_maximal_version="${python_maximal_version:-${python_versions[${#python_versions[@]}-1]}}"
		197	_append_accepted_versions_range
166	fi	198	fi
		199	else
167	if [[ "${python3}" == "1" ]]; then	200	if [[ "${python3}" == "1" ]]; then
168	die "${FUNCNAME}(): '-3' option and Python ABI cannot be specified simultaneously"	201	if [[ -z "${python3_minimal_version}" && -z "${python3_maximal_version}" ]]; then
		202	_PYTHON_ATOMS+=("=dev-lang/python-3*")
		203	else
		204	python_versions=("${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}")
		205	python_minimal_version="${python3_minimal_version:-${python_versions[0]}}"
		206	python_maximal_version="${python3_maximal_version:-${python_versions[${#python_versions[@]}-1]}}"
		207	_append_accepted_versions_range
		208	fi
169	fi	209	fi
170	slot="$1"	210	if [[ "${python2}" == "1" ]]; then
		211	if [[ -z "${python2_minimal_version}" && -z "${python2_maximal_version}" ]]; then
		212	_PYTHON_ATOMS+=("=dev-lang/python-2*")
		213	else
		214	python_versions=("${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}")
		215	python_minimal_version="${python2_minimal_version:-${python_versions[0]}}"
		216	python_maximal_version="${python2_maximal_version:-${python_versions[${#python_versions[@]}-1]}}"
		217	_append_accepted_versions_range
		218	fi
		219	fi
		220	fi
		221
		222	unset -f _append_accepted_versions_range
		223
		224	if [[ "${#_PYTHON_ATOMS[@]}" -gt 1 ]]; then
		225	DEPEND+="${DEPEND:+ }${USE_flag}${USE_flag:+? ( }\|\| ( ${_PYTHON_ATOMS[@]} )${USE_flag:+ )}"
		226	RDEPEND+="${RDEPEND:+ }${USE_flag}${USE_flag:+? ( }\|\| ( ${_PYTHON_ATOMS[@]} )${USE_flag:+ )}"
171	else	227	else
172	die "${FUNCNAME}(): Invalid usage"	228	DEPEND+="${DEPEND:+ }${USE_flag}${USE_flag:+? ( }${_PYTHON_ATOMS[@]}${USE_flag:+ )}"
		229	RDEPEND+="${RDEPEND:+ }${USE_flag}${USE_flag:+? ( }${_PYTHON_ATOMS[@]}${USE_flag:+ )}"
173	fi	230	fi
		231	else
		232	die "Invalid syntax of PYTHON_DEPEND"
		233	fi
		234	}
174		235
175	if [[ "${ABI_output}" == "1" ]]; then	236	DEPEND=">=app-admin/eselect-python-20091230"
176	echo -n "${slot}"	237	RDEPEND="${DEPEND}"
177	return	238
178	elif [[ "${absolute_path_output}" == "1" ]]; then	239	if [[ -n "${PYTHON_DEPEND}" ]]; then
179	echo -n "/usr/bin/python${slot}"	240	_python_parse_PYTHON_DEPEND
180	else	241	else
181	echo -n "python${slot}"	242	_PYTHON_ATOMS=("dev-lang/python")
182	fi	243	fi
		244	unset -f _python_parse_PYTHON_DEPEND
183		245
184	if [[ -n "${ABI}" && "${ABI}" != "${DEFAULT_ABI}" && "${DEFAULT_ABI}" != "default" ]]; then	246	if [[ -n "${NEED_PYTHON}" ]]; then
185	echo -n "-${ABI}"	247	eerror "Use PYTHON_DEPEND variable instead of NEED_PYTHON variable."
		248	die "NEED_PYTHON variable is banned"
186	fi	249	fi
187	}	250
		251	# @ECLASS-VARIABLE: PYTHON_USE_WITH
		252	# @DESCRIPTION:
		253	# Set this to a space separated list of USE flags the Python slot in use must be built with.
		254
		255	# @ECLASS-VARIABLE: PYTHON_USE_WITH_OR
		256	# @DESCRIPTION:
		257	# Set this to a space separated list of USE flags of which one must be turned on for the slot in use.
		258
		259	# @ECLASS-VARIABLE: PYTHON_USE_WITH_OPT
		260	# @DESCRIPTION:
		261	# Set this to a name of a USE flag if you need to make either PYTHON_USE_WITH or
		262	# PYTHON_USE_WITH_OR atoms conditional under a USE flag.
		263
		264	if ! has "${EAPI:-0}" 0 1 && [[ -n ${PYTHON_USE_WITH} \|\| -n ${PYTHON_USE_WITH_OR} ]]; then
		265	_PYTHON_USE_WITH_ATOMS_ARRAY=()
		266	if [[ -n "${PYTHON_USE_WITH}" ]]; then
		267	for _PYTHON_ATOM in "${_PYTHON_ATOMS[@]}"; do
		268	_PYTHON_USE_WITH_ATOMS_ARRAY+=("${_PYTHON_ATOM}[${PYTHON_USE_WITH// /,}]")
		269	done
		270	elif [[ -n "${PYTHON_USE_WITH_OR}" ]]; then
		271	for _USE_flag in ${PYTHON_USE_WITH_OR}; do
		272	for _PYTHON_ATOM in "${_PYTHON_ATOMS[@]}"; do
		273	_PYTHON_USE_WITH_ATOMS_ARRAY+=("${_PYTHON_ATOM}[${_USE_flag}]")
		274	done
		275	done
		276	unset _USE_flag
		277	fi
		278	if [[ "${#_PYTHON_USE_WITH_ATOMS_ARRAY[@]}" -gt 1 ]]; then
		279	_PYTHON_USE_WITH_ATOMS="\|\| ( ${_PYTHON_USE_WITH_ATOMS_ARRAY[@]} )"
		280	else
		281	_PYTHON_USE_WITH_ATOMS="${_PYTHON_USE_WITH_ATOMS_ARRAY[@]}"
		282	fi
		283	if [[ -n "${PYTHON_USE_WITH_OPT}" ]]; then
		284	_PYTHON_USE_WITH_ATOMS="${PYTHON_USE_WITH_OPT}? ( ${_PYTHON_USE_WITH_ATOMS} )"
		285	fi
		286	DEPEND+=" ${_PYTHON_USE_WITH_ATOMS}"
		287	RDEPEND+=" ${_PYTHON_USE_WITH_ATOMS}"
		288	unset _PYTHON_ATOM _PYTHON_USE_WITH_ATOMS _PYTHON_USE_WITH_ATOMS_ARRAY
		289	fi
		290
		291	unset _PYTHON_ATOMS
		292
		293	# ================================================================================================
		294	# =================================== MISCELLANEOUS FUNCTIONS ====================================
		295	# ================================================================================================
188		296
189	_python_implementation() {	297	_python_implementation() {
190	if [[ "${CATEGORY}/${PN}" == "dev-lang/python" ]]; then	298	if [[ "${CATEGORY}/${PN}" == "dev-lang/python" ]]; then
191	return 0	299	return 0
		300	elif [[ "${CATEGORY}/${PN}" == "dev-java/jython" ]]; then
		301	return 0
		302	elif [[ "${CATEGORY}/${PN}" == "dev-python/pypy" ]]; then
		303	return 0
192	else	304	else
193	return 1	305	return 1
194	fi	306	fi
195	}	307	}
196		308
197	# @FUNCTION: python_set_active_version	309	_python_abi-specific_local_scope() {
198	# @USAGE: <Python_ABI\|2\|3>	310	[[ " ${FUNCNAME[@]:2} " =~ " "(_python_final_sanity_checks\|python_execute_function\|python_mod_optimize\|python_mod_cleanup)" " ]]
199	# @DESCRIPTION:	311	}
200	# Set active version of Python.	312
201	python_set_active_version() {	313	_python_initialize_prefix_variables() {
202	if [[ "$#" -ne "1" ]]; then	314	if has "${EAPI:-0}" 0 1 2; then
203	die "${FUNCNAME}() requires 1 argument"	315	if [[ -n "${ROOT}" && -z "${EROOT}" ]]; then
		316	EROOT="${ROOT%/}${EPREFIX}/"
204	fi	317	fi
205		318	if [[ -n "${D}" && -z "${ED}" ]]; then
206	if [[ "$1" =~ ^[[:digit:]]+\.[[:digit:]]+$ ]]; then	319	ED="${D%/}${EPREFIX}/"
207	if ! _python_implementation && ! has_version "dev-lang/python:$1"; then
208	die "${FUNCNAME}(): 'dev-lang/python:$1' is not installed"
209	fi
210	export EPYTHON="$(PYTHON "$1")"
211	elif [[ "$1" == "2" ]]; then
212	if ! _python_implementation && ! has_version "=dev-lang/python-2*"; then
213	die "${FUNCNAME}(): '=dev-lang/python-2*' is not installed"
214	fi
215	export EPYTHON="$(PYTHON -2)"
216	elif [[ "$1" == "3" ]]; then
217	if ! _python_implementation && ! has_version "=dev-lang/python-3*"; then
218	die "${FUNCNAME}(): '=dev-lang/python-3*' is not installed"
219	fi
220	export EPYTHON="$(PYTHON -3)"
221	else
222	die "${FUNCNAME}(): Unrecognized argument '$1'"
223	fi	320	fi
224
225	# PYTHON_ABI variable is intended to be used only in ebuilds/eclasses,
226	# so it does not need to be exported to subprocesses.
227	PYTHON_ABI="${EPYTHON#python}"
228	PYTHON_ABI="${PYTHON_ABI%%-*}"
229	}
230
231	unset PYTHON_ABIS
232	unset PYTHON_ABIS_SANITY_CHECKS
233
234	# @FUNCTION: validate_PYTHON_ABIS
235	# @DESCRIPTION:
236	# Ensure that PYTHON_ABIS variable has valid value.
237	validate_PYTHON_ABIS() {
238	# Ensure that some functions cannot be accidentally successfully used in EAPI <= 2 without setting SUPPORT_PYTHON_ABIS variable.
239	if has "${EAPI:-0}" 0 1 2 && [[ -z "${SUPPORT_PYTHON_ABIS}" ]]; then
240	die "${FUNCNAME}() cannot be used in this EAPI without setting SUPPORT_PYTHON_ABIS variable"
241	fi	321	fi
		322	}
242		323
		324	unset PYTHON_SANITY_CHECKS_EXECUTED PYTHON_SKIP_SANITY_CHECKS
		325
		326	_python_initial_sanity_checks() {
		327	if [[ "$(declare -p PYTHON_SANITY_CHECKS_EXECUTED 2> /dev/null)" != "declare -- PYTHON_SANITY_CHECKS_EXECUTED="* \|\| " ${FUNCNAME[@]:1} " =~ " "(python_set_active_version\|python_pkg_setup)" " && -z "${PYTHON_SKIP_SANITY_CHECKS}" ]]; then
243	# Ensure that /usr/bin/python and /usr/bin/python-config are valid.	328	# Ensure that /usr/bin/python and /usr/bin/python-config are valid.
244	if [[ "$(readlink /usr/bin/python)" != "python-wrapper" ]]; then	329	if [[ "$(readlink "${EPREFIX}/usr/bin/python")" != "python-wrapper" ]]; then
245	eerror "'/usr/bin/python' is not valid symlink."	330	eerror "'${EPREFIX}/usr/bin/python' is not valid symlink."
246	eerror "Use \`eselect python set \${python_interpreter}\` to fix this problem."	331	eerror "Use \`eselect python set \${python_interpreter}\` to fix this problem."
247	die "'/usr/bin/python' is not valid symlink"	332	die "'${EPREFIX}/usr/bin/python' is not valid symlink"
248	fi	333	fi
249	if [[ "$(</usr/bin/python-config)" != "Gentoo python-config wrapper script" ]]; then	334	if [[ "$(<"${EPREFIX}/usr/bin/python-config")" != "Gentoo python-config wrapper script" ]]; then
250	eerror "'/usr/bin/python-config' is not valid script"	335	eerror "'${EPREFIX}/usr/bin/python-config' is not valid script"
251	eerror "Use \`eselect python set \${python_interpreter}\` to fix this problem."	336	eerror "Use \`eselect python set \${python_interpreter}\` to fix this problem."
252	die "'/usr/bin/python-config' is not valid script"	337	die "'${EPREFIX}/usr/bin/python-config' is not valid script"
253	fi	338	fi
		339	fi
		340	}
254		341
255	# USE_${ABI_TYPE^^} and RESTRICT_${ABI_TYPE^^}_ABIS variables hopefully will be included in EAPI >= 5.	342	_python_final_sanity_checks() {
		343	if ! _python_implementation && [[ "$(declare -p PYTHON_SANITY_CHECKS_EXECUTED 2> /dev/null)" != "declare -- PYTHON_SANITY_CHECKS_EXECUTED="* \|\| " ${FUNCNAME[@]:1} " =~ " "(python_set_active_version\|python_pkg_setup)" " && -z "${PYTHON_SKIP_SANITY_CHECKS}" ]]; then
		344	local PYTHON_ABI="${PYTHON_ABI}"
		345	for PYTHON_ABI in ${PYTHON_ABIS-${PYTHON_ABI}}; do
		346	# Ensure that appropriate version of Python is installed.
		347	if ! has_version "$(python_get_implementational_package)"; then
		348	die "$(python_get_implementational_package) is not installed"
		349	fi
		350
		351	# Ensure that EPYTHON variable is respected.
		352	if [[ "$(EPYTHON="$(PYTHON)" python -c "${_PYTHON_ABI_EXTRACTION_COMMAND}")" != "${PYTHON_ABI}" ]]; then
		353	eerror "Path to 'python': '$(type -p python)'"
		354	eerror "ABI: '${ABI}'"
		355	eerror "DEFAULT_ABI: '${DEFAULT_ABI}'"
		356	eerror "EPYTHON: '$(PYTHON)'"
		357	eerror "PYTHON_ABI: '${PYTHON_ABI}'"
		358	eerror "Locally active version of Python: '$(EPYTHON="$(PYTHON)" python -c "${_PYTHON_ABI_EXTRACTION_COMMAND}")'"
		359	die "'python' does not respect EPYTHON variable"
		360	fi
		361	done
		362	fi
		363	PYTHON_SANITY_CHECKS_EXECUTED="1"
		364	}
		365
		366	# @ECLASS-VARIABLE: PYTHON_COLORS
		367	# @DESCRIPTION:
		368	# User-configurable colored output.
		369	PYTHON_COLORS="${PYTHON_COLORS:-0}"
		370
		371	_python_set_color_variables() {
		372	if [[ "${PYTHON_COLORS}" != "0" && "${NOCOLOR:-false}" =~ ^(false\|no)$ ]]; then
		373	_BOLD=$'\e[1m'
		374	_RED=$'\e[1;31m'
		375	_GREEN=$'\e[1;32m'
		376	_BLUE=$'\e[1;34m'
		377	_CYAN=$'\e[1;36m'
		378	_NORMAL=$'\e[0m'
		379	else
		380	_BOLD=
		381	_RED=
		382	_GREEN=
		383	_BLUE=
		384	_CYAN=
		385	_NORMAL=
		386	fi
		387	}
		388
		389	unset PYTHON_PKG_SETUP_EXECUTED
		390
		391	_python_check_python_pkg_setup_execution() {
		392	[[ " ${FUNCNAME[@]:1} " =~ " "(python_set_active_version\|python_pkg_setup)" " ]] && return
		393
		394	if ! has "${EAPI:-0}" 0 1 2 3 && [[ -z "${PYTHON_PKG_SETUP_EXECUTED}" ]]; then
		395	die "python_pkg_setup() not called"
		396	fi
		397	}
		398
		399	# @FUNCTION: python_pkg_setup
		400	# @DESCRIPTION:
		401	# Perform sanity checks and initialize environment.
		402	#
		403	# This function is exported in EAPI 2 and 3 when PYTHON_USE_WITH or PYTHON_USE_WITH_OR variable
		404	# is set and always in EAPI >=4. Calling of this function is mandatory in EAPI >=4.
		405	python_pkg_setup() {
		406	if [[ "${EBUILD_PHASE}" != "setup" ]]; then
		407	die "${FUNCNAME}() can be used only in pkg_setup() phase"
		408	fi
		409
		410	if [[ "$#" -ne 0 ]]; then
		411	die "${FUNCNAME}() does not accept arguments"
		412	fi
		413
		414	export JYTHON_SYSTEM_CACHEDIR="1"
		415	addwrite "${EPREFIX}/var/cache/jython"
		416
		417	if _python_package_supporting_installation_for_multiple_python_abis; then
		418	_python_calculate_PYTHON_ABIS
		419	export EPYTHON="$(PYTHON -f)"
		420	else
		421	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		422	fi
		423
		424	if ! has "${EAPI:-0}" 0 1 && [[ -n "${PYTHON_USE_WITH}" \|\| -n "${PYTHON_USE_WITH_OR}" ]]; then
		425	if [[ "${PYTHON_USE_WITH_OPT}" ]]; then
		426	if [[ "${PYTHON_USE_WITH_OPT}" == !* ]]; then
		427	use ${PYTHON_USE_WITH_OPT#!} && return
		428	else
		429	use !${PYTHON_USE_WITH_OPT} && return
		430	fi
		431	fi
		432
		433	python_pkg_setup_check_USE_flags() {
		434	local python_atom USE_flag
		435	python_atom="$(python_get_implementational_package)"
		436
		437	for USE_flag in ${PYTHON_USE_WITH}; do
		438	if ! has_version "${python_atom}[${USE_flag}]"; then
		439	eerror "Please rebuild ${python_atom} with the following USE flags enabled: ${PYTHON_USE_WITH}"
		440	die "Please rebuild ${python_atom} with the following USE flags enabled: ${PYTHON_USE_WITH}"
		441	fi
		442	done
		443
		444	for USE_flag in ${PYTHON_USE_WITH_OR}; do
		445	if has_version "${python_atom}[${USE_flag}]"; then
		446	return
		447	fi
		448	done
		449
		450	if [[ ${PYTHON_USE_WITH_OR} ]]; then
		451	eerror "Please rebuild ${python_atom} with at least one of the following USE flags enabled: ${PYTHON_USE_WITH_OR}"
		452	die "Please rebuild ${python_atom} with at least one of the following USE flags enabled: ${PYTHON_USE_WITH_OR}"
		453	fi
		454	}
		455
		456	if _python_package_supporting_installation_for_multiple_python_abis; then
		457	PYTHON_SKIP_SANITY_CHECKS="1" python_execute_function -q python_pkg_setup_check_USE_flags
		458	else
		459	python_pkg_setup_check_USE_flags
		460	fi
		461
		462	unset -f python_pkg_setup_check_USE_flags
		463	fi
		464
		465	PYTHON_PKG_SETUP_EXECUTED="1"
		466	}
		467
		468	if ! has "${EAPI:-0}" 0 1 2 3 \|\| { has "${EAPI:-0}" 2 3 && [[ -n "${PYTHON_USE_WITH}" \|\| -n "${PYTHON_USE_WITH_OR}" ]]; }; then
		469	EXPORT_FUNCTIONS pkg_setup
		470	fi
		471
		472	_PYTHON_SHEBANG_BASE_PART_REGEX='^#![[:space:]]([^[:space:]]/usr/bin/env[[:space:]]+)?([^[:space:]]*/)?(jython\|pypy-c\|python)'
		473
		474	# @FUNCTION: python_convert_shebangs
		475	# @USAGE: [-q\|--quiet] [-r\|--recursive] [-x\|--only-executables] [--] <Python_ABI\|Python_version> <file\|directory> [files\|directories]
		476	# @DESCRIPTION:
		477	# Convert shebangs in specified files. Directories can be specified only with --recursive option.
		478	python_convert_shebangs() {
		479	_python_check_python_pkg_setup_execution
		480
		481	local argument file files=() only_executables="0" python_interpreter quiet="0" recursive="0"
		482
		483	while (($#)); do
		484	case "$1" in
		485	-r\|--recursive)
		486	recursive="1"
		487	;;
		488	-q\|--quiet)
		489	quiet="1"
		490	;;
		491	-x\|--only-executables)
		492	only_executables="1"
		493	;;
		494	--)
		495	shift
		496	break
		497	;;
		498	-*)
		499	die "${FUNCNAME}(): Unrecognized option '$1'"
		500	;;
		501	*)
		502	break
		503	;;
		504	esac
		505	shift
		506	done
		507
		508	if [[ "$#" -eq 0 ]]; then
		509	die "${FUNCNAME}(): Missing Python version and files or directories"
		510	elif [[ "$#" -eq 1 ]]; then
		511	die "${FUNCNAME}(): Missing files or directories"
		512	fi
		513
		514	if [[ -n "$(_python_get_implementation --ignore-invalid "$1")" ]]; then
		515	python_interpreter="$(PYTHON "$1")"
		516	else
		517	python_interpreter="python$1"
		518	fi
		519	shift
		520
		521	for argument in "$@"; do
		522	if [[ ! -e "${argument}" ]]; then
		523	die "${FUNCNAME}(): '${argument}' does not exist"
		524	elif [[ -f "${argument}" ]]; then
		525	files+=("${argument}")
		526	elif [[ -d "${argument}" ]]; then
		527	if [[ "${recursive}" == "1" ]]; then
		528	while read -d $'\0' -r file; do
		529	files+=("${file}")
		530	done < <(find "${argument}" $([[ "${only_executables}" == "1" ]] && echo -perm /111) -type f -print0)
		531	else
		532	die "${FUNCNAME}(): '${argument}' is not a regular file"
		533	fi
		534	else
		535	die "${FUNCNAME}(): '${argument}' is not a regular file or a directory"
		536	fi
		537	done
		538
		539	for file in "${files[@]}"; do
		540	file="${file#./}"
		541	[[ "${only_executables}" == "1" && ! -x "${file}" ]] && continue
		542
		543	if [[ "$(head -n1 "${file}")" =~ ${_PYTHON_SHEBANG_BASE_PART_REGEX} ]]; then
		544	[[ "$(sed -ne "2p" "${file}")" =~ ^"# Gentoo '".*"' wrapper script generated by python_generate_wrapper_scripts()"$ ]] && continue
		545
		546	if [[ "${quiet}" == "0" ]]; then
		547	einfo "Converting shebang in '${file}'"
		548	fi
		549
		550	sed -e "1s:^#![[:space:]]$[^[:space:]]/usr/bin/env[[:space:]]$\?[[:space:]]$[^[:space:]]/$\?$jython\\|pypy-c\\|python$$[[:digit:]]\+\(\.[[:digit:]]\+$\?\)\?$\$\\|[[:space:]].*$:#!\1\2${python_interpreter}\6:" -i "${file}" \|\| die "Conversion of shebang in '${file}' failed"
		551	fi
		552	done
		553	}
		554
		555	# @FUNCTION: python_clean_installation_image
		556	# @USAGE: [-q\|--quiet]
		557	# @DESCRIPTION:
		558	# Delete needless files in installation image.
		559	#
		560	# This function can be used only in src_install() phase.
		561	python_clean_installation_image() {
		562	if [[ "${EBUILD_PHASE}" != "install" ]]; then
		563	die "${FUNCNAME}() can be used only in src_install() phase"
		564	fi
		565
		566	_python_check_python_pkg_setup_execution
		567	_python_initialize_prefix_variables
		568
		569	local file files=() quiet="0"
		570
		571	while (($#)); do
		572	case "$1" in
		573	-q\|--quiet)
		574	quiet="1"
		575	;;
		576	-*)
		577	die "${FUNCNAME}(): Unrecognized option '$1'"
		578	;;
		579	*)
		580	die "${FUNCNAME}(): Invalid usage"
		581	;;
		582	esac
		583	shift
		584	done
		585
		586	while read -d $'\0' -r file; do
		587	files+=("${file}")
		588	done < <(find "${ED}" "(" -name ".py[co]" -o -name "\$py.class" ")" -type f -print0)
		589
		590	if [[ "${#files[@]}" -gt 0 ]]; then
		591	if [[ "${quiet}" == "0" ]]; then
		592	ewarn "Deleting byte-compiled Python modules needlessly generated by build system:"
		593	fi
		594	for file in "${files[@]}"; do
		595	if [[ "${quiet}" == "0" ]]; then
		596	ewarn " ${file}"
		597	fi
		598	rm -f "${file}"
		599
		600	# Delete empty __pycache__ directories.
		601	if [[ "${file%/}" == "/__pycache__" ]]; then
		602	rmdir "${file%/*}" 2> /dev/null
		603	fi
		604	done
		605	fi
		606
		607	python_clean_sitedirs() {
		608	if [[ -d "${ED}$(python_get_sitedir)" ]]; then
		609	find "${ED}$(python_get_sitedir)" "(" -name ".c" -o -name ".h" -o -name "*.la" ")" -type f -print0 \| xargs -0 rm -f
		610	fi
		611	}
		612	if _python_package_supporting_installation_for_multiple_python_abis; then
		613	python_execute_function -q python_clean_sitedirs
		614	else
		615	python_clean_sitedirs
		616	fi
		617
		618	unset -f python_clean_sitedirs
		619	}
		620
		621	# ================================================================================================
		622	# =========== FUNCTIONS FOR PACKAGES SUPPORTING INSTALLATION FOR MULTIPLE PYTHON ABIS ============
		623	# ================================================================================================
		624
		625	# @ECLASS-VARIABLE: SUPPORT_PYTHON_ABIS
		626	# @DESCRIPTION:
		627	# Set this in EAPI <= 4 to indicate that current package supports installation for
		628	# multiple Python ABIs.
		629
		630	# @ECLASS-VARIABLE: PYTHON_TESTS_RESTRICTED_ABIS
		631	# @DESCRIPTION:
		632	# Space-separated list of Python ABI patterns. Testing in Python ABIs matching any Python ABI
		633	# patterns specified in this list is skipped.
		634
		635	# @ECLASS-VARIABLE: PYTHON_EXPORT_PHASE_FUNCTIONS
		636	# @DESCRIPTION:
		637	# Set this to export phase functions for the following ebuild phases:
		638	# src_prepare(), src_configure(), src_compile(), src_test(), src_install().
		639	if ! has "${EAPI:-0}" 0 1; then
		640	python_src_prepare() {
		641	if [[ "${EBUILD_PHASE}" != "prepare" ]]; then
		642	die "${FUNCNAME}() can be used only in src_prepare() phase"
		643	fi
		644
		645	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		646	die "${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		647	fi
		648
		649	_python_check_python_pkg_setup_execution
		650
		651	if [[ "$#" -ne 0 ]]; then
		652	die "${FUNCNAME}() does not accept arguments"
		653	fi
		654
		655	python_copy_sources
		656	}
		657
		658	for python_default_function in src_configure src_compile src_test; do
		659	eval "python_${python_default_function}() {
		660	if [[ \"\${EBUILD_PHASE}\" != \"${python_default_function#src_}\" ]]; then
		661	die \"\${FUNCNAME}() can be used only in ${python_default_function}() phase\"
		662	fi
		663
		664	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		665	die \"\${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs\"
		666	fi
		667
		668	_python_check_python_pkg_setup_execution
		669
		670	python_execute_function -d -s -- \"\$@\"
		671	}"
		672	done
		673	unset python_default_function
		674
		675	python_src_install() {
		676	if [[ "${EBUILD_PHASE}" != "install" ]]; then
		677	die "${FUNCNAME}() can be used only in src_install() phase"
		678	fi
		679
		680	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		681	die "${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		682	fi
		683
		684	_python_check_python_pkg_setup_execution
		685
		686	if has "${EAPI:-0}" 0 1 2 3; then
		687	python_execute_function -d -s -- "$@"
		688	else
		689	python_installation() {
		690	emake DESTDIR="${T}/images/${PYTHON_ABI}" install "$@"
		691	}
		692	python_execute_function -s python_installation "$@"
		693	unset python_installation
		694
		695	python_merge_intermediate_installation_images "${T}/images"
		696	fi
		697	}
		698
		699	if [[ -n "${PYTHON_EXPORT_PHASE_FUNCTIONS}" ]]; then
		700	EXPORT_FUNCTIONS src_prepare src_configure src_compile src_test src_install
		701	fi
		702	fi
		703
		704	if has "${EAPI:-0}" 0 1 2 3 4; then
		705	unset PYTHON_ABIS
		706	fi
		707
		708	_python_calculate_PYTHON_ABIS() {
		709	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		710	die "${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		711	fi
		712
		713	_python_initial_sanity_checks
		714
256	if [[ "$(declare -p PYTHON_ABIS 2> /dev/null)" != "declare -x PYTHON_ABIS="* ]] && has "${EAPI:-0}" 0 1 2 3 4; then	715	if [[ "$(declare -p PYTHON_ABIS 2> /dev/null)" != "declare -x PYTHON_ABIS="* ]] && has "${EAPI:-0}" 0 1 2 3 4; then
257	local PYTHON_ABI python2_supported_versions python3_supported_versions restricted_ABI support_ABI supported_PYTHON_ABIS=	716	local PYTHON_ABI
258	PYTHON_ABI_SUPPORTED_VALUES="2.4 2.5 2.6 2.7 3.0 3.1 3.2"
259	python2_supported_versions="2.4 2.5 2.6 2.7"
260	python3_supported_versions="3.0 3.1 3.2"
261		717
262	if [[ "$(declare -p USE_PYTHON 2> /dev/null)" == "declare -x USE_PYTHON="* ]]; then	718	if [[ "$(declare -p USE_PYTHON 2> /dev/null)" == "declare -x USE_PYTHON="* ]]; then
263	local python2_enabled="0" python3_enabled="0"	719	local cpython_enabled="0"
264		720
265	if [[ -z "${USE_PYTHON}" ]]; then	721	if [[ -z "${USE_PYTHON}" ]]; then
266	die "USE_PYTHON variable is empty"	722	die "USE_PYTHON variable is empty"
267	fi	723	fi
268		724
269	for PYTHON_ABI in ${USE_PYTHON}; do	725	for PYTHON_ABI in ${USE_PYTHON}; do
270	if ! has "${PYTHON_ABI}" ${PYTHON_ABI_SUPPORTED_VALUES}; then	726	if ! has "${PYTHON_ABI}" "${_PYTHON_GLOBALLY_SUPPORTED_ABIS[@]}"; then
271	die "USE_PYTHON variable contains invalid value '${PYTHON_ABI}'"	727	die "USE_PYTHON variable contains invalid value '${PYTHON_ABI}'"
272	fi	728	fi
273		729
274	if has "${PYTHON_ABI}" ${python2_supported_versions}; then	730	if has "${PYTHON_ABI}" "${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}" "${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}"; then
275	python2_enabled="1"	731	cpython_enabled="1"
		732	fi
		733
		734	if ! _python_check_python_abi_matching --patterns-list "${PYTHON_ABI}" "${RESTRICT_PYTHON_ABIS}"; then
		735	export PYTHON_ABIS+="${PYTHON_ABIS:+ }${PYTHON_ABI}"
		736	fi
		737	done
		738
		739	if [[ -z "${PYTHON_ABIS//[${IFS}]/}" ]]; then
		740	die "USE_PYTHON variable does not enable any Python ABI supported by ${CATEGORY}/${PF}"
276	fi	741	fi
277	if has "${PYTHON_ABI}" ${python3_supported_versions}; then	742
278	python3_enabled="1"	743	if [[ "${cpython_enabled}" == "0" ]]; then
		744	die "USE_PYTHON variable does not enable any CPython ABI"
279	fi	745	fi
		746	else
		747	local python_version python2_version python3_version support_python_major_version
280		748
281	support_ABI="1"	749	if ! has_version "dev-lang/python"; then
282	for restricted_ABI in ${RESTRICT_PYTHON_ABIS}; do	750	die "${FUNCNAME}(): 'dev-lang/python' is not installed"
283	if [[ "${PYTHON_ABI}" == ${restricted_ABI} ]]; then	751	fi
284	support_ABI="0"	752
		753	python_version="$("${EPREFIX}/usr/bin/python" -c 'from sys import version_info; print(".".join(str(x) for x in version_info[:2]))')"
		754
		755	if has_version "=dev-lang/python-2*"; then
		756	if [[ "$(readlink "${EPREFIX}/usr/bin/python2")" != "python2."* ]]; then
		757	die "'${EPREFIX}/usr/bin/python2' is not valid symlink"
		758	fi
		759
		760	python2_version="$("${EPREFIX}/usr/bin/python2" -c 'from sys import version_info; print(".".join(str(x) for x in version_info[:2]))')"
		761
		762	support_python_major_version="0"
		763	for PYTHON_ABI in "${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}"; do
		764	if ! _python_check_python_abi_matching --patterns-list "${PYTHON_ABI}" "${RESTRICT_PYTHON_ABIS}"; then
		765	support_python_major_version="1"
285	break	766	break
286	fi	767	fi
287	done	768	done
288	[[ "${support_ABI}" == "1" ]] && export PYTHON_ABIS+="${PYTHON_ABIS:+ }${PYTHON_ABI}"	769	if [[ "${support_python_major_version}" == "1" ]]; then
289	done	770	if _python_check_python_abi_matching --patterns-list "${python2_version}" "${RESTRICT_PYTHON_ABIS}"; then
290		771	die "Active version of CPython 2 is not supported by ${CATEGORY}/${PF}"
291	if [[ -z "${PYTHON_ABIS//[${IFS}]/}" ]]; then	772	fi
292	die "USE_PYTHON variable does not enable any version of Python supported by ${CATEGORY}/${PF}"	773	else
		774	python2_version=""
293	fi	775	fi
294
295	if [[ "${python2_enabled}" == "0" ]]; then
296	ewarn "USE_PYTHON variable does not enable any version of Python 2. This configuration is unsupported."
297	fi	776	fi
298	if [[ "${python3_enabled}" == "0" ]]; then
299	ewarn "USE_PYTHON variable does not enable any version of Python 3. This configuration is unsupported."
300	fi
301	else
302	local python_version python2_version= python3_version= support_python_major_version
303		777
304	python_version="$(/usr/bin/python -c 'from sys import version_info; print(".".join([str(x) for x in version_info[:2]]))')"
305
306	if has_version "=dev-lang/python-2*"; then	778	if has_version "=dev-lang/python-3*"; then
307	if [[ "$(readlink /usr/bin/python2)" != "python2."* ]]; then	779	if [[ "$(readlink "${EPREFIX}/usr/bin/python3")" != "python3."* ]]; then
308	die "'/usr/bin/python2' is not valid symlink"	780	die "'${EPREFIX}/usr/bin/python3' is not valid symlink"
309	fi	781	fi
310		782
311	python2_version="$(/usr/bin/python2 -c 'from sys import version_info; print(".".join([str(x) for x in version_info[:2]]))')"	783	python3_version="$("${EPREFIX}/usr/bin/python3" -c 'from sys import version_info; print(".".join(str(x) for x in version_info[:2]))')"
312		784
313	for PYTHON_ABI in ${python2_supported_versions}; do	785	support_python_major_version="0"
		786	for PYTHON_ABI in "${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}"; do
		787	if ! _python_check_python_abi_matching --patterns-list "${PYTHON_ABI}" "${RESTRICT_PYTHON_ABIS}"; then
314	support_python_major_version="1"	788	support_python_major_version="1"
315	for restricted_ABI in ${RESTRICT_PYTHON_ABIS}; do	789	break
316	if [[ "${PYTHON_ABI}" == ${restricted_ABI} ]]; then
317	support_python_major_version="0"
318	fi	790	fi
319	done
320	[[ "${support_python_major_version}" == "1" ]] && break
321	done	791	done
322	if [[ "${support_python_major_version}" == "1" ]]; then	792	if [[ "${support_python_major_version}" == "1" ]]; then
323	for restricted_ABI in ${RESTRICT_PYTHON_ABIS}; do	793	if _python_check_python_abi_matching --patterns-list "${python3_version}" "${RESTRICT_PYTHON_ABIS}"; then
324	if [[ "${python2_version}" == ${restricted_ABI} ]]; then
325	die "Active version of Python 2 is not supported by ${CATEGORY}/${PF}"
326	fi
327	done
328	else
329	python2_version=""
330	fi
331	fi
332
333	if has_version "=dev-lang/python-3*"; then
334	if [[ "$(readlink /usr/bin/python3)" != "python3."* ]]; then
335	die "'/usr/bin/python3' is not valid symlink"
336	fi
337
338	python3_version="$(/usr/bin/python3 -c 'from sys import version_info; print(".".join([str(x) for x in version_info[:2]]))')"
339
340	for PYTHON_ABI in ${python3_supported_versions}; do
341	support_python_major_version="1"
342	for restricted_ABI in ${RESTRICT_PYTHON_ABIS}; do
343	if [[ "${PYTHON_ABI}" == ${restricted_ABI} ]]; then
344	support_python_major_version="0"
345	fi
346	done
347	[[ "${support_python_major_version}" == "1" ]] && break
348	done
349	if [[ "${support_python_major_version}" == "1" ]]; then
350	for restricted_ABI in ${RESTRICT_PYTHON_ABIS}; do
351	if [[ "${python3_version}" == ${restricted_ABI} ]]; then
352	die "Active version of Python 3 is not supported by ${CATEGORY}/${PF}"	794	die "Active version of CPython 3 is not supported by ${CATEGORY}/${PF}"
353	fi	795	fi
354	done
355	else	796	else
356	python3_version=""	797	python3_version=""
357	fi	798	fi
358	fi	799	fi
359		800
360	if [[ -n "${python2_version}" && "${python_version}" == "2."* && "${python_version}" != "${python2_version}" ]]; then	801	if [[ -n "${python2_version}" && "${python_version}" == "2."* && "${python_version}" != "${python2_version}" ]]; then
361	eerror "Python wrapper is configured incorrectly or /usr/bin/python2 symlink"	802	eerror "Python wrapper is configured incorrectly or '${EPREFIX}/usr/bin/python2' symlink"
362	eerror "is set incorrectly. Use \`eselect python\` to fix configuration."	803	eerror "is set incorrectly. Use \`eselect python\` to fix configuration."
363	die "Incorrect configuration of Python"	804	die "Incorrect configuration of Python"
364	fi	805	fi
365	if [[ -n "${python3_version}" && "${python_version}" == "3."* && "${python_version}" != "${python3_version}" ]]; then	806	if [[ -n "${python3_version}" && "${python_version}" == "3."* && "${python_version}" != "${python3_version}" ]]; then
366	eerror "Python wrapper is configured incorrectly or /usr/bin/python3 symlink"	807	eerror "Python wrapper is configured incorrectly or '${EPREFIX}/usr/bin/python3' symlink"
367	eerror "is set incorrectly. Use \`eselect python\` to fix configuration."	808	eerror "is set incorrectly. Use \`eselect python\` to fix configuration."
368	die "Incorrect configuration of Python"	809	die "Incorrect configuration of Python"
369	fi	810	fi
370		811
371	PYTHON_ABIS="${python2_version} ${python3_version}"	812	PYTHON_ABIS="${python2_version} ${python3_version}"
372	PYTHON_ABIS="${PYTHON_ABIS# }"	813	PYTHON_ABIS="${PYTHON_ABIS# }"
373	export PYTHON_ABIS="${PYTHON_ABIS% }"	814	export PYTHON_ABIS="${PYTHON_ABIS% }"
374	fi	815	fi
375	fi	816	fi
376		817
377	if ! _python_implementation && [[ "$(declare -p PYTHON_ABIS_SANITY_CHECKS 2> /dev/null)" != "declare -- PYTHON_ABIS_SANITY_CHECKS="* ]]; then	818	_python_final_sanity_checks
378	local PYTHON_ABI	819	}
379	for PYTHON_ABI in ${PYTHON_ABIS}; do	820
380	# Ensure that appropriate version of Python is installed.	821	_python_prepare_flags() {
381	if ! has_version "dev-lang/python:${PYTHON_ABI}"; then	822	local array=() deleted_flag element flags new_value old_flag old_value operator pattern prefix variable
382	die "dev-lang/python:${PYTHON_ABI} is not installed"	823
		824	for variable in CPPFLAGS CFLAGS CXXFLAGS LDFLAGS; do
		825	eval "_PYTHON_SAVED_${variable}=\"\${!variable}\""
		826	for prefix in PYTHON_USER_ PYTHON_; do
		827	if [[ "$(declare -p ${prefix}${variable} 2> /dev/null)" == "declare -a ${prefix}${variable}="* ]]; then
		828	eval "array=(\"\${${prefix}${variable}[@]}\")"
		829	for element in "${array[@]}"; do
		830	if [[ "${element}" =~ ^${_PYTHON_ABI_PATTERN_REGEX}\ (\+\|-)\ .+ ]]; then
		831	pattern="${element%% *}"
		832	element="${element#* }"
		833	operator="${element%% *}"
		834	flags="${element#* }"
		835	if _python_check_python_abi_matching "${PYTHON_ABI}" "${pattern}"; then
		836	if [[ "${operator}" == "+" ]]; then
		837	eval "export ${variable}+=\"\${variable:+ }${flags}\""
		838	elif [[ "${operator}" == "-" ]]; then
		839	flags="${flags// /$'\n'}"
		840	old_value="${!variable// /$'\n'}"
		841	new_value=""
		842	while read old_flag; do
		843	while read deleted_flag; do
		844	if [[ "${old_flag}" == ${deleted_flag} ]]; then
		845	continue 2
		846	fi
		847	done <<< "${flags}"
		848	new_value+="${new_value:+ }${old_flag}"
		849	done <<< "${old_value}"
		850	eval "export ${variable}=\"\${new_value}\""
		851	fi
383	fi	852	fi
384
385	# Ensure that EPYTHON variable is respected.
386	if [[ "$(EPYTHON="$(PYTHON)" python -c 'from sys import version_info; print(".".join([str(x) for x in version_info[:2]]))')" != "${PYTHON_ABI}" ]]; then
387	eerror "python: '$(type -p python)'"
388	eerror "ABI: '${ABI}'"
389	eerror "DEFAULT_ABI: '${DEFAULT_ABI}'"
390	eerror "EPYTHON: '$(PYTHON)'"
391	eerror "PYTHON_ABI: '${PYTHON_ABI}'"
392	eerror "Version of enabled Python: '$(EPYTHON="$(PYTHON)" python -c 'from sys import version_info; print(".".join([str(x) for x in version_info[:2]]))')'"
393	die "'python' does not respect EPYTHON variable"
394	fi
395	done
396	PYTHON_ABIS_SANITY_CHECKS="1"
397	fi
398	}
399
400	# @FUNCTION: python_copy_sources
401	# @USAGE: [--no-link] [--] [directory]
402	# @DESCRIPTION:
403	# Copy unpacked sources of given package for each Python ABI.
404	python_copy_sources() {
405	local dir dirs=() no_link="0" PYTHON_ABI
406
407	while (($#)); do
408	case "$1" in
409	--no-link)
410	no_link="1"
411	;;
412	--)
413	break
414	;;
415	-*)
416	die "${FUNCNAME}(): Unrecognized option '$1'"
417	;;
418	*)
419	break
420	;;
421	esac
422	shift
423	done
424
425	if [[ "$#" -eq 0 ]]; then
426	if [[ "${WORKDIR}" == "${S}" ]]; then
427	die "${FUNCNAME}() cannot be used"
428	fi
429	dirs="${S}"
430	else
431	dirs="$@"
432	fi
433
434	validate_PYTHON_ABIS
435	for PYTHON_ABI in ${PYTHON_ABIS}; do
436	for dir in "${dirs[@]}"; do
437	if [[ "${no_link}" == "1" ]]; then
438	cp -pr "${dir}" "${dir}-${PYTHON_ABI}" > /dev/null \|\| die "Copying of sources failed"
439	else	853	else
440	cp -lpr "${dir}" "${dir}-${PYTHON_ABI}" > /dev/null \|\| die "Copying of sources failed"	854	die "Element '${element}' of ${prefix}${variable} array has invalid syntax"
		855	fi
		856	done
		857	elif [[ -n "$(declare -p ${prefix}${variable} 2> /dev/null)" ]]; then
		858	die "${prefix}${variable} should be indexed array"
441	fi	859	fi
442	done	860	done
443	done	861	done
444	}	862	}
445		863
446	# @FUNCTION: python_set_build_dir_symlink	864	_python_restore_flags() {
447	# @USAGE: [directory="build"]	865	local variable
448	# @DESCRIPTION:
449	# Create build directory symlink.
450	python_set_build_dir_symlink() {
451	local dir="$1"
452		866
453	[[ -z "${PYTHON_ABI}" ]] && die "PYTHON_ABI variable not set"	867	for variable in CPPFLAGS CFLAGS CXXFLAGS LDFLAGS; do
454	[[ -z "${dir}" ]] && dir="build"	868	eval "${variable}=\"\${_PYTHON_SAVED_${variable}}\""
455		869	unset _PYTHON_SAVED_${variable}
456	# Do not delete preexistent directories.	870	done
457	rm -f "${dir}" \|\| die "Deletion of '${dir}' failed"
458	ln -s "${dir}-${PYTHON_ABI}" "${dir}" \|\| die "Creation of '${dir}' directory symlink failed"
459	}	871	}
460		872
461	# @FUNCTION: python_execute_function	873	# @FUNCTION: python_execute_function
462	# @USAGE: [--action-message message] [-d\|--default-function] [--failure-message message] [--nonfatal] [-q\|--quiet] [-s\|--separate-build-dirs] [--source-dir source_directory] [--] <function> [arguments]	874	# @USAGE: [--action-message message] [-d\|--default-function] [--failure-message message] [-f\|--final-ABI] [--nonfatal] [-q\|--quiet] [-s\|--separate-build-dirs] [--source-dir source_directory] [--] <function> [arguments]
463	# @DESCRIPTION:	875	# @DESCRIPTION:
464	# Execute specified function for each value of PYTHON_ABIS, optionally passing additional	876	# Execute specified function for each value of PYTHON_ABIS, optionally passing additional
465	# arguments. The specified function can use PYTHON_ABI and BUILDDIR variables.	877	# arguments. The specified function can use PYTHON_ABI and BUILDDIR variables.
466	python_execute_function() {	878	python_execute_function() {
467	local action action_message action_message_template= default_function="0" failure_message failure_message_template= function nonfatal="0" previous_directory previous_directory_stack previous_directory_stack_length PYTHON_ABI quiet="0" separate_build_dirs="0" source_dir=	879	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		880	die "${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		881	fi
		882
		883	_python_check_python_pkg_setup_execution
		884	_python_set_color_variables
		885
		886	local action action_message action_message_template default_function="0" failure_message failure_message_template final_ABI="0" function iterated_PYTHON_ABIS nonfatal="0" previous_directory previous_directory_stack previous_directory_stack_length PYTHON_ABI quiet="0" return_code separate_build_dirs="0" source_dir
468		887
469	while (($#)); do	888	while (($#)); do
470	case "$1" in	889	case "$1" in
471	--action-message)	890	--action-message)
472	action_message_template="$2"	891	action_message_template="$2"
…		…
477	;;	896	;;
478	--failure-message)	897	--failure-message)
479	failure_message_template="$2"	898	failure_message_template="$2"
480	shift	899	shift
481	;;	900	;;
		901	-f\|--final-ABI)
		902	final_ABI="1"
		903	;;
482	--nonfatal)	904	--nonfatal)
483	nonfatal="1"	905	nonfatal="1"
484	;;	906	;;
485	-q\|--quiet)	907	-q\|--quiet)
486	quiet="1"	908	quiet="1"
…		…
491	--source-dir)	913	--source-dir)
492	source_dir="$2"	914	source_dir="$2"
493	shift	915	shift
494	;;	916	;;
495	--)	917	--)
		918	shift
496	break	919	break
497	;;	920	;;
498	-*)	921	-*)
499	die "${FUNCNAME}(): Unrecognized option '$1'"	922	die "${FUNCNAME}(): Unrecognized option '$1'"
500	;;	923	;;
…		…
518		941
519	if [[ -z "$(type -t "${function}")" ]]; then	942	if [[ -z "$(type -t "${function}")" ]]; then
520	die "${FUNCNAME}(): '${function}' function is not defined"	943	die "${FUNCNAME}(): '${function}' function is not defined"
521	fi	944	fi
522	else	945	else
523	if [[ "$#" -ne "0" ]]; then
524	die "${FUNCNAME}(): '--default-function' option and function name cannot be specified simultaneously"
525	fi
526	if has "${EAPI:-0}" 0 1; then	946	if has "${EAPI:-0}" 0 1; then
527	die "${FUNCNAME}(): '--default-function' option cannot be used in this EAPI"	947	die "${FUNCNAME}(): '--default-function' option cannot be used in this EAPI"
528	fi	948	fi
529		949
530	if [[ "${EBUILD_PHASE}" == "configure" ]]; then	950	if [[ "${EBUILD_PHASE}" == "configure" ]]; then
531	if has "${EAPI}" 2 3; then	951	if has "${EAPI}" 2 3; then
532	python_default_function() {	952	python_default_function() {
533	econf	953	econf "$@"
534	}	954	}
535	else	955	else
536	python_default_function() {	956	python_default_function() {
537	nonfatal econf	957	nonfatal econf "$@"
538	}	958	}
539	fi	959	fi
540	elif [[ "${EBUILD_PHASE}" == "compile" ]]; then	960	elif [[ "${EBUILD_PHASE}" == "compile" ]]; then
541	python_default_function() {	961	python_default_function() {
542	emake	962	emake "$@"
543	}	963	}
544	elif [[ "${EBUILD_PHASE}" == "test" ]]; then	964	elif [[ "${EBUILD_PHASE}" == "test" ]]; then
545	python_default_function() {	965	python_default_function() {
546	if emake -j1 -n check &> /dev/null; then	966	if emake -j1 -n check &> /dev/null; then
547	emake -j1 check	967	emake -j1 check "$@"
548	elif emake -j1 -n test &> /dev/null; then	968	elif emake -j1 -n test &> /dev/null; then
549	emake -j1 test	969	emake -j1 test "$@"
550	fi	970	fi
551	}	971	}
552	elif [[ "${EBUILD_PHASE}" == "install" ]]; then	972	elif [[ "${EBUILD_PHASE}" == "install" ]]; then
553	python_default_function() {	973	python_default_function() {
554	emake DESTDIR="${D}" install	974	emake DESTDIR="${D}" install "$@"
555	}	975	}
556	else	976	else
557	die "${FUNCNAME}(): '--default-function' option cannot be used in this ebuild phase"	977	die "${FUNCNAME}(): '--default-function' option cannot be used in this ebuild phase"
558	fi	978	fi
559	function="python_default_function"	979	function="python_default_function"
		980	fi
		981
		982	# Ensure that python_execute_function() cannot be directly or indirectly called by python_execute_function().
		983	if _python_abi-specific_local_scope; then
		984	die "${FUNCNAME}(): Invalid call stack"
560	fi	985	fi
561		986
562	if [[ "${quiet}" == "0" ]]; then	987	if [[ "${quiet}" == "0" ]]; then
563	[[ "${EBUILD_PHASE}" == "setup" ]] && action="Setting up"	988	[[ "${EBUILD_PHASE}" == "setup" ]] && action="Setting up"
564	[[ "${EBUILD_PHASE}" == "unpack" ]] && action="Unpacking"	989	[[ "${EBUILD_PHASE}" == "unpack" ]] && action="Unpacking"
…		…
571	[[ "${EBUILD_PHASE}" == "postinst" ]] && action="Postinstallation"	996	[[ "${EBUILD_PHASE}" == "postinst" ]] && action="Postinstallation"
572	[[ "${EBUILD_PHASE}" == "prerm" ]] && action="Preuninstallation"	997	[[ "${EBUILD_PHASE}" == "prerm" ]] && action="Preuninstallation"
573	[[ "${EBUILD_PHASE}" == "postrm" ]] && action="Postuninstallation"	998	[[ "${EBUILD_PHASE}" == "postrm" ]] && action="Postuninstallation"
574	fi	999	fi
575		1000
576	local RED GREEN BLUE NORMAL	1001	_python_calculate_PYTHON_ABIS
577	if [[ "${NOCOLOR:-false}" =~ ^(false\|no)$ ]]; then	1002	if [[ "${final_ABI}" == "1" ]]; then
578	RED=$'\e[1;31m'	1003	iterated_PYTHON_ABIS="$(PYTHON -f --ABI)"
579	GREEN=$'\e[1;32m'
580	BLUE=$'\e[1;34m'
581	NORMAL=$'\e[0m'
582	else	1004	else
583	RED=	1005	iterated_PYTHON_ABIS="${PYTHON_ABIS}"
584	GREEN=
585	BLUE=
586	NORMAL=
587	fi	1006	fi
588
589	validate_PYTHON_ABIS
590	for PYTHON_ABI in ${PYTHON_ABIS}; do	1007	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do
		1008	if [[ "${EBUILD_PHASE}" == "test" ]] && _python_check_python_abi_matching --patterns-list "${PYTHON_ABI}" "${PYTHON_TESTS_RESTRICTED_ABIS}"; then
		1009	if [[ "${quiet}" == "0" ]]; then
		1010	echo " ${_GREEN}*${_NORMAL} ${_BLUE}Testing of ${CATEGORY}/${PF} with $(python_get_implementation_and_version) skipped${_NORMAL}"
		1011	fi
		1012	continue
		1013	fi
		1014
		1015	_python_prepare_flags
		1016
591	if [[ "${quiet}" == "0" ]]; then	1017	if [[ "${quiet}" == "0" ]]; then
592	if [[ -n "${action_message_template}" ]]; then	1018	if [[ -n "${action_message_template}" ]]; then
593	action_message="$(eval echo -n "${action_message_template}")"	1019	eval "action_message=\"${action_message_template}\""
594	else	1020	else
595	action_message="${action} of ${CATEGORY}/${PF} with Python ${PYTHON_ABI}..."	1021	action_message="${action} of ${CATEGORY}/${PF} with $(python_get_implementation_and_version)..."
596	fi	1022	fi
597	echo " ${GREEN}*${NORMAL} ${BLUE}${action_message}${NORMAL}"	1023	echo " ${_GREEN}*${_NORMAL} ${_BLUE}${action_message}${_NORMAL}"
598	fi	1024	fi
599		1025
600	if [[ "${separate_build_dirs}" == "1" ]]; then	1026	if [[ "${separate_build_dirs}" == "1" ]]; then
601	if [[ -n "${source_dir}" ]]; then	1027	if [[ -n "${source_dir}" ]]; then
602	export BUILDDIR="${S}/${source_dir}-${PYTHON_ABI}"	1028	export BUILDDIR="${S}/${source_dir}-${PYTHON_ABI}"
…		…
616	EPYTHON="$(PYTHON)" nonfatal "${function}" "$@"	1042	EPYTHON="$(PYTHON)" nonfatal "${function}" "$@"
617	else	1043	else
618	EPYTHON="$(PYTHON)" "${function}" "$@"	1044	EPYTHON="$(PYTHON)" "${function}" "$@"
619	fi	1045	fi
620		1046
621	if [[ "$?" != "0" ]]; then	1047	return_code="$?"
		1048
		1049	_python_restore_flags
		1050
		1051	if [[ "${return_code}" -ne 0 ]]; then
622	if [[ -n "${failure_message_template}" ]]; then	1052	if [[ -n "${failure_message_template}" ]]; then
623	failure_message="$(eval echo -n "${failure_message_template}")"	1053	eval "failure_message=\"${failure_message_template}\""
624	else	1054	else
625	failure_message="${action} failed with Python ${PYTHON_ABI} in ${function}() function"	1055	failure_message="${action} failed with $(python_get_implementation_and_version) in ${function}() function"
626	fi	1056	fi
627		1057
628	if [[ "${nonfatal}" == "1" ]]; then	1058	if [[ "${nonfatal}" == "1" ]]; then
629	if [[ "${quiet}" == "0" ]]; then	1059	if [[ "${quiet}" == "0" ]]; then
630	ewarn "${RED}${failure_message}${NORMAL}"	1060	ewarn "${failure_message}"
631	fi	1061	fi
632	elif has "${PYTHON_ABI}" ${FAILURE_TOLERANT_PYTHON_ABIS}; then	1062	elif [[ "${final_ABI}" == "0" ]] && has "${PYTHON_ABI}" ${FAILURE_TOLERANT_PYTHON_ABIS}; then
633	if [[ "${EBUILD_PHASE}" != "test" ]] \|\| ! has test-fail-continue ${FEATURES}; then	1063	if [[ "${EBUILD_PHASE}" != "test" ]] \|\| ! has test-fail-continue ${FEATURES}; then
634	local enabled_PYTHON_ABIS= other_PYTHON_ABI	1064	local enabled_PYTHON_ABIS= other_PYTHON_ABI
635	for other_PYTHON_ABI in ${PYTHON_ABIS}; do	1065	for other_PYTHON_ABI in ${PYTHON_ABIS}; do
636	[[ "${other_PYTHON_ABI}" != "${PYTHON_ABI}" ]] && enabled_PYTHON_ABIS+="${enabled_PYTHON_ABIS:+ }${other_PYTHON_ABI}"	1066	[[ "${other_PYTHON_ABI}" != "${PYTHON_ABI}" ]] && enabled_PYTHON_ABIS+="${enabled_PYTHON_ABIS:+ }${other_PYTHON_ABI}"
637	done	1067	done
638	export PYTHON_ABIS="${enabled_PYTHON_ABIS}"	1068	export PYTHON_ABIS="${enabled_PYTHON_ABIS}"
639	fi	1069	fi
640	if [[ "${quiet}" == "0" ]]; then	1070	if [[ "${quiet}" == "0" ]]; then
641	ewarn "${RED}${failure_message}${NORMAL}"	1071	ewarn "${failure_message}"
642	fi	1072	fi
643	if [[ -z "${PYTHON_ABIS}" ]]; then	1073	if [[ -z "${PYTHON_ABIS}" ]]; then
644	die "${function}() function failed with all enabled versions of Python"	1074	die "${function}() function failed with all enabled Python ABIs"
645	fi	1075	fi
646	else	1076	else
647	die "${failure_message}"	1077	die "${failure_message}"
648	fi	1078	fi
649	fi	1079	fi
…		…
678	if [[ "${default_function}" == "1" ]]; then	1108	if [[ "${default_function}" == "1" ]]; then
679	unset -f python_default_function	1109	unset -f python_default_function
680	fi	1110	fi
681	}	1111	}
682		1112
683	# @FUNCTION: python_convert_shebangs	1113	# @FUNCTION: python_copy_sources
684	# @USAGE: [-q\|--quiet] [-r\|--recursive] [-x\|--only-executables] [--] <Python_version> <file\|directory> [files\|directories]	1114	# @USAGE: <directory="${S}"> [directory]
685	# @DESCRIPTION:	1115	# @DESCRIPTION:
686	# Convert shebangs in specified files. Directories can be specified only with --recursive option.	1116	# Copy unpacked sources of current package to separate build directory for each Python ABI.
687	python_convert_shebangs() {	1117	python_copy_sources() {
688	local argument file files=() only_executables="0" python_version quiet="0" recursive="0"	1118	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		1119	die "${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		1120	fi
689		1121
690	while (($#)); do	1122	_python_check_python_pkg_setup_execution
691	case "$1" in	1123
692	-r\|--recursive)	1124	local dir dirs=() PYTHON_ABI
693	recursive="1"
694	;;
695	-q\|--quiet)
696	quiet="1"
697	;;
698	-x\|--only-executables)
699	only_executables="1"
700	;;
701	--)
702	break
703	;;
704	-*)
705	die "${FUNCNAME}(): Unrecognized option '$1'"
706	;;
707	*)
708	break
709	;;
710	esac
711	shift
712	done
713		1125
714	if [[ "$#" -eq 0 ]]; then	1126	if [[ "$#" -eq 0 ]]; then
715	die "${FUNCNAME}(): Missing Python version and files or directories"	1127	if [[ "${WORKDIR}" == "${S}" ]]; then
716	elif [[ "$#" -eq 1 ]]; then	1128	die "${FUNCNAME}() cannot be used with current value of S variable"
717	die "${FUNCNAME}(): Missing files or directories"
718	fi
719
720	python_version="$1"
721	shift
722
723	for argument in "$@"; do
724	if [[ ! -e "${argument}" ]]; then
725	die "${FUNCNAME}(): '${argument}' does not exist"
726	elif [[ -f "${argument}" ]]; then
727	files+=("${argument}")
728	elif [[ -d "${argument}" ]]; then
729	if [[ "${recursive}" == "1" ]]; then
730	if [[ "${only_executables}" == "1" ]]; then
731	files+=($(find "${argument}" -perm /111 -type f))
732	else
733	files+=($(find "${argument}" -type f))
734	fi
735	else
736	die "${FUNCNAME}(): '${argument}' is not a regular file"
737	fi	1129	fi
		1130	dirs=("${S%/}")
738	else	1131	else
739	die "${FUNCNAME}(): '${argument}' is not a regular file or a directory"	1132	dirs=("$@")
740	fi	1133	fi
		1134
		1135	_python_calculate_PYTHON_ABIS
		1136	for PYTHON_ABI in ${PYTHON_ABIS}; do
		1137	for dir in "${dirs[@]}"; do
		1138	cp -pr "${dir}" "${dir}-${PYTHON_ABI}" > /dev/null \|\| die "Copying of sources failed"
741	done	1139	done
742
743	for file in "${files[@]}"; do
744	file="${file#./}"
745	[[ "${only_executables}" == "1" && ! -x "${file}" ]] && continue
746
747	if [[ "$(head -n1 "${file}")" =~ ^'#!'.*python ]]; then
748	if [[ "${quiet}" == "0" ]]; then
749	einfo "Converting shebang in '${file}'"
750	fi
751	sed -e "1s/python$[[:digit:]]\+\(\.[[:digit:]]\+$\?\)\?/python${python_version}/" -i "${file}" \|\| die "Conversion of shebang in '${file}' failed"
752
753	# Delete potential whitespace after "#!".
754	sed -e '1s/$^#!$[[:space:]]*/\1/' -i "${file}" \|\| die "sed '${file}' failed"
755	fi
756	done	1140	done
757	}	1141	}
758		1142
759	# @FUNCTION: python_generate_wrapper_scripts	1143	# @FUNCTION: python_generate_wrapper_scripts
760	# @USAGE: [-E\|--respect-EPYTHON] [-f\|--force] [-q\|--quiet] [--] <file> [files]	1144	# @USAGE: [-E\|--respect-EPYTHON] [-f\|--force] [-q\|--quiet] [--] <file> [files]
761	# @DESCRIPTION:	1145	# @DESCRIPTION:
762	# Generate wrapper scripts. Existing files are overwritten only with --force option.	1146	# Generate wrapper scripts. Existing files are overwritten only with --force option.
763	# If --respect-EPYTHON option is specified, then generated wrapper scripts will	1147	# If --respect-EPYTHON option is specified, then generated wrapper scripts will
764	# respect EPYTHON variable at run time.	1148	# respect EPYTHON variable at run time.
		1149	#
		1150	# This function can be used only in src_install() phase.
765	python_generate_wrapper_scripts() {	1151	python_generate_wrapper_scripts() {
		1152	if [[ "${EBUILD_PHASE}" != "install" ]]; then
		1153	die "${FUNCNAME}() can be used only in src_install() phase"
		1154	fi
		1155
		1156	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		1157	die "${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		1158	fi
		1159
		1160	_python_check_python_pkg_setup_execution
		1161	_python_initialize_prefix_variables
		1162
766	local eselect_python_option file force="0" quiet="0" PYTHON_ABI python2_enabled="0" python2_supported_versions python3_enabled="0" python3_supported_versions respect_EPYTHON="0"	1163	local eselect_python_option file force="0" quiet="0" PYTHON_ABI PYTHON_ABIS_list python2_enabled="0" python3_enabled="0" respect_EPYTHON="0"
767	python2_supported_versions="2.4 2.5 2.6 2.7"
768	python3_supported_versions="3.0 3.1 3.2"
769		1164
770	while (($#)); do	1165	while (($#)); do
771	case "$1" in	1166	case "$1" in
772	-E\|--respect-EPYTHON)	1167	-E\|--respect-EPYTHON)
773	respect_EPYTHON="1"	1168	respect_EPYTHON="1"
…		…
777	;;	1172	;;
778	-q\|--quiet)	1173	-q\|--quiet)
779	quiet="1"	1174	quiet="1"
780	;;	1175	;;
781	--)	1176	--)
		1177	shift
782	break	1178	break
783	;;	1179	;;
784	-*)	1180	-*)
785	die "${FUNCNAME}(): Unrecognized option '$1'"	1181	die "${FUNCNAME}(): Unrecognized option '$1'"
786	;;	1182	;;
…		…
793		1189
794	if [[ "$#" -eq 0 ]]; then	1190	if [[ "$#" -eq 0 ]]; then
795	die "${FUNCNAME}(): Missing arguments"	1191	die "${FUNCNAME}(): Missing arguments"
796	fi	1192	fi
797		1193
798	validate_PYTHON_ABIS	1194	_python_calculate_PYTHON_ABIS
799	for PYTHON_ABI in ${python2_supported_versions}; do	1195	for PYTHON_ABI in "${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}"; do
800	if has "${PYTHON_ABI}" ${PYTHON_ABIS}; then	1196	if has "${PYTHON_ABI}" ${PYTHON_ABIS}; then
801	python2_enabled="1"	1197	python2_enabled="1"
802	fi	1198	fi
803	done	1199	done
804	for PYTHON_ABI in ${python3_supported_versions}; do	1200	for PYTHON_ABI in "${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}"; do
805	if has "${PYTHON_ABI}" ${PYTHON_ABIS}; then	1201	if has "${PYTHON_ABI}" ${PYTHON_ABIS}; then
806	python3_enabled="1"	1202	python3_enabled="1"
807	fi	1203	fi
808	done	1204	done
809		1205
…		…
815	eselect_python_option="--python3"	1211	eselect_python_option="--python3"
816	else	1212	else
817	die "${FUNCNAME}(): Unsupported environment"	1213	die "${FUNCNAME}(): Unsupported environment"
818	fi	1214	fi
819		1215
		1216	PYTHON_ABIS_list="$("$(PYTHON -f)" -c "print(', '.join('\"%s\"' % x for x in reversed('${PYTHON_ABIS}'.split())))")"
		1217
820	for file in "$@"; do	1218	for file in "$@"; do
821	if [[ -f "${file}" && "${force}" == "0" ]]; then	1219	if [[ -f "${file}" && "${force}" == "0" ]]; then
822	die "${FUNCNAME}(): '$1' already exists"	1220	die "${FUNCNAME}(): '${file}' already exists"
823	fi	1221	fi
824		1222
825	if [[ "${quiet}" == "0" ]]; then	1223	if [[ "${quiet}" == "0" ]]; then
826	einfo "Generating '${file#${D%/}}' wrapper script"	1224	einfo "Generating '${file#${ED%/}}' wrapper script"
827	fi	1225	fi
828		1226
829	cat << EOF > "${file}"	1227	cat << EOF > "${file}"
830	#!/usr/bin/env python	1228	#!/usr/bin/env python
831	# Gentoo '${file##*/}' wrapper script	1229	# Gentoo '${file##*/}' wrapper script generated by python_generate_wrapper_scripts()
832		1230
833	import os	1231	import os
834	import re	1232	import re
835	import subprocess	1233	import subprocess
836	import sys	1234	import sys
837		1235
		1236	cpython_ABI_re = re.compile(r"^(\d+\.\d+)$")
		1237	jython_ABI_re = re.compile(r"^(\d+\.\d+)-jython$")
		1238	pypy_ABI_re = re.compile(r"^\d+\.\d+-pypy-(\d+\.\d+)$")
838	EPYTHON_re = re.compile(r"^python(\d+\.\d+)$")	1239	cpython_interpreter_re = re.compile(r"^python(\d+\.\d+)$")
		1240	jython_interpreter_re = re.compile(r"^jython(\d+\.\d+)$")
		1241	pypy_interpreter_re = re.compile(r"^pypy-c(\d+\.\d+)$")
		1242	cpython_shebang_re = re.compile(r"^#![ \t]*(?:${EPREFIX}/usr/bin/python\|(?:${EPREFIX})?/usr/bin/env[ \t]+(?:${EPREFIX}/usr/bin/)?python)")
		1243	python_shebang_options_re = re.compile(r"^#![ \t]*${EPREFIX}/usr/bin/(?:jython\|pypy-c\|python)(?:\d+(?:\.\d+)?)?[ \t]+(-\S)")
		1244	python_verification_output_re = re.compile("^GENTOO_PYTHON_TARGET_SCRIPT_PATH supported\n$")
		1245
		1246	pypy_versions_mapping = {
		1247	"1.5": "2.7"
		1248	}
		1249
		1250	def get_PYTHON_ABI(python_interpreter):
		1251	cpython_matched = cpython_interpreter_re.match(python_interpreter)
		1252	jython_matched = jython_interpreter_re.match(python_interpreter)
		1253	pypy_matched = pypy_interpreter_re.match(python_interpreter)
		1254	if cpython_matched is not None:
		1255	PYTHON_ABI = cpython_matched.group(1)
		1256	elif jython_matched is not None:
		1257	PYTHON_ABI = jython_matched.group(1) + "-jython"
		1258	elif pypy_matched is not None:
		1259	PYTHON_ABI = pypy_versions_mapping[pypy_matched.group(1)] + "-pypy-" + pypy_matched.group(1)
		1260	else:
		1261	PYTHON_ABI = None
		1262	return PYTHON_ABI
		1263
		1264	def get_python_interpreter(PYTHON_ABI):
		1265	cpython_matched = cpython_ABI_re.match(PYTHON_ABI)
		1266	jython_matched = jython_ABI_re.match(PYTHON_ABI)
		1267	pypy_matched = pypy_ABI_re.match(PYTHON_ABI)
		1268	if cpython_matched is not None:
		1269	python_interpreter = "python" + cpython_matched.group(1)
		1270	elif jython_matched is not None:
		1271	python_interpreter = "jython" + jython_matched.group(1)
		1272	elif pypy_matched is not None:
		1273	python_interpreter = "pypy-c" + pypy_matched.group(1)
		1274	else:
		1275	python_interpreter = None
		1276	return python_interpreter
839		1277
840	EOF	1278	EOF
841	if [[ "$?" != "0" ]]; then	1279	if [[ "$?" != "0" ]]; then
842	die "${FUNCNAME}(): Generation of '$1' failed"	1280	die "${FUNCNAME}(): Generation of '$1' failed"
843	fi	1281	fi
844	if [[ "${respect_EPYTHON}" == "1" ]]; then	1282	if [[ "${respect_EPYTHON}" == "1" ]]; then
845	cat << EOF >> "${file}"	1283	cat << EOF >> "${file}"
846	EPYTHON = os.environ.get("EPYTHON")	1284	python_interpreter = os.environ.get("EPYTHON")
847	if EPYTHON:	1285	if python_interpreter:
848	EPYTHON_matched = EPYTHON_re.match(EPYTHON)	1286	PYTHON_ABI = get_PYTHON_ABI(python_interpreter)
849	if EPYTHON_matched:	1287	if PYTHON_ABI is None:
850	PYTHON_ABI = EPYTHON_matched.group(1)
851	else:
852	sys.stderr.write("EPYTHON variable has unrecognized value '%s'\n" % EPYTHON)	1288	sys.stderr.write("%s: EPYTHON variable has unrecognized value '%s'\n" % (sys.argv[0], python_interpreter))
853	sys.exit(1)	1289	sys.exit(1)
854	else:	1290	else:
855	try:	1291	try:
		1292	environment = os.environ.copy()
		1293	environment["ROOT"] = "/"
856	eselect_process = subprocess.Popen(["/usr/bin/eselect", "python", "show"${eselect_python_option:+, $(echo "\"")}${eselect_python_option}${eselect_python_option:+$(echo "\"")}], stdout=subprocess.PIPE)	1294	eselect_process = subprocess.Popen(["${EPREFIX}/usr/bin/eselect", "python", "show"${eselect_python_option:+, $(echo "\"")}${eselect_python_option}${eselect_python_option:+$(echo "\"")}], env=environment, stdout=subprocess.PIPE)
857	if eselect_process.wait() != 0:	1295	if eselect_process.wait() != 0:
858	raise ValueError	1296	raise ValueError
859	except (OSError, ValueError):	1297	except (OSError, ValueError):
860	sys.stderr.write("Execution of 'eselect python show${eselect_python_option:+ }${eselect_python_option}' failed\n")	1298	sys.stderr.write("%s: Execution of 'eselect python show${eselect_python_option:+ }${eselect_python_option}' failed\n" % sys.argv[0])
861	sys.exit(1)	1299	sys.exit(1)
862		1300
863	eselect_output = eselect_process.stdout.read()	1301	python_interpreter = eselect_process.stdout.read()
864	if not isinstance(eselect_output, str):	1302	if not isinstance(python_interpreter, str):
865	# Python 3	1303	# Python 3
866	eselect_output = eselect_output.decode()	1304	python_interpreter = python_interpreter.decode()
		1305	python_interpreter = python_interpreter.rstrip("\n")
867		1306
868	EPYTHON_matched = EPYTHON_re.match(eselect_output)	1307	PYTHON_ABI = get_PYTHON_ABI(python_interpreter)
869	if EPYTHON_matched:	1308	if PYTHON_ABI is None:
870	PYTHON_ABI = EPYTHON_matched.group(1)
871	else:
872	sys.stderr.write("'eselect python show${eselect_python_option:+ }${eselect_python_option}' printed unrecognized value '%s" % eselect_output)	1309	sys.stderr.write("%s: 'eselect python show${eselect_python_option:+ }${eselect_python_option}' printed unrecognized value '%s'\n" % (sys.argv[0], python_interpreter))
873	sys.exit(1)	1310	sys.exit(1)
874	EOF
875	if [[ "$?" != "0" ]]; then
876	die "${FUNCNAME}(): Generation of '$1' failed"
877	fi
878	else
879	cat << EOF >> "${file}"
880	try:
881	eselect_process = subprocess.Popen(["/usr/bin/eselect", "python", "show"${eselect_python_option:+, $(echo "\"")}${eselect_python_option}${eselect_python_option:+$(echo "\"")}], stdout=subprocess.PIPE)
882	if eselect_process.wait() != 0:
883	raise ValueError
884	except (OSError, ValueError):
885	sys.stderr.write("Execution of 'eselect python show${eselect_python_option:+ }${eselect_python_option}' failed\n")
886	sys.exit(1)
887		1311
888	eselect_output = eselect_process.stdout.read()	1312	wrapper_script_path = os.path.realpath(sys.argv[0])
889	if not isinstance(eselect_output, str):	1313	target_executable_path = "%s-%s" % (wrapper_script_path, PYTHON_ABI)
890	# Python 3	1314	if not os.path.exists(target_executable_path):
891	eselect_output = eselect_output.decode()	1315	sys.stderr.write("%s: '%s' does not exist\n" % (sys.argv[0], target_executable_path))
892
893	EPYTHON_matched = EPYTHON_re.match(eselect_output)
894	if EPYTHON_matched:
895	PYTHON_ABI = EPYTHON_matched.group(1)
896	else:
897	sys.stderr.write("'eselect python show${eselect_python_option:+ }${eselect_python_option}' printed unrecognized value '%s" % eselect_output)
898	sys.exit(1)	1316	sys.exit(1)
899	EOF	1317	EOF
900	if [[ "$?" != "0" ]]; then	1318	if [[ "$?" != "0" ]]; then
901	die "${FUNCNAME}(): Generation of '$1' failed"	1319	die "${FUNCNAME}(): Generation of '$1' failed"
902	fi	1320	fi
		1321	else
		1322	cat << EOF >> "${file}"
		1323	try:
		1324	environment = os.environ.copy()
		1325	environment["ROOT"] = "/"
		1326	eselect_process = subprocess.Popen(["${EPREFIX}/usr/bin/eselect", "python", "show"${eselect_python_option:+, $(echo "\"")}${eselect_python_option}${eselect_python_option:+$(echo "\"")}], env=environment, stdout=subprocess.PIPE)
		1327	if eselect_process.wait() != 0:
		1328	raise ValueError
		1329	except (OSError, ValueError):
		1330	sys.stderr.write("%s: Execution of 'eselect python show${eselect_python_option:+ }${eselect_python_option}' failed\n" % sys.argv[0])
		1331	sys.exit(1)
		1332
		1333	python_interpreter = eselect_process.stdout.read()
		1334	if not isinstance(python_interpreter, str):
		1335	# Python 3
		1336	python_interpreter = python_interpreter.decode()
		1337	python_interpreter = python_interpreter.rstrip("\n")
		1338
		1339	PYTHON_ABI = get_PYTHON_ABI(python_interpreter)
		1340	if PYTHON_ABI is None:
		1341	sys.stderr.write("%s: 'eselect python show${eselect_python_option:+ }${eselect_python_option}' printed unrecognized value '%s'\n" % (sys.argv[0], python_interpreter))
		1342	sys.exit(1)
		1343
		1344	wrapper_script_path = os.path.realpath(sys.argv[0])
		1345	for PYTHON_ABI in [PYTHON_ABI, ${PYTHON_ABIS_list}]:
		1346	target_executable_path = "%s-%s" % (wrapper_script_path, PYTHON_ABI)
		1347	if os.path.exists(target_executable_path):
		1348	break
		1349	else:
		1350	sys.stderr.write("%s: No target script exists for '%s'\n" % (sys.argv[0], wrapper_script_path))
		1351	sys.exit(1)
		1352
		1353	python_interpreter = get_python_interpreter(PYTHON_ABI)
		1354	if python_interpreter is None:
		1355	sys.stderr.write("%s: Unrecognized Python ABI '%s'\n" % (sys.argv[0], PYTHON_ABI))
		1356	sys.exit(1)
		1357	EOF
		1358	if [[ "$?" != "0" ]]; then
		1359	die "${FUNCNAME}(): Generation of '$1' failed"
		1360	fi
903	fi	1361	fi
904	cat << EOF >> "${file}"	1362	cat << EOF >> "${file}"
905		1363
		1364	target_executable = open(target_executable_path, "rb")
		1365	target_executable_first_line = target_executable.readline()
		1366	target_executable.close()
		1367	if not isinstance(target_executable_first_line, str):
		1368	# Python 3
		1369	target_executable_first_line = target_executable_first_line.decode("utf_8", "replace")
		1370
		1371	options = []
		1372	python_shebang_options_matched = python_shebang_options_re.match(target_executable_first_line)
		1373	if python_shebang_options_matched is not None:
		1374	options = [python_shebang_options_matched.group(1)]
		1375
		1376	cpython_shebang_matched = cpython_shebang_re.match(target_executable_first_line)
		1377
		1378	if cpython_shebang_matched is not None:
		1379	try:
		1380	python_interpreter_path = "${EPREFIX}/usr/bin/%s" % python_interpreter
		1381	os.environ["GENTOO_PYTHON_TARGET_SCRIPT_PATH_VERIFICATION"] = "1"
		1382	python_verification_process = subprocess.Popen([python_interpreter_path, "-c", "pass"], stdout=subprocess.PIPE)
		1383	del os.environ["GENTOO_PYTHON_TARGET_SCRIPT_PATH_VERIFICATION"]
		1384	if python_verification_process.wait() != 0:
		1385	raise ValueError
		1386
		1387	python_verification_output = python_verification_process.stdout.read()
		1388	if not isinstance(python_verification_output, str):
		1389	# Python 3
		1390	python_verification_output = python_verification_output.decode()
		1391
		1392	if not python_verification_output_re.match(python_verification_output):
		1393	raise ValueError
		1394
		1395	if cpython_interpreter_re.match(python_interpreter) is not None:
906	os.environ["PYTHON_PROCESS_NAME"] = sys.argv[0]	1396	os.environ["GENTOO_PYTHON_PROCESS_NAME"] = os.path.basename(sys.argv[0])
907	target_executable = "%s-%s" % (os.path.realpath(sys.argv[0]), PYTHON_ABI)	1397	os.environ["GENTOO_PYTHON_WRAPPER_SCRIPT_PATH"] = sys.argv[0]
908	if not os.path.exists(target_executable):	1398	os.environ["GENTOO_PYTHON_TARGET_SCRIPT_PATH"] = target_executable_path
909	sys.stderr.write("'%s' does not exist\n" % target_executable)
910	sys.exit(1)
911		1399
		1400	if hasattr(os, "execv"):
		1401	os.execv(python_interpreter_path, [python_interpreter_path] + options + sys.argv)
		1402	else:
		1403	sys.exit(subprocess.Popen([python_interpreter_path] + options + sys.argv).wait())
		1404	except (KeyboardInterrupt, SystemExit):
		1405	raise
		1406	except:
		1407	pass
		1408	for variable in ("GENTOO_PYTHON_PROCESS_NAME", "GENTOO_PYTHON_WRAPPER_SCRIPT_PATH", "GENTOO_PYTHON_TARGET_SCRIPT_PATH", "GENTOO_PYTHON_TARGET_SCRIPT_PATH_VERIFICATION"):
		1409	if variable in os.environ:
		1410	del os.environ[variable]
		1411
		1412	if hasattr(os, "execv"):
912	os.execv(target_executable, sys.argv)	1413	os.execv(target_executable_path, sys.argv)
		1414	else:
		1415	sys.exit(subprocess.Popen([target_executable_path] + sys.argv[1:]).wait())
913	EOF	1416	EOF
914	if [[ "$?" != "0" ]]; then	1417	if [[ "$?" != "0" ]]; then
915	die "${FUNCNAME}(): Generation of '$1' failed"	1418	die "${FUNCNAME}(): Generation of '$1' failed"
916	fi	1419	fi
917	fperms +x "${file#${D%/}}" \|\| die "fperms '${file}' failed"	1420	fperms +x "${file#${ED%/}}" \|\| die "fperms '${file}' failed"
918	done	1421	done
919	}	1422	}
920		1423
921	# @ECLASS-VARIABLE: PYTHON_USE_WITH	1424	# @ECLASS-VARIABLE: PYTHON_VERSIONED_SCRIPTS
922	# @DESCRIPTION:	1425	# @DESCRIPTION:
923	# Set this to a space separated list of use flags	1426	# Array of regular expressions of paths to versioned Python scripts.
924	# the python slot in use must be built with.	1427	# Python scripts in /usr/bin and /usr/sbin are versioned by default.
925		1428
926	# @ECLASS-VARIABLE: PYTHON_USE_WITH_OR	1429	# @ECLASS-VARIABLE: PYTHON_VERSIONED_EXECUTABLES
927	# @DESCRIPTION:	1430	# @DESCRIPTION:
928	# Set this to a space separated list of use flags	1431	# Array of regular expressions of paths to versioned executables (including Python scripts).
929	# of which one must be turned on for the slot of
930	# in use.
931		1432
932	# @ECLASS-VARIABLE: PYTHON_USE_WITH_OPT	1433	# @ECLASS-VARIABLE: PYTHON_NONVERSIONED_EXECUTABLES
933	# @DESCRIPTION:	1434	# @DESCRIPTION:
934	# Set this if you need to make either PYTHON_USE_WITH or	1435	# Array of regular expressions of paths to nonversioned executables (including Python scripts).
935	# PYTHON_USE_WITH_OR atoms conditional under a use flag.
936		1436
937	# @FUNCTION: python_pkg_setup	1437	# @FUNCTION: python_merge_intermediate_installation_images
		1438	# @USAGE: [-q\|--quiet] [--] <intermediate_installation_images_directory>
938	# @DESCRIPTION:	1439	# @DESCRIPTION:
939	# Makes sure PYTHON_USE_WITH or PYTHON_USE_WITH_OR listed use flags	1440	# Merge intermediate installation images into installation image.
940	# are respected. Only exported if one of those variables is set.	1441	#
941	if ! has "${EAPI:-0}" 0 1 && [[ -n ${PYTHON_USE_WITH} \|\| -n ${PYTHON_USE_WITH_OR} ]]; then	1442	# This function can be used only in src_install() phase.
942	python_pkg_setup() {	1443	python_merge_intermediate_installation_images() {
943	python_pkg_setup_fail() {	1444	if [[ "${EBUILD_PHASE}" != "install" ]]; then
944	eerror "${1}"	1445	die "${FUNCNAME}() can be used only in src_install() phase"
945	die "${1}"	1446	fi
946	}
947		1447
948	[[ ${PYTHON_USE_WITH_OPT} ]] && use !${PYTHON_USE_WITH_OPT} && return	1448	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		1449	die "${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		1450	fi
949		1451
950	python_pkg_setup_check_USE_flags() {	1452	_python_check_python_pkg_setup_execution
951	local pyatom use	1453	_python_initialize_prefix_variables
		1454
		1455	local absolute_file b file files=() intermediate_installation_images_directory PYTHON_ABI quiet="0" regex shebang version_executable wrapper_scripts=() wrapper_scripts_set=()
		1456
		1457	while (($#)); do
		1458	case "$1" in
		1459	-q\|--quiet)
		1460	quiet="1"
		1461	;;
		1462	--)
		1463	shift
		1464	break
		1465	;;
		1466	-*)
		1467	die "${FUNCNAME}(): Unrecognized option '$1'"
		1468	;;
		1469	*)
		1470	break
		1471	;;
		1472	esac
		1473	shift
		1474	done
		1475
		1476	if [[ "$#" -ne 1 ]]; then
		1477	die "${FUNCNAME}() requires 1 argument"
		1478	fi
		1479
		1480	intermediate_installation_images_directory="$1"
		1481
		1482	if [[ ! -d "${intermediate_installation_images_directory}" ]]; then
		1483	die "${FUNCNAME}(): Intermediate installation images directory '${intermediate_installation_images_directory}' does not exist"
		1484	fi
		1485
		1486	_python_calculate_PYTHON_ABIS
		1487	if [[ "$(PYTHON -f --ABI)" == 3.* ]]; then
		1488	b="b"
		1489	fi
		1490
		1491	while read -d $'\0' -r file; do
		1492	files+=("${file}")
		1493	done < <("$(PYTHON -f)" -c \
		1494	"import os
		1495	import sys
		1496
		1497	if hasattr(sys.stdout, 'buffer'):
		1498	# Python 3
		1499	stdout = sys.stdout.buffer
		1500	else:
		1501	# Python 2
		1502	stdout = sys.stdout
		1503
		1504	files_set = set()
		1505
		1506	os.chdir(${b}'${intermediate_installation_images_directory}')
		1507
		1508	for PYTHON_ABI in ${b}'${PYTHON_ABIS}'.split():
		1509	for root, dirs, files in os.walk(PYTHON_ABI + ${b}'${EPREFIX}'):
		1510	root = root[len(PYTHON_ABI + ${b}'${EPREFIX}')+1:]
		1511	files_set.update(root + ${b}'/' + file for file in files)
		1512
		1513	for file in sorted(files_set):
		1514	stdout.write(file)
		1515	stdout.write(${b}'\x00')" \|\| die "${FUNCNAME}(): Failure of extraction of files in intermediate installation images")
		1516
		1517	for PYTHON_ABI in ${PYTHON_ABIS}; do
		1518	if [[ ! -d "${intermediate_installation_images_directory}/${PYTHON_ABI}" ]]; then
		1519	die "${FUNCNAME}(): Intermediate installation image for Python ABI '${PYTHON_ABI}' does not exist"
		1520	fi
		1521
		1522	pushd "${intermediate_installation_images_directory}/${PYTHON_ABI}${EPREFIX}" > /dev/null \|\| die "pushd failed"
		1523
		1524	for file in "${files[@]}"; do
		1525	version_executable="0"
		1526	for regex in "/usr/bin/." "/usr/sbin/." "${PYTHON_VERSIONED_SCRIPTS[@]}"; do
		1527	if [[ "/${file}" =~ ^${regex}$ ]]; then
		1528	version_executable="1"
		1529	break
		1530	fi
		1531	done
		1532	for regex in "${PYTHON_VERSIONED_EXECUTABLES[@]}"; do
		1533	if [[ "/${file}" =~ ^${regex}$ ]]; then
		1534	version_executable="2"
		1535	break
		1536	fi
		1537	done
		1538	if [[ "${version_executable}" != "0" ]]; then
		1539	for regex in "${PYTHON_NONVERSIONED_EXECUTABLES[@]}"; do
		1540	if [[ "/${file}" =~ ^${regex}$ ]]; then
		1541	version_executable="0"
		1542	break
		1543	fi
		1544	done
		1545	fi
		1546
		1547	[[ "${version_executable}" == "0" ]] && continue
		1548
952	if [[ -n "${PYTHON_ABI}" ]]; then	1549	if [[ -L "${file}" ]]; then
953	pyatom="dev-lang/python:${PYTHON_ABI}"	1550	absolute_file="$(readlink "${file}")"
		1551	if [[ "${absolute_file}" == /* ]]; then
		1552	absolute_file="${intermediate_installation_images_directory}/${PYTHON_ABI}${EPREFIX}/${absolute_file##/}"
		1553	else
		1554	if [[ "${file}" == / ]]; then
		1555	absolute_file="${intermediate_installation_images_directory}/${PYTHON_ABI}${EPREFIX}/${file%/*}/${absolute_file}"
		1556	else
		1557	absolute_file="${intermediate_installation_images_directory}/${PYTHON_ABI}${EPREFIX}/${absolute_file}"
		1558	fi
		1559	fi
954	else	1560	else
955	pyatom="dev-lang/python:$(PYTHON -A --ABI)"	1561	absolute_file="${intermediate_installation_images_directory}/${PYTHON_ABI}${EPREFIX}/${file}"
956	fi
957
958	for use in ${PYTHON_USE_WITH}; do
959	if ! has_version "${pyatom}[${use}]"; then
960	python_pkg_setup_fail "Please rebuild ${pyatom} with the following USE flags enabled: ${PYTHON_USE_WITH}"
961	fi	1562	fi
		1563
		1564	[[ ! -x "${absolute_file}" ]] && continue
		1565
		1566	shebang="$(head -n1 "${absolute_file}")" \|\| die "Extraction of shebang from '${absolute_file}' failed"
		1567
		1568	if [[ "${version_executable}" == "2" ]]; then
		1569	wrapper_scripts+=("${ED}${file}")
		1570	elif [[ "${version_executable}" == "1" ]]; then
		1571	if [[ "${shebang}" =~ ${_PYTHON_SHEBANG_BASE_PART_REGEX}([[:digit:]]+(\.[[:digit:]]+)?)?($\|[[:space:]]+) ]]; then
		1572	wrapper_scripts+=("${ED}${file}")
		1573	else
		1574	version_executable="0"
		1575	fi
		1576	fi
		1577
		1578	[[ "${version_executable}" == "0" ]] && continue
		1579
		1580	if [[ -e "${file}-${PYTHON_ABI}" ]]; then
		1581	die "${FUNCNAME}(): '${EPREFIX}/${file}-${PYTHON_ABI}' already exists"
		1582	fi
		1583
		1584	mv "${file}" "${file}-${PYTHON_ABI}" \|\| die "Renaming of '${file}' failed"
		1585
		1586	if [[ "${shebang}" =~ ${_PYTHON_SHEBANG_BASE_PART_REGEX}[[:digit:]]*($\|[[:space:]]+) ]]; then
		1587	if [[ -L "${file}-${PYTHON_ABI}" ]]; then
		1588	python_convert_shebangs $([[ "${quiet}" == "1" ]] && echo --quiet) "${PYTHON_ABI}" "${absolute_file}"
		1589	else
		1590	python_convert_shebangs $([[ "${quiet}" == "1" ]] && echo --quiet) "${PYTHON_ABI}" "${file}-${PYTHON_ABI}"
		1591	fi
		1592	fi
962	done	1593	done
963		1594
964	for use in ${PYTHON_USE_WITH_OR}; do	1595	popd > /dev/null \|\| die "popd failed"
965	if has_version "${pyatom}[${use}]"; then
966	return
967	fi
968	done
969		1596
970	if [[ ${PYTHON_USE_WITH_OR} ]]; then	1597	if ROOT="/" has_version sys-apps/coreutils; then
971	python_pkg_setup_fail "Please rebuild ${pyatom} with at least one of the following USE flags enabled: ${PYTHON_USE_WITH_OR}"	1598	cp -fr --preserve=all --no-preserve=context "${intermediate_installation_images_directory}/${PYTHON_ABI}/"* "${D}" \|\| die "Merging of intermediate installation image for Python ABI '${PYTHON_ABI} into installation image failed"
972	fi
973	}
974
975	if ! has "${EAPI:-0}" 0 1 2 \|\| [[ -n "${SUPPORT_PYTHON_ABIS}" ]]; then
976	python_execute_function -q python_pkg_setup_check_USE_flags
977	else	1599	else
978	python_pkg_setup_check_USE_flags	1600	cp -fpr "${intermediate_installation_images_directory}/${PYTHON_ABI}/"* "${D}" \|\| die "Merging of intermediate installation image for Python ABI '${PYTHON_ABI} into installation image failed"
		1601	fi
		1602	done
		1603
		1604	rm -fr "${intermediate_installation_images_directory}"
		1605
		1606	if [[ "${#wrapper_scripts[@]}" -ge 1 ]]; then
		1607	rm -f "${T}/python_wrapper_scripts"
		1608
		1609	for file in "${wrapper_scripts[@]}"; do
		1610	echo -n "${file}" >> "${T}/python_wrapper_scripts"
		1611	echo -en "\x00" >> "${T}/python_wrapper_scripts"
		1612	done
		1613
		1614	while read -d $'\0' -r file; do
		1615	wrapper_scripts_set+=("${file}")
		1616	done < <("$(PYTHON -f)" -c \
		1617	"import sys
		1618
		1619	if hasattr(sys.stdout, 'buffer'):
		1620	# Python 3
		1621	stdout = sys.stdout.buffer
		1622	else:
		1623	# Python 2
		1624	stdout = sys.stdout
		1625
		1626	files = set(open('${T}/python_wrapper_scripts', 'rb').read().rstrip(${b}'\x00').split(${b}'\x00'))
		1627
		1628	for file in sorted(files):
		1629	stdout.write(file)
		1630	stdout.write(${b}'\x00')" \|\| die "${FUNCNAME}(): Failure of extraction of set of wrapper scripts")
		1631
		1632	python_generate_wrapper_scripts $([[ "${quiet}" == "1" ]] && echo --quiet) "${wrapper_scripts_set[@]}"
		1633	fi
		1634	}
		1635
		1636	# ================================================================================================
		1637	# ========= FUNCTIONS FOR PACKAGES NOT SUPPORTING INSTALLATION FOR MULTIPLE PYTHON ABIS ==========
		1638	# ================================================================================================
		1639
		1640	unset EPYTHON PYTHON_ABI
		1641
		1642	# @FUNCTION: python_set_active_version
		1643	# @USAGE: <Python_ABI\|2\|3>
		1644	# @DESCRIPTION:
		1645	# Set locally active version of Python.
		1646	# If Python_ABI argument is specified, then version of Python corresponding to Python_ABI is used.
		1647	# If 2 argument is specified, then active version of CPython 2 is used.
		1648	# If 3 argument is specified, then active version of CPython 3 is used.
		1649	#
		1650	# This function can be used only in pkg_setup() phase.
		1651	python_set_active_version() {
		1652	if [[ "${EBUILD_PHASE}" != "setup" ]]; then
		1653	die "${FUNCNAME}() can be used only in pkg_setup() phase"
		1654	fi
		1655
		1656	if _python_package_supporting_installation_for_multiple_python_abis; then
		1657	die "${FUNCNAME}() cannot be used in ebuilds of packages supporting installation for multiple Python ABIs"
		1658	fi
		1659
		1660	if [[ "$#" -ne 1 ]]; then
		1661	die "${FUNCNAME}() requires 1 argument"
		1662	fi
		1663
		1664	_python_initial_sanity_checks
		1665
		1666	if [[ -z "${PYTHON_ABI}" ]]; then
		1667	if [[ -n "$(_python_get_implementation --ignore-invalid "$1")" ]]; then
		1668	# PYTHON_ABI variable is intended to be used only in ebuilds/eclasses,
		1669	# so it does not need to be exported to subprocesses.
		1670	PYTHON_ABI="$1"
		1671	if ! _python_implementation && ! has_version "$(python_get_implementational_package)"; then
		1672	die "${FUNCNAME}(): '$(python_get_implementational_package)' is not installed"
979	fi	1673	fi
		1674	export EPYTHON="$(PYTHON "$1")"
		1675	elif [[ "$1" == "2" ]]; then
		1676	if ! _python_implementation && ! has_version "=dev-lang/python-2*"; then
		1677	die "${FUNCNAME}(): '=dev-lang/python-2*' is not installed"
		1678	fi
		1679	export EPYTHON="$(PYTHON -2)"
		1680	PYTHON_ABI="${EPYTHON#python}"
		1681	PYTHON_ABI="${PYTHON_ABI%%-*}"
		1682	elif [[ "$1" == "3" ]]; then
		1683	if ! _python_implementation && ! has_version "=dev-lang/python-3*"; then
		1684	die "${FUNCNAME}(): '=dev-lang/python-3*' is not installed"
		1685	fi
		1686	export EPYTHON="$(PYTHON -3)"
		1687	PYTHON_ABI="${EPYTHON#python}"
		1688	PYTHON_ABI="${PYTHON_ABI%%-*}"
		1689	else
		1690	die "${FUNCNAME}(): Unrecognized argument '$1'"
		1691	fi
		1692	fi
		1693
		1694	_python_final_sanity_checks
		1695
		1696	# python-updater checks PYTHON_REQUESTED_ACTIVE_VERSION variable.
		1697	PYTHON_REQUESTED_ACTIVE_VERSION="$1"
		1698	}
		1699
		1700	# @FUNCTION: python_need_rebuild
		1701	# @DESCRIPTION:
		1702	# Mark current package for rebuilding by python-updater after
		1703	# switching of active version of Python.
		1704	python_need_rebuild() {
		1705	if _python_package_supporting_installation_for_multiple_python_abis; then
		1706	die "${FUNCNAME}() cannot be used in ebuilds of packages supporting installation for multiple Python ABIs"
		1707	fi
		1708
		1709	_python_check_python_pkg_setup_execution
		1710
		1711	if [[ "$#" -ne 0 ]]; then
		1712	die "${FUNCNAME}() does not accept arguments"
		1713	fi
		1714
		1715	export PYTHON_NEED_REBUILD="$(PYTHON --ABI)"
		1716	}
		1717
		1718	# ================================================================================================
		1719	# ======================================= GETTER FUNCTIONS =======================================
		1720	# ================================================================================================
		1721
		1722	_PYTHON_ABI_EXTRACTION_COMMAND=\
		1723	'import platform
		1724	import sys
		1725	sys.stdout.write(".".join(str(x) for x in sys.version_info[:2]))
		1726	if platform.system()[:4] == "Java":
		1727	sys.stdout.write("-jython")
		1728	elif hasattr(platform, "python_implementation") and platform.python_implementation() == "PyPy":
		1729	sys.stdout.write("-pypy-" + ".".join(str(x) for x in sys.pypy_version_info[:2]))'
		1730
		1731	_python_get_implementation() {
		1732	local ignore_invalid="0"
		1733
		1734	while (($#)); do
		1735	case "$1" in
		1736	--ignore-invalid)
		1737	ignore_invalid="1"
		1738	;;
		1739	--)
		1740	shift
		1741	break
		1742	;;
		1743	-*)
		1744	die "${FUNCNAME}(): Unrecognized option '$1'"
		1745	;;
		1746	*)
		1747	break
		1748	;;
		1749	esac
		1750	shift
		1751	done
		1752
		1753	if [[ "$#" -ne 1 ]]; then
		1754	die "${FUNCNAME}() requires 1 argument"
		1755	fi
		1756
		1757	if [[ "$1" =~ ^[[:digit:]]+\.[[:digit:]]+$ ]]; then
		1758	echo "CPython"
		1759	elif [[ "$1" =~ ^[[:digit:]]+\.[[:digit:]]+-jython$ ]]; then
		1760	echo "Jython"
		1761	elif [[ "$1" =~ ^[[:digit:]]+\.[[:digit:]]+-pypy-[[:digit:]]+\.[[:digit:]]+$ ]]; then
		1762	echo "PyPy"
		1763	else
		1764	if [[ "${ignore_invalid}" == "0" ]]; then
		1765	die "${FUNCNAME}(): Unrecognized Python ABI '$1'"
		1766	fi
		1767	fi
		1768	}
		1769
		1770	# @FUNCTION: PYTHON
		1771	# @USAGE: [-2] [-3] [--ABI] [-a\|--absolute-path] [-f\|--final-ABI] [--] <Python_ABI="${PYTHON_ABI}">
		1772	# @DESCRIPTION:
		1773	# Print filename of Python interpreter for specified Python ABI. If Python_ABI argument
		1774	# is ommitted, then PYTHON_ABI environment variable must be set and is used.
		1775	# If -2 option is specified, then active version of CPython 2 is used.
		1776	# If -3 option is specified, then active version of CPython 3 is used.
		1777	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		1778	# -2, -3 and --final-ABI options and Python_ABI argument cannot be specified simultaneously.
		1779	# If --ABI option is specified, then only specified Python ABI is printed instead of
		1780	# filename of Python interpreter.
		1781	# If --absolute-path option is specified, then absolute path to Python interpreter is printed.
		1782	# --ABI and --absolute-path options cannot be specified simultaneously.
		1783	PYTHON() {
		1784	_python_check_python_pkg_setup_execution
		1785
		1786	local ABI_output="0" absolute_path_output="0" final_ABI="0" PYTHON_ABI="${PYTHON_ABI}" python_interpreter python2="0" python3="0"
		1787
		1788	while (($#)); do
		1789	case "$1" in
		1790	-2)
		1791	python2="1"
		1792	;;
		1793	-3)
		1794	python3="1"
		1795	;;
		1796	--ABI)
		1797	ABI_output="1"
		1798	;;
		1799	-a\|--absolute-path)
		1800	absolute_path_output="1"
		1801	;;
		1802	-f\|--final-ABI)
		1803	final_ABI="1"
		1804	;;
		1805	--)
		1806	shift
		1807	break
		1808	;;
		1809	-*)
		1810	die "${FUNCNAME}(): Unrecognized option '$1'"
		1811	;;
		1812	*)
		1813	break
		1814	;;
		1815	esac
		1816	shift
		1817	done
		1818
		1819	if [[ "${ABI_output}" == "1" && "${absolute_path_output}" == "1" ]]; then
		1820	die "${FUNCNAME}(): '--ABI' and '--absolute-path' options cannot be specified simultaneously"
		1821	fi
		1822
		1823	if [[ "$((${python2} + ${python3} + ${final_ABI}))" -gt 1 ]]; then
		1824	die "${FUNCNAME}(): '-2', '-3' or '--final-ABI' options cannot be specified simultaneously"
		1825	fi
		1826
		1827	if [[ "$#" -eq 0 ]]; then
		1828	if [[ "${final_ABI}" == "1" ]]; then
		1829	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		1830	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		1831	fi
		1832	_python_calculate_PYTHON_ABIS
		1833	PYTHON_ABI="${PYTHON_ABIS##* }"
		1834	elif [[ "${python2}" == "1" ]]; then
		1835	PYTHON_ABI="$(ROOT="/" eselect python show --python2 --ABI)"
		1836	if [[ -z "${PYTHON_ABI}" ]]; then
		1837	die "${FUNCNAME}(): Active version of CPython 2 not set"
		1838	elif [[ "${PYTHON_ABI}" != "2."* ]]; then
		1839	die "${FUNCNAME}(): Internal error in \`eselect python show --python2\`"
		1840	fi
		1841	elif [[ "${python3}" == "1" ]]; then
		1842	PYTHON_ABI="$(ROOT="/" eselect python show --python3 --ABI)"
		1843	if [[ -z "${PYTHON_ABI}" ]]; then
		1844	die "${FUNCNAME}(): Active version of CPython 3 not set"
		1845	elif [[ "${PYTHON_ABI}" != "3."* ]]; then
		1846	die "${FUNCNAME}(): Internal error in \`eselect python show --python3\`"
		1847	fi
		1848	elif _python_package_supporting_installation_for_multiple_python_abis; then
		1849	if ! _python_abi-specific_local_scope; then
		1850	die "${FUNCNAME}() should be used in ABI-specific local scope"
		1851	fi
		1852	else
		1853	PYTHON_ABI="$("${EPREFIX}/usr/bin/python" -c "${_PYTHON_ABI_EXTRACTION_COMMAND}")"
		1854	if [[ -z "${PYTHON_ABI}" ]]; then
		1855	die "${FUNCNAME}(): Failure of extraction of locally active version of Python"
		1856	fi
		1857	fi
		1858	elif [[ "$#" -eq 1 ]]; then
		1859	if [[ "${final_ABI}" == "1" ]]; then
		1860	die "${FUNCNAME}(): '--final-ABI' option and Python ABI cannot be specified simultaneously"
		1861	fi
		1862	if [[ "${python2}" == "1" ]]; then
		1863	die "${FUNCNAME}(): '-2' option and Python ABI cannot be specified simultaneously"
		1864	fi
		1865	if [[ "${python3}" == "1" ]]; then
		1866	die "${FUNCNAME}(): '-3' option and Python ABI cannot be specified simultaneously"
		1867	fi
		1868	PYTHON_ABI="$1"
		1869	else
		1870	die "${FUNCNAME}(): Invalid usage"
		1871	fi
		1872
		1873	if [[ "${ABI_output}" == "1" ]]; then
		1874	echo -n "${PYTHON_ABI}"
		1875	return
		1876	else
		1877	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
		1878	python_interpreter="python${PYTHON_ABI}"
		1879	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
		1880	python_interpreter="jython${PYTHON_ABI%-jython}"
		1881	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "PyPy" ]]; then
		1882	python_interpreter="pypy-c${PYTHON_ABI#*-pypy-}"
		1883	fi
		1884
		1885	if [[ "${absolute_path_output}" == "1" ]]; then
		1886	echo -n "${EPREFIX}/usr/bin/${python_interpreter}"
		1887	else
		1888	echo -n "${python_interpreter}"
		1889	fi
		1890	fi
		1891
		1892	if [[ -n "${ABI}" && "${ABI}" != "${DEFAULT_ABI}" && "${DEFAULT_ABI}" != "default" ]]; then
		1893	echo -n "-${ABI}"
		1894	fi
		1895	}
		1896
		1897	# @FUNCTION: python_get_implementation
		1898	# @USAGE: [-f\|--final-ABI]
		1899	# @DESCRIPTION:
		1900	# Print name of Python implementation.
		1901	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		1902	python_get_implementation() {
		1903	_python_check_python_pkg_setup_execution
		1904
		1905	local final_ABI="0" PYTHON_ABI="${PYTHON_ABI}"
		1906
		1907	while (($#)); do
		1908	case "$1" in
		1909	-f\|--final-ABI)
		1910	final_ABI="1"
		1911	;;
		1912	-*)
		1913	die "${FUNCNAME}(): Unrecognized option '$1'"
		1914	;;
		1915	*)
		1916	die "${FUNCNAME}(): Invalid usage"
		1917	;;
		1918	esac
		1919	shift
		1920	done
		1921
		1922	if [[ "${final_ABI}" == "1" ]]; then
		1923	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		1924	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		1925	fi
		1926	PYTHON_ABI="$(PYTHON -f --ABI)"
		1927	else
		1928	if _python_package_supporting_installation_for_multiple_python_abis; then
		1929	if ! _python_abi-specific_local_scope; then
		1930	die "${FUNCNAME}() should be used in ABI-specific local scope"
		1931	fi
		1932	else
		1933	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		1934	fi
		1935	fi
		1936
		1937	echo "$(_python_get_implementation "${PYTHON_ABI}")"
		1938	}
		1939
		1940	# @FUNCTION: python_get_implementational_package
		1941	# @USAGE: [-f\|--final-ABI]
		1942	# @DESCRIPTION:
		1943	# Print category, name and slot of package providing Python implementation.
		1944	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		1945	python_get_implementational_package() {
		1946	_python_check_python_pkg_setup_execution
		1947
		1948	local final_ABI="0" PYTHON_ABI="${PYTHON_ABI}"
		1949
		1950	while (($#)); do
		1951	case "$1" in
		1952	-f\|--final-ABI)
		1953	final_ABI="1"
		1954	;;
		1955	-*)
		1956	die "${FUNCNAME}(): Unrecognized option '$1'"
		1957	;;
		1958	*)
		1959	die "${FUNCNAME}(): Invalid usage"
		1960	;;
		1961	esac
		1962	shift
		1963	done
		1964
		1965	if [[ "${final_ABI}" == "1" ]]; then
		1966	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		1967	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		1968	fi
		1969	PYTHON_ABI="$(PYTHON -f --ABI)"
		1970	else
		1971	if _python_package_supporting_installation_for_multiple_python_abis; then
		1972	if ! _python_abi-specific_local_scope; then
		1973	die "${FUNCNAME}() should be used in ABI-specific local scope"
		1974	fi
		1975	else
		1976	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		1977	fi
		1978	fi
		1979
		1980	if [[ "${EAPI:-0}" == "0" ]]; then
		1981	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
		1982	echo "=dev-lang/python-${PYTHON_ABI}*"
		1983	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
		1984	echo "=dev-java/jython-${PYTHON_ABI%-jython}*"
		1985	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "PyPy" ]]; then
		1986	echo "=dev-python/pypy-${PYTHON_ABI#-pypy-}"
		1987	fi
		1988	else
		1989	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
		1990	echo "dev-lang/python:${PYTHON_ABI}"
		1991	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
		1992	echo "dev-java/jython:${PYTHON_ABI%-jython}"
		1993	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "PyPy" ]]; then
		1994	echo "dev-python/pypy:${PYTHON_ABI#*-pypy-}"
		1995	fi
		1996	fi
		1997	}
		1998
		1999	# @FUNCTION: python_get_includedir
		2000	# @USAGE: [-b\|--base-path] [-f\|--final-ABI]
		2001	# @DESCRIPTION:
		2002	# Print path to Python include directory.
		2003	# If --base-path option is specified, then path not prefixed with "/" is printed.
		2004	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		2005	python_get_includedir() {
		2006	_python_check_python_pkg_setup_execution
		2007
		2008	local base_path="0" final_ABI="0" prefix PYTHON_ABI="${PYTHON_ABI}"
		2009
		2010	while (($#)); do
		2011	case "$1" in
		2012	-b\|--base-path)
		2013	base_path="1"
		2014	;;
		2015	-f\|--final-ABI)
		2016	final_ABI="1"
		2017	;;
		2018	-*)
		2019	die "${FUNCNAME}(): Unrecognized option '$1'"
		2020	;;
		2021	*)
		2022	die "${FUNCNAME}(): Invalid usage"
		2023	;;
		2024	esac
		2025	shift
		2026	done
		2027
		2028	if [[ "${base_path}" == "0" ]]; then
		2029	prefix="/"
		2030	fi
		2031
		2032	if [[ "${final_ABI}" == "1" ]]; then
		2033	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		2034	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		2035	fi
		2036	PYTHON_ABI="$(PYTHON -f --ABI)"
		2037	else
		2038	if _python_package_supporting_installation_for_multiple_python_abis; then
		2039	if ! _python_abi-specific_local_scope; then
		2040	die "${FUNCNAME}() should be used in ABI-specific local scope"
		2041	fi
		2042	else
		2043	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		2044	fi
		2045	fi
		2046
		2047	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
		2048	echo "${prefix}usr/include/python${PYTHON_ABI}"
		2049	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
		2050	echo "${prefix}usr/share/jython-${PYTHON_ABI%-jython}/Include"
		2051	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "PyPy" ]]; then
		2052	echo "${prefix}usr/$(get_libdir)/pypy${PYTHON_ABI#*-pypy-}/include"
		2053	fi
		2054	}
		2055
		2056	# @FUNCTION: python_get_libdir
		2057	# @USAGE: [-b\|--base-path] [-f\|--final-ABI]
		2058	# @DESCRIPTION:
		2059	# Print path to Python standard library directory.
		2060	# If --base-path option is specified, then path not prefixed with "/" is printed.
		2061	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		2062	python_get_libdir() {
		2063	_python_check_python_pkg_setup_execution
		2064
		2065	local base_path="0" final_ABI="0" prefix PYTHON_ABI="${PYTHON_ABI}"
		2066
		2067	while (($#)); do
		2068	case "$1" in
		2069	-b\|--base-path)
		2070	base_path="1"
		2071	;;
		2072	-f\|--final-ABI)
		2073	final_ABI="1"
		2074	;;
		2075	-*)
		2076	die "${FUNCNAME}(): Unrecognized option '$1'"
		2077	;;
		2078	*)
		2079	die "${FUNCNAME}(): Invalid usage"
		2080	;;
		2081	esac
		2082	shift
		2083	done
		2084
		2085	if [[ "${base_path}" == "0" ]]; then
		2086	prefix="/"
		2087	fi
		2088
		2089	if [[ "${final_ABI}" == "1" ]]; then
		2090	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		2091	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		2092	fi
		2093	PYTHON_ABI="$(PYTHON -f --ABI)"
		2094	else
		2095	if _python_package_supporting_installation_for_multiple_python_abis; then
		2096	if ! _python_abi-specific_local_scope; then
		2097	die "${FUNCNAME}() should be used in ABI-specific local scope"
		2098	fi
		2099	else
		2100	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		2101	fi
		2102	fi
		2103
		2104	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
		2105	echo "${prefix}usr/$(get_libdir)/python${PYTHON_ABI}"
		2106	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
		2107	echo "${prefix}usr/share/jython-${PYTHON_ABI%-jython}/Lib"
		2108	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "PyPy" ]]; then
		2109	die "${FUNCNAME}(): PyPy has multiple standard library directories"
		2110	fi
		2111	}
		2112
		2113	# @FUNCTION: python_get_sitedir
		2114	# @USAGE: [-b\|--base-path] [-f\|--final-ABI]
		2115	# @DESCRIPTION:
		2116	# Print path to Python site-packages directory.
		2117	# If --base-path option is specified, then path not prefixed with "/" is printed.
		2118	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		2119	python_get_sitedir() {
		2120	_python_check_python_pkg_setup_execution
		2121
		2122	local base_path="0" final_ABI="0" prefix PYTHON_ABI="${PYTHON_ABI}"
		2123
		2124	while (($#)); do
		2125	case "$1" in
		2126	-b\|--base-path)
		2127	base_path="1"
		2128	;;
		2129	-f\|--final-ABI)
		2130	final_ABI="1"
		2131	;;
		2132	-*)
		2133	die "${FUNCNAME}(): Unrecognized option '$1'"
		2134	;;
		2135	*)
		2136	die "${FUNCNAME}(): Invalid usage"
		2137	;;
		2138	esac
		2139	shift
		2140	done
		2141
		2142	if [[ "${base_path}" == "0" ]]; then
		2143	prefix="/"
		2144	fi
		2145
		2146	if [[ "${final_ABI}" == "1" ]]; then
		2147	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		2148	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		2149	fi
		2150	PYTHON_ABI="$(PYTHON -f --ABI)"
		2151	else
		2152	if _python_package_supporting_installation_for_multiple_python_abis; then
		2153	if ! _python_abi-specific_local_scope; then
		2154	die "${FUNCNAME}() should be used in ABI-specific local scope"
		2155	fi
		2156	else
		2157	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		2158	fi
		2159	fi
		2160
		2161	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
		2162	echo "${prefix}usr/$(get_libdir)/python${PYTHON_ABI}/site-packages"
		2163	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
		2164	echo "${prefix}usr/share/jython-${PYTHON_ABI%-jython}/Lib/site-packages"
		2165	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "PyPy" ]]; then
		2166	echo "${prefix}usr/$(get_libdir)/pypy${PYTHON_ABI#*-pypy-}/site-packages"
		2167	fi
		2168	}
		2169
		2170	# @FUNCTION: python_get_library
		2171	# @USAGE: [-b\|--base-path] [-f\|--final-ABI] [-l\|--linker-option]
		2172	# @DESCRIPTION:
		2173	# Print path to Python library.
		2174	# If --base-path option is specified, then path not prefixed with "/" is printed.
		2175	# If --linker-option is specified, then "-l${library}" linker option is printed.
		2176	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		2177	python_get_library() {
		2178	_python_check_python_pkg_setup_execution
		2179
		2180	local base_path="0" final_ABI="0" linker_option="0" prefix PYTHON_ABI="${PYTHON_ABI}"
		2181
		2182	while (($#)); do
		2183	case "$1" in
		2184	-b\|--base-path)
		2185	base_path="1"
		2186	;;
		2187	-f\|--final-ABI)
		2188	final_ABI="1"
		2189	;;
		2190	-l\|--linker-option)
		2191	linker_option="1"
		2192	;;
		2193	-*)
		2194	die "${FUNCNAME}(): Unrecognized option '$1'"
		2195	;;
		2196	*)
		2197	die "${FUNCNAME}(): Invalid usage"
		2198	;;
		2199	esac
		2200	shift
		2201	done
		2202
		2203	if [[ "${base_path}" == "0" ]]; then
		2204	prefix="/"
		2205	fi
		2206
		2207	if [[ "${base_path}" == "1" && "${linker_option}" == "1" ]]; then
		2208	die "${FUNCNAME}(): '--base-path' and '--linker-option' options cannot be specified simultaneously"
		2209	fi
		2210
		2211	if [[ "${final_ABI}" == "1" ]]; then
		2212	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		2213	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		2214	fi
		2215	PYTHON_ABI="$(PYTHON -f --ABI)"
		2216	else
		2217	if _python_package_supporting_installation_for_multiple_python_abis; then
		2218	if ! _python_abi-specific_local_scope; then
		2219	die "${FUNCNAME}() should be used in ABI-specific local scope"
		2220	fi
		2221	else
		2222	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		2223	fi
		2224	fi
		2225
		2226	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
		2227	if [[ "${linker_option}" == "1" ]]; then
		2228	echo "-lpython${PYTHON_ABI}"
		2229	else
		2230	echo "${prefix}usr/$(get_libdir)/libpython${PYTHON_ABI}$(get_libname)"
		2231	fi
		2232	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
		2233	die "${FUNCNAME}(): Jython does not have shared library"
		2234	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "PyPy" ]]; then
		2235	die "${FUNCNAME}(): PyPy does not have shared library"
		2236	fi
		2237	}
		2238
		2239	# @FUNCTION: python_get_version
		2240	# @USAGE: [-f\|--final-ABI] [-l\|--language] [--full] [--major] [--minor] [--micro]
		2241	# @DESCRIPTION:
		2242	# Print version of Python implementation.
		2243	# --full, --major, --minor and --micro options cannot be specified simultaneously.
		2244	# If --full, --major, --minor and --micro options are not specified, then "${major_version}.${minor_version}" is printed.
		2245	# If --language option is specified, then version of Python language is printed.
		2246	# --language and --full options cannot be specified simultaneously.
		2247	# --language and --micro options cannot be specified simultaneously.
		2248	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		2249	python_get_version() {
		2250	_python_check_python_pkg_setup_execution
		2251
		2252	local final_ABI="0" language="0" language_version full="0" major="0" minor="0" micro="0" PYTHON_ABI="${PYTHON_ABI}" python_command
		2253
		2254	while (($#)); do
		2255	case "$1" in
		2256	-f\|--final-ABI)
		2257	final_ABI="1"
		2258	;;
		2259	-l\|--language)
		2260	language="1"
		2261	;;
		2262	--full)
		2263	full="1"
		2264	;;
		2265	--major)
		2266	major="1"
		2267	;;
		2268	--minor)
		2269	minor="1"
		2270	;;
		2271	--micro)
		2272	micro="1"
		2273	;;
		2274	-*)
		2275	die "${FUNCNAME}(): Unrecognized option '$1'"
		2276	;;
		2277	*)
		2278	die "${FUNCNAME}(): Invalid usage"
		2279	;;
		2280	esac
		2281	shift
		2282	done
		2283
		2284	if [[ "${final_ABI}" == "1" ]]; then
		2285	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		2286	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		2287	fi
		2288	else
		2289	if _python_package_supporting_installation_for_multiple_python_abis && ! _python_abi-specific_local_scope; then
		2290	die "${FUNCNAME}() should be used in ABI-specific local scope"
		2291	fi
		2292	fi
		2293
		2294	if [[ "$((${full} + ${major} + ${minor} + ${micro}))" -gt 1 ]]; then
		2295	die "${FUNCNAME}(): '--full', '--major', '--minor' or '--micro' options cannot be specified simultaneously"
		2296	fi
		2297
		2298	if [[ "${language}" == "1" ]]; then
		2299	if [[ "${final_ABI}" == "1" ]]; then
		2300	PYTHON_ABI="$(PYTHON -f --ABI)"
		2301	elif [[ -z "${PYTHON_ABI}" ]]; then
		2302	PYTHON_ABI="$(PYTHON --ABI)"
		2303	fi
		2304	language_version="${PYTHON_ABI%%-*}"
		2305	if [[ "${full}" == "1" ]]; then
		2306	die "${FUNCNAME}(): '--language' and '--full' options cannot be specified simultaneously"
		2307	elif [[ "${major}" == "1" ]]; then
		2308	echo "${language_version%.*}"
		2309	elif [[ "${minor}" == "1" ]]; then
		2310	echo "${language_version#*.}"
		2311	elif [[ "${micro}" == "1" ]]; then
		2312	die "${FUNCNAME}(): '--language' and '--micro' options cannot be specified simultaneously"
		2313	else
		2314	echo "${language_version}"
		2315	fi
		2316	else
		2317	if [[ "${full}" == "1" ]]; then
		2318	python_command="import sys; print('.'.join(str(x) for x in getattr(sys, 'pypy_version_info', sys.version_info)[:3]))"
		2319	elif [[ "${major}" == "1" ]]; then
		2320	python_command="import sys; print(getattr(sys, 'pypy_version_info', sys.version_info)[0])"
		2321	elif [[ "${minor}" == "1" ]]; then
		2322	python_command="import sys; print(getattr(sys, 'pypy_version_info', sys.version_info)[1])"
		2323	elif [[ "${micro}" == "1" ]]; then
		2324	python_command="import sys; print(getattr(sys, 'pypy_version_info', sys.version_info)[2])"
		2325	else
		2326	if [[ -n "${PYTHON_ABI}" && "${final_ABI}" == "0" ]]; then
		2327	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
		2328	echo "${PYTHON_ABI}"
		2329	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
		2330	echo "${PYTHON_ABI%-jython}"
		2331	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "PyPy" ]]; then
		2332	echo "${PYTHON_ABI#*-pypy-}"
		2333	fi
		2334	return
		2335	fi
		2336	python_command="from sys import version_info; print('.'.join(str(x) for x in version_info[:2]))"
		2337	fi
		2338
		2339	if [[ "${final_ABI}" == "1" ]]; then
		2340	"$(PYTHON -f)" -c "${python_command}"
		2341	else
		2342	"$(PYTHON ${PYTHON_ABI})" -c "${python_command}"
		2343	fi
		2344	fi
		2345	}
		2346
		2347	# @FUNCTION: python_get_implementation_and_version
		2348	# @USAGE: [-f\|--final-ABI]
		2349	# @DESCRIPTION:
		2350	# Print name and version of Python implementation.
		2351	# If version of Python implementation is not bound to version of Python language, then
		2352	# version of Python language is additionally printed.
		2353	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		2354	python_get_implementation_and_version() {
		2355	_python_check_python_pkg_setup_execution
		2356
		2357	local final_ABI="0" PYTHON_ABI="${PYTHON_ABI}"
		2358
		2359	while (($#)); do
		2360	case "$1" in
		2361	-f\|--final-ABI)
		2362	final_ABI="1"
		2363	;;
		2364	-*)
		2365	die "${FUNCNAME}(): Unrecognized option '$1'"
		2366	;;
		2367	*)
		2368	die "${FUNCNAME}(): Invalid usage"
		2369	;;
		2370	esac
		2371	shift
		2372	done
		2373
		2374	if [[ "${final_ABI}" == "1" ]]; then
		2375	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		2376	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		2377	fi
		2378	PYTHON_ABI="$(PYTHON -f --ABI)"
		2379	else
		2380	if _python_package_supporting_installation_for_multiple_python_abis; then
		2381	if ! _python_abi-specific_local_scope; then
		2382	die "${FUNCNAME}() should be used in ABI-specific local scope"
		2383	fi
		2384	else
		2385	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		2386	fi
		2387	fi
		2388
		2389	if [[ "${PYTHON_ABI}" =~ ^[[:digit:]]+\.[[:digit:]]+-[[:alnum:]]+-[[:digit:]]+\.[[:digit:]]+$ ]]; then
		2390	echo "$(_python_get_implementation "${PYTHON_ABI}") ${PYTHON_ABI##-} (Python ${PYTHON_ABI%%-})"
		2391	else
		2392	echo "$(_python_get_implementation "${PYTHON_ABI}") ${PYTHON_ABI%%-*}"
		2393	fi
		2394	}
		2395
		2396	# ================================================================================================
		2397	# ================================ FUNCTIONS FOR RUNNING OF TESTS ================================
		2398	# ================================================================================================
		2399
		2400	# @ECLASS-VARIABLE: PYTHON_TEST_VERBOSITY
		2401	# @DESCRIPTION:
		2402	# User-configurable verbosity of tests of Python modules.
		2403	# Supported values: 0, 1, 2, 3, 4.
		2404	PYTHON_TEST_VERBOSITY="${PYTHON_TEST_VERBOSITY:-1}"
		2405
		2406	_python_test_hook() {
		2407	if [[ "$#" -ne 1 ]]; then
		2408	die "${FUNCNAME}() requires 1 argument"
		2409	fi
		2410
		2411	if _python_package_supporting_installation_for_multiple_python_abis && [[ "$(type -t "${FUNCNAME[3]}_$1_hook")" == "function" ]]; then
		2412	"${FUNCNAME[3]}_$1_hook"
		2413	fi
		2414	}
		2415
		2416	# @FUNCTION: python_execute_nosetests
		2417	# @USAGE: [-P\|--PYTHONPATH PYTHONPATH] [-s\|--separate-build-dirs] [--] [arguments]
		2418	# @DESCRIPTION:
		2419	# Execute nosetests for all enabled Python ABIs.
		2420	# In ebuilds of packages supporting installation for multiple Python ABIs, this function calls
		2421	# python_execute_nosetests_pre_hook() and python_execute_nosetests_post_hook(), if they are defined.
		2422	python_execute_nosetests() {
		2423	_python_check_python_pkg_setup_execution
		2424	_python_set_color_variables
		2425
		2426	local PYTHONPATH_template separate_build_dirs
		2427
		2428	while (($#)); do
		2429	case "$1" in
		2430	-P\|--PYTHONPATH)
		2431	PYTHONPATH_template="$2"
		2432	shift
		2433	;;
		2434	-s\|--separate-build-dirs)
		2435	separate_build_dirs="1"
		2436	;;
		2437	--)
		2438	shift
		2439	break
		2440	;;
		2441	-*)
		2442	die "${FUNCNAME}(): Unrecognized option '$1'"
		2443	;;
		2444	*)
		2445	break
		2446	;;
		2447	esac
		2448	shift
		2449	done
		2450
		2451	python_test_function() {
		2452	local evaluated_PYTHONPATH
		2453
		2454	eval "evaluated_PYTHONPATH=\"${PYTHONPATH_template}\""
		2455
		2456	_python_test_hook pre
		2457
		2458	if [[ -n "${evaluated_PYTHONPATH}" ]]; then
		2459	echo ${_BOLD}PYTHONPATH="${evaluated_PYTHONPATH}" nosetests --verbosity="${PYTHON_TEST_VERBOSITY}" "$@"${_NORMAL}
		2460	PYTHONPATH="${evaluated_PYTHONPATH}" nosetests --verbosity="${PYTHON_TEST_VERBOSITY}" "$@" \|\| return "$?"
		2461	else
		2462	echo ${_BOLD}nosetests --verbosity="${PYTHON_TEST_VERBOSITY}" "$@"${_NORMAL}
		2463	nosetests --verbosity="${PYTHON_TEST_VERBOSITY}" "$@" \|\| return "$?"
		2464	fi
		2465
		2466	_python_test_hook post
980	}	2467	}
		2468	if _python_package_supporting_installation_for_multiple_python_abis; then
		2469	python_execute_function ${separate_build_dirs:+-s} python_test_function "$@"
		2470	else
		2471	if [[ -n "${separate_build_dirs}" ]]; then
		2472	die "${FUNCNAME}(): Invalid usage"
		2473	fi
		2474	python_test_function "$@" \|\| die "Testing failed"
		2475	fi
981		2476
982	EXPORT_FUNCTIONS pkg_setup	2477	unset -f python_test_function
		2478	}
983		2479
984	if [[ -n "${PYTHON_USE_WITH}" ]]; then	2480	# @FUNCTION: python_execute_py.test
985	PYTHON_USE_WITH_ATOM="${PYTHON_ATOM}[${PYTHON_USE_WITH/ /,}]"	2481	# @USAGE: [-P\|--PYTHONPATH PYTHONPATH] [-s\|--separate-build-dirs] [--] [arguments]
986	elif [[ -n "${PYTHON_USE_WITH_OR}" ]]; then	2482	# @DESCRIPTION:
987	PYTHON_USE_WITH_ATOM="\|\| ( "	2483	# Execute py.test for all enabled Python ABIs.
988	for use in ${PYTHON_USE_WITH_OR}; do	2484	# In ebuilds of packages supporting installation for multiple Python ABIs, this function calls
989	PYTHON_USE_WITH_ATOM+=" ${PYTHON_ATOM}[${use}]"	2485	# python_execute_py.test_pre_hook() and python_execute_py.test_post_hook(), if they are defined.
		2486	python_execute_py.test() {
		2487	_python_check_python_pkg_setup_execution
		2488	_python_set_color_variables
		2489
		2490	local PYTHONPATH_template separate_build_dirs
		2491
		2492	while (($#)); do
		2493	case "$1" in
		2494	-P\|--PYTHONPATH)
		2495	PYTHONPATH_template="$2"
		2496	shift
		2497	;;
		2498	-s\|--separate-build-dirs)
		2499	separate_build_dirs="1"
		2500	;;
		2501	--)
		2502	shift
		2503	break
		2504	;;
		2505	-*)
		2506	die "${FUNCNAME}(): Unrecognized option '$1'"
		2507	;;
		2508	*)
		2509	break
		2510	;;
		2511	esac
		2512	shift
990	done	2513	done
991	unset use	2514
992	PYTHON_USE_WITH_ATOM+=" )"	2515	python_test_function() {
		2516	local evaluated_PYTHONPATH
		2517
		2518	eval "evaluated_PYTHONPATH=\"${PYTHONPATH_template}\""
		2519
		2520	_python_test_hook pre
		2521
		2522	if [[ -n "${evaluated_PYTHONPATH}" ]]; then
		2523	echo ${_BOLD}PYTHONPATH="${evaluated_PYTHONPATH}" py.test $([[ "${PYTHON_TEST_VERBOSITY}" -ge 2 ]] && echo -v) "$@"${_NORMAL}
		2524	PYTHONPATH="${evaluated_PYTHONPATH}" py.test $([[ "${PYTHON_TEST_VERBOSITY}" -ge 2 ]] && echo -v) "$@" \|\| return "$?"
		2525	else
		2526	echo ${_BOLD}py.test $([[ "${PYTHON_TEST_VERBOSITY}" -gt 1 ]] && echo -v) "$@"${_NORMAL}
		2527	py.test $([[ "${PYTHON_TEST_VERBOSITY}" -gt 1 ]] && echo -v) "$@" \|\| return "$?"
993	fi	2528	fi
994	if [[ -n "${PYTHON_USE_WITH_OPT}" ]]; then
995	PYTHON_USE_WITH_ATOM="${PYTHON_USE_WITH_OPT}? ( ${PYTHON_USE_WITH_ATOM} )"
996	fi
997	DEPEND+=" ${PYTHON_USE_WITH_ATOM}"
998	RDEPEND+=" ${PYTHON_USE_WITH_ATOM}"
999	fi
1000		2529
1001	# @ECLASS-VARIABLE: PYTHON_DEFINE_DEFAULT_FUNCTIONS	2530	_python_test_hook post
1002	# @DESCRIPTION:
1003	# Set this to define default functions for the following ebuild phases:
1004	# src_prepare, src_configure, src_compile, src_test, src_install.
1005	if ! has "${EAPI:-0}" 0 1 && [[ -n "${PYTHON_DEFINE_DEFAULT_FUNCTIONS}" ]]; then
1006	python_src_prepare() {
1007	python_copy_sources
1008	}	2531	}
		2532	if _python_package_supporting_installation_for_multiple_python_abis; then
		2533	python_execute_function ${separate_build_dirs:+-s} python_test_function "$@"
		2534	else
		2535	if [[ -n "${separate_build_dirs}" ]]; then
		2536	die "${FUNCNAME}(): Invalid usage"
		2537	fi
		2538	python_test_function "$@" \|\| die "Testing failed"
		2539	fi
1009		2540
1010	for python_default_function in src_configure src_compile src_test src_install; do	2541	unset -f python_test_function
1011	eval "python_${python_default_function}() { python_execute_function -d -s; }"	2542	}
		2543
		2544	# @FUNCTION: python_execute_trial
		2545	# @USAGE: [-P\|--PYTHONPATH PYTHONPATH] [-s\|--separate-build-dirs] [--] [arguments]
		2546	# @DESCRIPTION:
		2547	# Execute trial for all enabled Python ABIs.
		2548	# In ebuilds of packages supporting installation for multiple Python ABIs, this function
		2549	# calls python_execute_trial_pre_hook() and python_execute_trial_post_hook(), if they are defined.
		2550	python_execute_trial() {
		2551	_python_check_python_pkg_setup_execution
		2552	_python_set_color_variables
		2553
		2554	local PYTHONPATH_template separate_build_dirs
		2555
		2556	while (($#)); do
		2557	case "$1" in
		2558	-P\|--PYTHONPATH)
		2559	PYTHONPATH_template="$2"
		2560	shift
		2561	;;
		2562	-s\|--separate-build-dirs)
		2563	separate_build_dirs="1"
		2564	;;
		2565	--)
		2566	shift
		2567	break
		2568	;;
		2569	-*)
		2570	die "${FUNCNAME}(): Unrecognized option '$1'"
		2571	;;
		2572	*)
		2573	break
		2574	;;
		2575	esac
		2576	shift
1012	done	2577	done
		2578
		2579	python_test_function() {
		2580	local evaluated_PYTHONPATH
		2581
		2582	eval "evaluated_PYTHONPATH=\"${PYTHONPATH_template}\""
		2583
		2584	_python_test_hook pre
		2585
		2586	if [[ -n "${evaluated_PYTHONPATH}" ]]; then
		2587	echo ${_BOLD}PYTHONPATH="${evaluated_PYTHONPATH}" trial $([[ "${PYTHON_TEST_VERBOSITY}" -ge 4 ]] && echo --spew) "$@"${_NORMAL}
		2588	PYTHONPATH="${evaluated_PYTHONPATH}" trial $([[ "${PYTHON_TEST_VERBOSITY}" -ge 4 ]] && echo --spew) "$@" \|\| return "$?"
		2589	else
		2590	echo ${_BOLD}trial $([[ "${PYTHON_TEST_VERBOSITY}" -ge 4 ]] && echo --spew) "$@"${_NORMAL}
		2591	trial $([[ "${PYTHON_TEST_VERBOSITY}" -ge 4 ]] && echo --spew) "$@" \|\| return "$?"
		2592	fi
		2593
		2594	_python_test_hook post
		2595	}
		2596	if _python_package_supporting_installation_for_multiple_python_abis; then
		2597	python_execute_function ${separate_build_dirs:+-s} python_test_function "$@"
		2598	else
		2599	if [[ -n "${separate_build_dirs}" ]]; then
		2600	die "${FUNCNAME}(): Invalid usage"
		2601	fi
		2602	python_test_function "$@" \|\| die "Testing failed"
		2603	fi
		2604
1013	unset python_default_function	2605	unset -f python_test_function
		2606	}
1014		2607
1015	EXPORT_FUNCTIONS src_prepare src_configure src_compile src_test src_install	2608	# ================================================================================================
		2609	# ======================= FUNCTIONS FOR HANDLING OF BYTE-COMPILED MODULES ========================
		2610	# ================================================================================================
		2611
		2612	# @FUNCTION: python_enable_pyc
		2613	# @DESCRIPTION:
		2614	# Tell Python to automatically recompile modules to .pyc/.pyo if the
		2615	# timestamps/version stamps have changed.
		2616	python_enable_pyc() {
		2617	_python_check_python_pkg_setup_execution
		2618
		2619	if [[ "$#" -ne 0 ]]; then
		2620	die "${FUNCNAME}() does not accept arguments"
1016	fi	2621	fi
		2622
		2623	unset PYTHONDONTWRITEBYTECODE
		2624	}
1017		2625
1018	# @FUNCTION: python_disable_pyc	2626	# @FUNCTION: python_disable_pyc
1019	# @DESCRIPTION:	2627	# @DESCRIPTION:
1020	# Tell Python not to automatically recompile modules to .pyc/.pyo	2628	# Tell Python not to automatically recompile modules to .pyc/.pyo
1021	# even if the timestamps/version stamps do not match. This is done	2629	# even if the timestamps/version stamps do not match. This is done
1022	# to protect sandbox.	2630	# to protect sandbox.
1023	python_disable_pyc() {	2631	python_disable_pyc() {
		2632	_python_check_python_pkg_setup_execution
		2633
		2634	if [[ "$#" -ne 0 ]]; then
		2635	die "${FUNCNAME}() does not accept arguments"
		2636	fi
		2637
1024	export PYTHONDONTWRITEBYTECODE="1"	2638	export PYTHONDONTWRITEBYTECODE="1"
1025	}	2639	}
1026		2640
1027	# @FUNCTION: python_enable_pyc	2641	_python_clean_compiled_modules() {
1028	# @DESCRIPTION:	2642	_python_initialize_prefix_variables
1029	# Tell Python to automatically recompile modules to .pyc/.pyo if the	2643	_python_set_color_variables
1030	# timestamps/version stamps have changed.
1031	python_enable_pyc() {
1032	unset PYTHONDONTWRITEBYTECODE
1033	}
1034		2644
1035	# @FUNCTION: python_need_rebuild	2645	[[ "${FUNCNAME[1]}" =~ ^(python_mod_optimize\|python_mod_cleanup)$ ]] \|\| die "${FUNCNAME}(): Invalid usage"
1036	# @DESCRIPTION: Run without arguments, specifies that the package should be
1037	# rebuilt after a python upgrade.
1038	# Do not use this function in ebuilds of packages supporting installation
1039	# for multiple versions of Python.
1040	python_need_rebuild() {
1041	export PYTHON_NEED_REBUILD="$(PYTHON -A --ABI)"
1042	}
1043		2646
1044	# @FUNCTION: python_get_includedir	2647	local base_module_name compiled_file compiled_files=() dir path py_file root
1045	# @DESCRIPTION:	2648
1046	# Run without arguments, returns the Python include directory.	2649	# Strip trailing slash from EROOT.
1047	python_get_includedir() {	2650	root="${EROOT%/}"
1048	if [[ -n "${PYTHON_ABI}" ]]; then	2651
1049	echo "/usr/include/python${PYTHON_ABI}"	2652	for path in "$@"; do
1050	else	2653	compiled_files=()
1051	echo "/usr/include/python$(PYTHON -A --ABI)"	2654	if [[ -d "${path}" ]]; then
		2655	while read -d $'\0' -r compiled_file; do
		2656	compiled_files+=("${compiled_file}")
		2657	done < <(find "${path}" "(" -name ".py[co]" -o -name "\$py.class" ")" -print0)
		2658
		2659	if [[ "${EBUILD_PHASE}" == "postrm" ]]; then
		2660	# Delete empty child directories.
		2661	find "${path}" -type d \| sort -r \| while read -r dir; do
		2662	if rmdir "${dir}" 2> /dev/null; then
		2663	echo "${_CYAN}<<< ${dir}${_NORMAL}"
		2664	fi
		2665	done
		2666	fi
		2667	elif [[ "${path}" == *.py ]]; then
		2668	base_module_name="${path##*/}"
		2669	base_module_name="${base_module_name%.py}"
		2670	if [[ -d "${path%/*}/__pycache__" ]]; then
		2671	while read -d $'\0' -r compiled_file; do
		2672	compiled_files+=("${compiled_file}")
		2673	done < <(find "${path%/}/__pycache__" "(" -name "${base_module_name}..py[co]" -o -name "${base_module_name}\$py.class" ")" -print0)
		2674	fi
		2675	compiled_files+=("${path}c" "${path}o" "${path%.py}\$py.class")
1052	fi	2676	fi
1053	}
1054		2677
1055	# @FUNCTION: python_get_libdir	2678	for compiled_file in "${compiled_files[@]}"; do
1056	# @DESCRIPTION:	2679	[[ ! -f "${compiled_file}" ]] && continue
1057	# Run without arguments, returns the Python library directory.	2680	dir="${compiled_file%/*}"
1058	python_get_libdir() {	2681	dir="${dir##*/}"
1059	if [[ -n "${PYTHON_ABI}" ]]; then	2682	if [[ "${compiled_file}" == *.py[co] ]]; then
1060	echo "/usr/$(get_libdir)/python${PYTHON_ABI}"	2683	if [[ "${dir}" == "__pycache__" ]]; then
		2684	base_module_name="${compiled_file##*/}"
		2685	base_module_name="${base_module_name%.*py[co]}"
		2686	base_module_name="${base_module_name%.*}"
		2687	py_file="${compiled_file%__pycache__/*}${base_module_name}.py"
		2688	else
		2689	py_file="${compiled_file%[co]}"
		2690	fi
		2691	if [[ "${EBUILD_PHASE}" == "postinst" ]]; then
		2692	[[ -f "${py_file}" && "${compiled_file}" -nt "${py_file}" ]] && continue
		2693	else
		2694	[[ -f "${py_file}" ]] && continue
		2695	fi
		2696	echo "${_BLUE}<<< ${compiled_file%[co]}[co]${_NORMAL}"
		2697	rm -f "${compiled_file%[co]}"[co]
		2698	elif [[ "${compiled_file}" == *\$py.class ]]; then
		2699	if [[ "${dir}" == "__pycache__" ]]; then
		2700	base_module_name="${compiled_file##*/}"
		2701	base_module_name="${base_module_name%\$py.class}"
		2702	py_file="${compiled_file%__pycache__/*}${base_module_name}.py"
		2703	else
		2704	py_file="${compiled_file%\$py.class}.py"
		2705	fi
		2706	if [[ "${EBUILD_PHASE}" == "postinst" ]]; then
		2707	[[ -f "${py_file}" && "${compiled_file}" -nt "${py_file}" ]] && continue
		2708	else
		2709	[[ -f "${py_file}" ]] && continue
		2710	fi
		2711	echo "${_BLUE}<<< ${compiled_file}${_NORMAL}"
		2712	rm -f "${compiled_file}"
1061	else	2713	else
1062	echo "/usr/$(get_libdir)/python$(PYTHON -A --ABI)"	2714	die "${FUNCNAME}(): Unrecognized file type: '${compiled_file}'"
1063	fi	2715	fi
1064	}
1065		2716
1066	# @FUNCTION: python_get_sitedir	2717	# Delete empty parent directories.
1067	# @DESCRIPTION:	2718	dir="${compiled_file%/*}"
1068	# Run without arguments, returns the Python site-packages directory.	2719	while [[ "${dir}" != "${root}" ]]; do
1069	python_get_sitedir() {	2720	if rmdir "${dir}" 2> /dev/null; then
1070	echo "$(python_get_libdir)/site-packages"	2721	echo "${_CYAN}<<< ${dir}${_NORMAL}"
		2722	else
		2723	break
		2724	fi
		2725	dir="${dir%/*}"
		2726	done
		2727	done
		2728	done
1071	}	2729	}
1072		2730
1073	# @FUNCTION: python_tkinter_exists
1074	# @DESCRIPTION:
1075	# Run without arguments, checks if python was compiled with Tkinter
1076	# support. If not, prints an error message and dies.
1077	python_tkinter_exists() {
1078	if ! python -c "import Tkinter" >/dev/null 2>&1; then
1079	eerror "You need to recompile python with Tkinter support."
1080	eerror "Try adding: 'dev-lang/python tk'"
1081	eerror "in to /etc/portage/package.use"
1082	echo
1083	die "missing tkinter support with installed python"
1084	fi
1085	}
1086
1087	# @FUNCTION: python_mod_exists	2731	# @FUNCTION: python_mod_optimize
1088	# @USAGE: <module>	2732	# @USAGE: [--allow-evaluated-non-sitedir-paths] [-d directory] [-f] [-l] [-q] [-x regular_expression] [--] <file\|directory> [files\|directories]
1089	# @DESCRIPTION:	2733	# @DESCRIPTION:
1090	# Run with the module name as an argument. it will check if a	2734	# Byte-compile specified Python modules.
1091	# python module is installed and loadable. it will return	2735	# -d, -f, -l, -q and -x options passed to this function are passed to compileall.py.
1092	# TRUE(0) if the module exists, and FALSE(1) if the module does
1093	# not exist.
1094	#	2736	#
1095	# Example:
1096	# if python_mod_exists gtk; then
1097	# echo "gtk support enabled"
1098	# fi
1099	python_mod_exists() {
1100	[[ "$1" ]] \|\| die "${FUNCNAME} requires an argument!"
1101	python -c "import $1" &>/dev/null
1102	}
1103
1104	# @FUNCTION: python_mod_compile
1105	# @USAGE: <file> [more files ...]
1106	# @DESCRIPTION:
1107	# Given filenames, it will pre-compile the module's .pyc and .pyo.
1108	# This function should only be run in pkg_postinst()
1109	#
1110	# Example:
1111	# python_mod_compile /usr/lib/python2.3/site-packages/pygoogle.py
1112	#
1113	python_mod_compile() {
1114	if ! has "${EAPI:-0}" 0 1 2 \|\| [[ -n "${SUPPORT_PYTHON_ABIS}" ]]; then
1115	die "${FUNCNAME}() cannot be used in this EAPI"
1116	fi
1117
1118	local f myroot myfiles=()
1119
1120	# Check if phase is pkg_postinst()
1121	[[ ${EBUILD_PHASE} != postinst ]] &&\
1122	die "${FUNCNAME} should only be run in pkg_postinst()"
1123
1124	# strip trailing slash
1125	myroot="${ROOT%/}"
1126
1127	# respect ROOT
1128	for f in "$@"; do
1129	[[ -f "${myroot}/${f}" ]] && myfiles+=("${myroot}/${f}")
1130	done
1131
1132	if ((${#myfiles[@]})); then
1133	"$(PYTHON -A)" "${myroot}$(python_get_libdir)/py_compile.py" "${myfiles[@]}"
1134	"$(PYTHON -A)" -O "${myroot}$(python_get_libdir)/py_compile.py" "${myfiles[@]}" &> /dev/null
1135	else
1136	ewarn "No files to compile!"
1137	fi
1138	}
1139
1140	# @FUNCTION: python_mod_optimize
1141	# @USAGE: [options] [directory\|file]
1142	# @DESCRIPTION:
1143	# If no arguments supplied, it will recompile not recursively all modules
1144	# under sys.path (eg. /usr/lib/python2.6, /usr/lib/python2.6/site-packages).
1145	#
1146	# If supplied with arguments, it will recompile all modules recursively
1147	# in the supplied directory.
1148	# This function should only be run in pkg_postinst().	2737	# This function can be used only in pkg_postinst() phase.
1149	#
1150	# Options passed to this function are passed to compileall.py.
1151	#
1152	# Example:
1153	# python_mod_optimize ctypesgencore
1154	python_mod_optimize() {	2738	python_mod_optimize() {
1155	# Check if phase is pkg_postinst().	2739	if [[ "${EBUILD_PHASE}" != "postinst" ]]; then
1156	[[ ${EBUILD_PHASE} != "postinst" ]] && die "${FUNCNAME} should only be run in pkg_postinst()"	2740	die "${FUNCNAME}() can be used only in pkg_postinst() phase"
		2741	fi
1157		2742
		2743	_python_check_python_pkg_setup_execution
		2744	_python_initialize_prefix_variables
		2745
		2746	if ! has "${EAPI:-0}" 0 1 2 \|\| _python_package_supporting_installation_for_multiple_python_abis \|\| _python_implementation \|\| [[ "${CATEGORY}/${PN}" == "sys-apps/portage" ]]; then
		2747	# PYTHON_ABI variable cannot be local in packages not supporting installation for multiple Python ABIs.
		2748	local allow_evaluated_non_sitedir_paths="0" dir dirs=() evaluated_dirs=() evaluated_files=() file files=() iterated_PYTHON_ABIS options=() other_dirs=() other_files=() previous_PYTHON_ABI="${PYTHON_ABI}" return_code root site_packages_dirs=() site_packages_files=() stderr stderr_line
		2749
		2750	if _python_package_supporting_installation_for_multiple_python_abis; then
1158	if ! has "${EAPI:-0}" 0 1 2 \|\| [[ -n "${SUPPORT_PYTHON_ABIS}" ]]; then	2751	if has "${EAPI:-0}" 0 1 2 3 && [[ -z "${PYTHON_ABIS}" ]]; then
1159	local dir file options=() other_dirs=() other_files=() PYTHON_ABI return_code root site_packages_absolute_dirs=() site_packages_dirs=() site_packages_absolute_files=() site_packages_files=()	2752	die "${FUNCNAME}(): python_pkg_setup() or python_execute_function() not called"
		2753	fi
		2754	iterated_PYTHON_ABIS="${PYTHON_ABIS}"
		2755	else
		2756	if has "${EAPI:-0}" 0 1 2 3; then
		2757	iterated_PYTHON_ABIS="${PYTHON_ABI:=$(PYTHON --ABI)}"
		2758	else
		2759	iterated_PYTHON_ABIS="${PYTHON_ABI}"
		2760	fi
		2761	fi
1160		2762
1161	# Strip trailing slash from ROOT.	2763	# Strip trailing slash from EROOT.
1162	root="${ROOT%/}"	2764	root="${EROOT%/}"
1163		2765
1164	# Respect ROOT and options passed to compileall.py.
1165	while (($#)); do	2766	while (($#)); do
1166	case "$1" in	2767	case "$1" in
		2768	--allow-evaluated-non-sitedir-paths)
		2769	allow_evaluated_non_sitedir_paths="1"
		2770	;;
1167	-l\|-f\|-q)	2771	-l\|-f\|-q)
1168	options+=("$1")	2772	options+=("$1")
1169	;;	2773	;;
1170	-d\|-x)	2774	-d\|-x)
1171	options+=("$1" "$2")	2775	options+=("$1" "$2")
1172	shift	2776	shift
1173	;;	2777	;;
		2778	--)
		2779	shift
		2780	break
		2781	;;
1174	-*)	2782	-*)
1175	ewarn "${FUNCNAME}: Ignoring compile option $1"	2783	die "${FUNCNAME}(): Unrecognized option '$1'"
1176	;;	2784	;;
1177	*)	2785	*)
1178	if ! _python_implementation && [[ "$1" =~ ^/usr/lib(32\|64)?/python[[:digit:]]+\.[[:digit:]]+ ]]; then
1179	die "${FUNCNAME} does not support absolute paths of directories/files in site-packages directories"
1180	elif [[ "$1" =~ ^/ ]]; then
1181	if [[ -d "${root}/$1" ]]; then
1182	other_dirs+=("${root}/$1")
1183	elif [[ -f "${root}/$1" ]]; then
1184	other_files+=("${root}/$1")
1185	elif [[ -e "${root}/$1" ]]; then
1186	ewarn "'${root}/$1' is not a file or a directory!"
1187	else
1188	ewarn "'${root}/$1' does not exist!"
1189	fi
1190	else
1191	for PYTHON_ABI in ${PYTHON_ABIS-${PYTHON_ABI-$(PYTHON -A --ABI)}}; do
1192	if [[ -d "${root}$(python_get_sitedir)/$1" ]]; then
1193	site_packages_dirs+=("$1")
1194	break	2786	break
1195	elif [[ -f "${root}$(python_get_sitedir)/$1" ]]; then
1196	site_packages_files+=("$1")
1197	break
1198	elif [[ -e "${root}$(python_get_sitedir)/$1" ]]; then
1199	ewarn "'$1' is not a file or a directory!"
1200	else
1201	ewarn "'$1' does not exist!"
1202	fi
1203	done
1204	fi
1205	;;	2787	;;
1206	esac	2788	esac
1207	shift	2789	shift
1208	done	2790	done
1209		2791
		2792	if [[ "${allow_evaluated_non_sitedir_paths}" == "1" ]] && ! _python_package_supporting_installation_for_multiple_python_abis; then
		2793	die "${FUNCNAME}(): '--allow-evaluated-non-sitedir-paths' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		2794	fi
		2795
		2796	if [[ "$#" -eq 0 ]]; then
		2797	die "${FUNCNAME}(): Missing files or directories"
		2798	fi
		2799
		2800	while (($#)); do
		2801	if [[ "$1" =~ ^($\|(\.\|\.\.\|/)($\|/)) ]]; then
		2802	die "${FUNCNAME}(): Invalid argument '$1'"
		2803	elif ! _python_implementation && [[ "$1" =~ ^/usr/lib(32\|64)?/python[[:digit:]]+\.[[:digit:]]+ ]]; then
		2804	die "${FUNCNAME}(): Paths of directories / files in site-packages directories must be relative to site-packages directories"
		2805	elif [[ "$1" =~ ^/ ]]; then
		2806	if _python_package_supporting_installation_for_multiple_python_abis; then
		2807	if [[ "${allow_evaluated_non_sitedir_paths}" != "1" ]]; then
		2808	die "${FUNCNAME}(): Absolute paths cannot be used in ebuilds of packages supporting installation for multiple Python ABIs"
		2809	fi
		2810	if [[ "$1" != \$ ]]; then
		2811	die "${FUNCNAME}(): '$1' has invalid syntax"
		2812	fi
		2813	if [[ "$1" == *.py ]]; then
		2814	evaluated_files+=("$1")
		2815	else
		2816	evaluated_dirs+=("$1")
		2817	fi
		2818	else
		2819	if [[ -d "${root}$1" ]]; then
		2820	other_dirs+=("${root}$1")
		2821	elif [[ -f "${root}$1" ]]; then
		2822	other_files+=("${root}$1")
		2823	elif [[ -e "${root}$1" ]]; then
		2824	eerror "${FUNCNAME}(): '${root}$1' is not a regular file or a directory"
		2825	else
		2826	eerror "${FUNCNAME}(): '${root}$1' does not exist"
		2827	fi
		2828	fi
		2829	else
		2830	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do
		2831	if [[ -d "${root}$(python_get_sitedir)/$1" ]]; then
		2832	site_packages_dirs+=("$1")
		2833	break
		2834	elif [[ -f "${root}$(python_get_sitedir)/$1" ]]; then
		2835	site_packages_files+=("$1")
		2836	break
		2837	elif [[ -e "${root}$(python_get_sitedir)/$1" ]]; then
		2838	eerror "${FUNCNAME}(): '$1' is not a regular file or a directory"
		2839	else
		2840	eerror "${FUNCNAME}(): '$1' does not exist"
		2841	fi
		2842	done
		2843	fi
		2844	shift
		2845	done
		2846
1210	# Set additional options.	2847	# Set additional options.
1211	options+=("-q")	2848	options+=("-q")
1212		2849
1213	for PYTHON_ABI in ${PYTHON_ABIS-${PYTHON_ABI-$(PYTHON -A --ABI)}}; do	2850	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do
1214	if ((${#site_packages_dirs[@]})) \|\| ((${#site_packages_files[@]})); then	2851	if ((${#site_packages_dirs[@]})) \|\| ((${#site_packages_files[@]})) \|\| ((${#evaluated_dirs[@]})) \|\| ((${#evaluated_files[@]})); then
1215	return_code="0"	2852	return_code="0"
1216	ebegin "Compilation and optimization of Python modules for Python ${PYTHON_ABI}"	2853	stderr=""
1217	if ((${#site_packages_dirs[@]})); then	2854	ebegin "Compilation and optimization of Python modules for $(python_get_implementation_and_version)"
		2855	if ((${#site_packages_dirs[@]})) \|\| ((${#evaluated_dirs[@]})); then
1218	for dir in "${site_packages_dirs[@]}"; do	2856	for dir in "${site_packages_dirs[@]}"; do
1219	site_packages_absolute_dirs+=("${root}$(python_get_sitedir)/${dir}")	2857	dirs+=("${root}$(python_get_sitedir)/${dir}")
1220	done	2858	done
1221	"$(PYTHON)" "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${site_packages_absolute_dirs[@]}" \|\| return_code="1"	2859	for dir in "${evaluated_dirs[@]}"; do
		2860	eval "dirs+=(\"\${root}${dir}\")"
		2861	done
		2862	stderr+="${stderr:+$'\n'}$("$(PYTHON)" -m compileall "${options[@]}" "${dirs[@]}" 2>&1)" \|\| return_code="1"
		2863	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" != "Jython" ]]; then
1222	"$(PYTHON)" -O "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${site_packages_absolute_dirs[@]}" &> /dev/null \|\| return_code="1"	2864	"$(PYTHON)" -O -m compileall "${options[@]}" "${dirs[@]}" &> /dev/null \|\| return_code="1"
1223	fi	2865	fi
1224	if ((${#site_packages_files[@]})); then	2866	_python_clean_compiled_modules "${dirs[@]}"
		2867	fi
		2868	if ((${#site_packages_files[@]})) \|\| ((${#evaluated_files[@]})); then
1225	for file in "${site_packages_files[@]}"; do	2869	for file in "${site_packages_files[@]}"; do
1226	site_packages_absolute_files+=("${root}$(python_get_sitedir)/${file}")	2870	files+=("${root}$(python_get_sitedir)/${file}")
1227	done	2871	done
1228	"$(PYTHON)" "${root}$(python_get_libdir)/py_compile.py" "${site_packages_absolute_files[@]}" \|\| return_code="1"	2872	for file in "${evaluated_files[@]}"; do
1229	"$(PYTHON)" -O "${root}$(python_get_libdir)/py_compile.py" "${site_packages_absolute_files[@]}" &> /dev/null \|\| return_code="1"	2873	eval "files+=(\"\${root}${file}\")"
		2874	done
		2875	stderr+="${stderr:+$'\n'}$("$(PYTHON)" -m py_compile "${files[@]}" 2>&1)" \|\| return_code="1"
		2876	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" != "Jython" ]]; then
		2877	"$(PYTHON)" -O -m py_compile "${files[@]}" &> /dev/null \|\| return_code="1"
		2878	fi
		2879	_python_clean_compiled_modules "${files[@]}"
1230	fi	2880	fi
1231	eend "${return_code}"	2881	eend "${return_code}"
		2882	if [[ -n "${stderr}" ]]; then
		2883	eerror "Syntax errors / warnings in Python modules for $(python_get_implementation_and_version):" &> /dev/null
		2884	while read stderr_line; do
		2885	eerror " ${stderr_line}"
		2886	done <<< "${stderr}"
1232	fi	2887	fi
1233	unset site_packages_absolute_dirs site_packages_absolute_files	2888	fi
		2889	unset dirs files
1234	done	2890	done
1235		2891
1236	# Do not use PYTHON_ABI in next calls to python_get_libdir().	2892	if _python_package_supporting_installation_for_multiple_python_abis; then
		2893	# Restore previous value of PYTHON_ABI.
		2894	if [[ -n "${previous_PYTHON_ABI}" ]]; then
		2895	PYTHON_ABI="${previous_PYTHON_ABI}"
		2896	else
1237	unset PYTHON_ABI	2897	unset PYTHON_ABI
		2898	fi
		2899	fi
1238		2900
1239	if ((${#other_dirs[@]})) \|\| ((${#other_files[@]})); then	2901	if ((${#other_dirs[@]})) \|\| ((${#other_files[@]})); then
1240	return_code="0"	2902	return_code="0"
		2903	stderr=""
1241	ebegin "Compilation and optimization of Python modules placed outside of site-packages directories for Python $(PYTHON -A --ABI)"	2904	ebegin "Compilation and optimization of Python modules placed outside of site-packages directories for $(python_get_implementation_and_version)"
1242	if ((${#other_dirs[@]})); then	2905	if ((${#other_dirs[@]})); then
1243	"$(PYTHON -A)" "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${other_dirs[@]}" \|\| return_code="1"	2906	stderr+="${stderr:+$'\n'}$("$(PYTHON ${PYTHON_ABI})" -m compileall "${options[@]}" "${other_dirs[@]}" 2>&1)" \|\| return_code="1"
		2907	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" != "Jython" ]]; then
1244	"$(PYTHON -A)" -O "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${other_dirs[@]}" &> /dev/null \|\| return_code="1"	2908	"$(PYTHON ${PYTHON_ABI})" -O -m compileall "${options[@]}" "${other_dirs[@]}" &> /dev/null \|\| return_code="1"
		2909	fi
		2910	_python_clean_compiled_modules "${other_dirs[@]}"
1245	fi	2911	fi
1246	if ((${#other_files[@]})); then	2912	if ((${#other_files[@]})); then
1247	"$(PYTHON -A)" "${root}$(python_get_libdir)/py_compile.py" "${other_files[@]}" \|\| return_code="1"	2913	stderr+="${stderr:+$'\n'}$("$(PYTHON ${PYTHON_ABI})" -m py_compile "${other_files[@]}" 2>&1)" \|\| return_code="1"
		2914	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" != "Jython" ]]; then
1248	"$(PYTHON -A)" -O "${root}$(python_get_libdir)/py_compile.py" "${other_files[@]}" &> /dev/null \|\| return_code="1"	2915	"$(PYTHON ${PYTHON_ABI})" -O -m py_compile "${other_files[@]}" &> /dev/null \|\| return_code="1"
		2916	fi
		2917	_python_clean_compiled_modules "${other_files[@]}"
1249	fi	2918	fi
1250	eend "${return_code}"	2919	eend "${return_code}"
		2920	if [[ -n "${stderr}" ]]; then
		2921	eerror "Syntax errors / warnings in Python modules placed outside of site-packages directories for $(python_get_implementation_and_version):" &> /dev/null
		2922	while read stderr_line; do
		2923	eerror " ${stderr_line}"
		2924	done <<< "${stderr}"
1251	fi	2925	fi
		2926	fi
1252	else	2927	else
		2928	# Deprecated part of python_mod_optimize()
		2929	ewarn
		2930	ewarn "Deprecation Warning: Usage of ${FUNCNAME}() in packages not supporting installation"
		2931	ewarn "for multiple Python ABIs in EAPI <=2 is deprecated and will be disallowed on 2011-08-01."
		2932	ewarn "Use EAPI >=3 and call ${FUNCNAME}() with paths having appropriate syntax."
		2933	ewarn "The ebuild needs to be fixed. Please report a bug, if it has not been already reported."
		2934	ewarn
		2935
1253	local myroot mydirs=() myfiles=() myopts=() return_code="0"	2936	local myroot mydirs=() myfiles=() myopts=() return_code="0"
1254		2937
1255	# strip trailing slash	2938	# strip trailing slash
1256	myroot="${ROOT%/}"	2939	myroot="${EROOT%/}"
1257		2940
1258	# respect ROOT and options passed to compileall.py	2941	# respect EROOT and options passed to compileall.py
1259	while (($#)); do	2942	while (($#)); do
1260	case "$1" in	2943	case "$1" in
1261	-l\|-f\|-q)	2944	-l\|-f\|-q)
1262	myopts+=("$1")	2945	myopts+=("$1")
1263	;;	2946	;;
1264	-d\|-x)	2947	-d\|-x)
1265	myopts+=("$1" "$2")	2948	myopts+=("$1" "$2")
1266	shift	2949	shift
1267	;;	2950	;;
		2951	--)
		2952	shift
		2953	break
		2954	;;
1268	-*)	2955	-*)
1269	ewarn "${FUNCNAME}: Ignoring compile option $1"	2956	die "${FUNCNAME}(): Unrecognized option '$1'"
1270	;;	2957	;;
1271	*)	2958	*)
1272	if [[ -d "${myroot}"/$1 ]]; then	2959	break
1273	mydirs+=("${myroot}/$1")
1274	elif [[ -f "${myroot}"/$1 ]]; then
1275	# Files are passed to python_mod_compile which is ROOT-aware
1276	myfiles+=("$1")
1277	elif [[ -e "${myroot}/$1" ]]; then
1278	ewarn "${myroot}/$1 is not a file or directory!"
1279	else
1280	ewarn "${myroot}/$1 does not exist!"
1281	fi
1282	;;	2960	;;
1283	esac	2961	esac
1284	shift	2962	shift
1285	done	2963	done
1286		2964
		2965	if [[ "$#" -eq 0 ]]; then
		2966	die "${FUNCNAME}(): Missing files or directories"
		2967	fi
		2968
		2969	while (($#)); do
		2970	if [[ "$1" =~ ^($\|(\.\|\.\.\|/)($\|/)) ]]; then
		2971	die "${FUNCNAME}(): Invalid argument '$1'"
		2972	elif [[ -d "${myroot}/${1#/}" ]]; then
		2973	mydirs+=("${myroot}/${1#/}")
		2974	elif [[ -f "${myroot}/${1#/}" ]]; then
		2975	myfiles+=("${myroot}/${1#/}")
		2976	elif [[ -e "${myroot}/${1#/}" ]]; then
		2977	eerror "${FUNCNAME}(): ${myroot}/${1#/} is not a regular file or directory"
		2978	else
		2979	eerror "${FUNCNAME}(): ${myroot}/${1#/} does not exist"
		2980	fi
		2981	shift
		2982	done
		2983
1287	# set additional opts	2984	# set additional opts
1288	myopts+=(-q)	2985	myopts+=(-q)
1289		2986
1290	ebegin "Compilation and optimization of Python modules for Python $(PYTHON -A --ABI)"	2987	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		2988
		2989	ebegin "Compilation and optimization of Python modules for $(python_get_implementation) $(python_get_version)"
1291	if ((${#mydirs[@]})); then	2990	if ((${#mydirs[@]})); then
1292	"$(PYTHON -A)" "${myroot}$(python_get_libdir)/compileall.py" "${myopts[@]}" "${mydirs[@]}" \|\| return_code="1"	2991	"$(PYTHON ${PYTHON_ABI})" "${myroot}$(python_get_libdir)/compileall.py" "${myopts[@]}" "${mydirs[@]}" \|\| return_code="1"
1293	"$(PYTHON -A)" -O "${myroot}$(python_get_libdir)/compileall.py" "${myopts[@]}" "${mydirs[@]}" &> /dev/null \|\| return_code="1"	2992	"$(PYTHON ${PYTHON_ABI})" -O "${myroot}$(python_get_libdir)/compileall.py" "${myopts[@]}" "${mydirs[@]}" &> /dev/null \|\| return_code="1"
		2993	_python_clean_compiled_modules "${mydirs[@]}"
1294	fi	2994	fi
1295		2995
1296	if ((${#myfiles[@]})); then	2996	if ((${#myfiles[@]})); then
		2997	"$(PYTHON ${PYTHON_ABI})" "${myroot}$(python_get_libdir)/py_compile.py" "${myfiles[@]}" \|\| return_code="1"
		2998	"$(PYTHON ${PYTHON_ABI})" -O "${myroot}$(python_get_libdir)/py_compile.py" "${myfiles[@]}" &> /dev/null \|\| return_code="1"
1297	python_mod_compile "${myfiles[@]}"	2999	_python_clean_compiled_modules "${myfiles[@]}"
1298	fi	3000	fi
1299		3001
1300	eend "${return_code}"	3002	eend "${return_code}"
1301	fi	3003	fi
1302	}	3004	}
1303		3005
1304	# @FUNCTION: python_mod_cleanup	3006	# @FUNCTION: python_mod_cleanup
1305	# @USAGE: [directory\|file]	3007	# @USAGE: [--allow-evaluated-non-sitedir-paths] [--] <file\|directory> [files\|directories]
1306	# @DESCRIPTION:	3008	# @DESCRIPTION:
1307	# Run with optional arguments, where arguments are Python modules. If none given,	3009	# Delete orphaned byte-compiled Python modules corresponding to specified Python modules.
1308	# it will look in /usr/lib/python[0-9].[0-9].
1309	#	3010	#
1310	# It will recursively scan all compiled Python modules in the directories and
1311	# determine if they are orphaned (i.e. their corresponding .py files are missing.)
1312	# If they are, then it will remove their corresponding .pyc and .pyo files.
1313	#
1314	# This function should only be run in pkg_postrm().	3011	# This function can be used only in pkg_postrm() phase.
1315	python_mod_cleanup() {	3012	python_mod_cleanup() {
1316	local path py_file PYTHON_ABI SEARCH_PATH=() root	3013	if [[ "${EBUILD_PHASE}" != "postrm" ]]; then
		3014	die "${FUNCNAME}() can be used only in pkg_postrm() phase"
		3015	fi
1317		3016
1318	# Check if phase is pkg_postrm().	3017	_python_check_python_pkg_setup_execution
1319	[[ ${EBUILD_PHASE} != "postrm" ]] && die "${FUNCNAME} should only be run in pkg_postrm()"	3018	_python_initialize_prefix_variables
1320		3019
		3020	local allow_evaluated_non_sitedir_paths="0" dir iterated_PYTHON_ABIS PYTHON_ABI="${PYTHON_ABI}" root search_paths=() sitedir
		3021
		3022	if _python_package_supporting_installation_for_multiple_python_abis; then
		3023	if has "${EAPI:-0}" 0 1 2 3 && [[ -z "${PYTHON_ABIS}" ]]; then
		3024	die "${FUNCNAME}(): python_pkg_setup() or python_execute_function() not called"
		3025	fi
		3026	iterated_PYTHON_ABIS="${PYTHON_ABIS}"
		3027	else
		3028	if has "${EAPI:-0}" 0 1 2 3; then
		3029	iterated_PYTHON_ABIS="${PYTHON_ABI:-$(PYTHON --ABI)}"
		3030	else
		3031	iterated_PYTHON_ABIS="${PYTHON_ABI}"
		3032	fi
		3033	fi
		3034
1321	# Strip trailing slash from ROOT.	3035	# Strip trailing slash from EROOT.
1322	root="${ROOT%/}"	3036	root="${EROOT%/}"
1323		3037
1324	if (($#)); then	3038	while (($#)); do
1325	if ! has "${EAPI:-0}" 0 1 2 \|\| [[ -n "${SUPPORT_PYTHON_ABIS}" ]]; then	3039	case "$1" in
		3040	--allow-evaluated-non-sitedir-paths)
		3041	allow_evaluated_non_sitedir_paths="1"
		3042	;;
		3043	--)
		3044	shift
		3045	break
		3046	;;
		3047	-*)
		3048	die "${FUNCNAME}(): Unrecognized option '$1'"
		3049	;;
		3050	*)
		3051	break
		3052	;;
		3053	esac
		3054	shift
		3055	done
		3056
		3057	if [[ "${allow_evaluated_non_sitedir_paths}" == "1" ]] && ! _python_package_supporting_installation_for_multiple_python_abis; then
		3058	die "${FUNCNAME}(): '--allow-evaluated-non-sitedir-paths' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		3059	fi
		3060
		3061	if [[ "$#" -eq 0 ]]; then
		3062	die "${FUNCNAME}(): Missing files or directories"
		3063	fi
		3064
		3065	if ! has "${EAPI:-0}" 0 1 2 \|\| _python_package_supporting_installation_for_multiple_python_abis \|\| _python_implementation \|\| [[ "${CATEGORY}/${PN}" == "sys-apps/portage" ]]; then
1326	while (($#)); do	3066	while (($#)); do
		3067	if [[ "$1" =~ ^($\|(\.\|\.\.\|/)($\|/)) ]]; then
		3068	die "${FUNCNAME}(): Invalid argument '$1'"
1327	if ! _python_implementation && [[ "$1" =~ ^/usr/lib(32\|64)?/python[[:digit:]]+\.[[:digit:]]+ ]]; then	3069	elif ! _python_implementation && [[ "$1" =~ ^/usr/lib(32\|64)?/python[[:digit:]]+\.[[:digit:]]+ ]]; then
1328	die "${FUNCNAME} does not support absolute paths of directories/files in site-packages directories"	3070	die "${FUNCNAME}(): Paths of directories / files in site-packages directories must be relative to site-packages directories"
1329	elif [[ "$1" =~ ^/ ]]; then	3071	elif [[ "$1" =~ ^/ ]]; then
1330	SEARCH_PATH+=("${root}/${1#/}")	3072	if _python_package_supporting_installation_for_multiple_python_abis; then
		3073	if [[ "${allow_evaluated_non_sitedir_paths}" != "1" ]]; then
		3074	die "${FUNCNAME}(): Absolute paths cannot be used in ebuilds of packages supporting installation for multiple Python ABIs"
		3075	fi
		3076	if [[ "$1" != \$ ]]; then
		3077	die "${FUNCNAME}(): '$1' has invalid syntax"
		3078	fi
		3079	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do
		3080	eval "search_paths+=(\"\${root}$1\")"
		3081	done
1331	else	3082	else
1332	for PYTHON_ABI in ${PYTHON_ABIS-${PYTHON_ABI-$(PYTHON -A --ABI)}}; do	3083	search_paths+=("${root}$1")
1333	SEARCH_PATH+=("${root}$(python_get_sitedir)/$1")
1334	done
1335	fi
1336	shift
1337	done
1338	else
1339	SEARCH_PATH=("${@#/}")
1340	SEARCH_PATH=("${SEARCH_PATH[@]/#/${root}/}")
1341	fi
1342	else
1343	local dir sitedir
1344	for dir in "${root}"/usr/lib*; do
1345	if [[ -d "${dir}" && ! -L "${dir}" ]]; then
1346	for sitedir in "${dir}"/python*/site-packages; do
1347	if [[ -d "${sitedir}" ]]; then
1348	SEARCH_PATH+=("${sitedir}")
1349	fi	3084	fi
		3085	else
		3086	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do
		3087	search_paths+=("${root}$(python_get_sitedir)/$1")
1350	done	3088	done
1351	fi	3089	fi
		3090	shift
1352	done	3091	done
1353	fi
1354
1355	local BLUE CYAN NORMAL
1356	if [[ "${NOCOLOR:-false}" =~ ^(false\|no)$ ]]; then
1357	BLUE=$'\e[1;34m'
1358	CYAN=$'\e[1;36m'
1359	NORMAL=$'\e[0m'
1360	else	3092	else
1361	BLUE=	3093	# Deprecated part of python_mod_cleanup()
1362	CYAN=	3094	ewarn
1363	NORMAL=	3095	ewarn "Deprecation Warning: Usage of ${FUNCNAME}() in packages not supporting installation"
1364	fi	3096	ewarn "for multiple Python ABIs in EAPI <=2 is deprecated and will be disallowed on 2011-08-01."
		3097	ewarn "Use EAPI >=3 and call ${FUNCNAME}() with paths having appropriate syntax."
		3098	ewarn "The ebuild needs to be fixed. Please report a bug, if it has not been already reported."
		3099	ewarn
1365		3100
1366	for path in "${SEARCH_PATH[@]}"; do	3101	search_paths=("${@#/}")
1367	if [[ -d "${path}" ]]; then	3102	search_paths=("${search_paths[@]/#/${root}/}")
1368	find "${path}" -name '*.py[co]' -print0 \| while read -rd ''; do
1369	py_file="${REPLY%[co]}"
1370	[[ -f "${py_file}" \|\| (! -f "${py_file}c" && ! -f "${py_file}o") ]] && continue
1371	einfo "${BLUE}<<< ${py_file}[co]${NORMAL}"
1372	rm -f "${py_file}"[co]
1373	done
1374
1375	# Attempt to delete directories, which may be empty.
1376	find "${path}" -type d \| sort -r \| while read -r dir; do
1377	rmdir "${dir}" 2>/dev/null && einfo "${CYAN}<<< ${dir}${NORMAL}"
1378	done
1379	elif [[ "${path}" == *.py && ! -f "${path}" && (-f "${path}c" \|\| -f "${path}o") ]]; then
1380	einfo "${BLUE}<<< ${path}[co]${NORMAL}"
1381	rm -f "${path}"[co]
1382	fi	3103	fi
1383	done	3104
		3105	_python_clean_compiled_modules "${search_paths[@]}"
1384	}	3106	}
		3107
		3108	# ================================================================================================
		3109	# ===================================== DEPRECATED FUNCTIONS =====================================
		3110	# ================================================================================================

 Legend:



Removed from v.1.84
 


changed lines


 
Added in v.1.135
 Legend:



Removed from v.1.84
 


changed lines


 
Added in v.1.135
-Removed from v.1.84
+Added in v.1.135

	ViewVC Help
Powered by ViewVC 1.1.13