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

Diff of /eclass/python.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.98
 


changed lines


 
Added in v.1.152
 Legend:



Removed from v.1.98
 


changed lines


 
Added in v.1.152
-Removed from v.1.98
+Added in v.1.152

	ViewVC Help
Powered by ViewVC 1.1.17