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

Diff of /eclass/python.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.95
 


changed lines


 
Added in v.1.158
 Legend:



Removed from v.1.95
 


changed lines


 
Added in v.1.158
-Removed from v.1.95
+Added in v.1.158

	ViewVC Help
Powered by ViewVC 1.1.13