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

Diff of /eclass/python.eclass

Parent Directory | Revision Log | View Patch Patch

Revision 1.99		Revision 1.115
1	# Copyright 1999-2010 Gentoo Foundation	1	# Copyright 1999-2011 Gentoo Foundation
2	# Distributed under the terms of the GNU General Public License v2	2	# Distributed under the terms of the GNU General Public License v2
3	# $Header: /var/cvsroot/gentoo-x86/eclass/python.eclass,v 1.99 2010/05/25 19:49:54 arfrever Exp $	3	# $Header: /var/cvsroot/gentoo-x86/eclass/python.eclass,v 1.115 2011/07/04 11:27:29 djc 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
…		…
13		13
14	if ! has "${EAPI:-0}" 0 1 2 3; then	14	if ! has "${EAPI:-0}" 0 1 2 3; then
15	die "API of python.eclass in EAPI=\"${EAPI}\" not established"	15	die "API of python.eclass in EAPI=\"${EAPI}\" not established"
16	fi	16	fi
17		17
18	_CPYTHON2_SUPPORTED_ABIS=(2.4 2.5 2.6 2.7)	18	_CPYTHON2_GLOBALLY_SUPPORTED_ABIS=(2.4 2.5 2.6 2.7)
19	_CPYTHON3_SUPPORTED_ABIS=(3.0 3.1 3.2)	19	_CPYTHON3_GLOBALLY_SUPPORTED_ABIS=(3.0 3.1 3.2 3.3)
20	_JYTHON_SUPPORTED_ABIS=(2.5-jython)	20	_JYTHON_GLOBALLY_SUPPORTED_ABIS=(2.5-jython)
		21	_PYTHON_GLOBALLY_SUPPORTED_ABIS=(${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]} ${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]} ${_JYTHON_GLOBALLY_SUPPORTED_ABIS[@]})
		22
		23	# ================================================================================================
		24	# ===================================== HANDLING OF METADATA =====================================
		25	# ================================================================================================
		26
		27	_python_check_python_abi_matching() {
		28	local pattern patterns patterns_list="0" PYTHON_ABI
		29
		30	while (($#)); do
		31	case "$1" in
		32	--patterns-list)
		33	patterns_list="1"
		34	;;
		35	--)
		36	shift
		37	break
		38	;;
		39	-*)
		40	die "${FUNCNAME}(): Unrecognized option '$1'"
		41	;;
		42	*)
		43	break
		44	;;
		45	esac
		46	shift
		47	done
		48
		49	if [[ "$#" -ne 2 ]]; then
		50	die "${FUNCNAME}() requires 2 arguments"
		51	fi
		52
		53	PYTHON_ABI="$1"
		54
		55	if [[ "${patterns_list}" == "0" ]]; then
		56	pattern="$2"
		57
		58	if [[ "${pattern}" == *"-cpython" ]]; then
		59	[[ "${PYTHON_ABI}" =~ ^[[:digit:]]+\.[[:digit:]]+$ && "${PYTHON_ABI}" == ${pattern%-cpython} ]]
		60	elif [[ "${pattern}" == *"-jython" ]]; then
		61	[[ "${PYTHON_ABI}" == ${pattern} ]]
		62	else
		63	if [[ "${PYTHON_ABI}" =~ ^[[:digit:]]+\.[[:digit:]]+$ ]]; then
		64	[[ "${PYTHON_ABI}" == ${pattern} ]]
		65	elif [[ "${PYTHON_ABI}" =~ ^[[:digit:]]+\.[[:digit:]]+-jython$ ]]; then
		66	[[ "${PYTHON_ABI%-jython}" == ${pattern} ]]
		67	else
		68	die "${FUNCNAME}(): Unrecognized Python ABI '${PYTHON_ABI}'"
		69	fi
		70	fi
		71	else
		72	patterns="${2// /$'\n'}"
		73
		74	while read pattern; do
		75	if _python_check_python_abi_matching "${PYTHON_ABI}" "${pattern}"; then
		76	return 0
		77	fi
		78	done <<< "${patterns}"
		79
		80	return 1
		81	fi
		82	}
21		83
22	# @ECLASS-VARIABLE: PYTHON_DEPEND	84	# @ECLASS-VARIABLE: PYTHON_DEPEND
23	# @DESCRIPTION:	85	# @DESCRIPTION:
24	# Specification of dependency on dev-lang/python.	86	# Specification of dependency on dev-lang/python.
25	# Syntax:	87	# Syntax:
…		…
27	# version_components_group: <major_version[:[minimal_version][:maximal_version]]>	89	# version_components_group: <major_version[:[minimal_version][:maximal_version]]>
28	# major_version: <2\|3\|*>	90	# major_version: <2\|3\|*>
29	# minimal_version: <minimal_major_version.minimal_minor_version>	91	# minimal_version: <minimal_major_version.minimal_minor_version>
30	# maximal_version: <maximal_major_version.maximal_minor_version>	92	# maximal_version: <maximal_major_version.maximal_minor_version>
31		93
32	_parse_PYTHON_DEPEND() {	94	_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	95	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		96
35	version_components_group_regex="(2\|3\|\*)(:([[:digit:]]+\.[[:digit:]]+)?(:([[:digit:]]+\.[[:digit:]]+)?)?)?"	97	version_components_group_regex="(2\|3\|\*)(:([[:digit:]]+\.[[:digit:]]+)?(:([[:digit:]]+\.[[:digit:]]+)?)?)?"
36	version_components_groups="${PYTHON_DEPEND}"	98	version_components_groups="${PYTHON_DEPEND}"
37		99
…		…
60	fi	122	fi
61	fi	123	fi
62		124
63	if [[ "${major_version}" == "2" ]]; then	125	if [[ "${major_version}" == "2" ]]; then
64	python2="1"	126	python2="1"
65	python_versions=("${_CPYTHON2_SUPPORTED_ABIS[@]}")	127	python_versions=("${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}")
66	python2_minimal_version="${minimal_version}"	128	python2_minimal_version="${minimal_version}"
67	python2_maximal_version="${maximal_version}"	129	python2_maximal_version="${maximal_version}"
68	elif [[ "${major_version}" == "3" ]]; then	130	elif [[ "${major_version}" == "3" ]]; then
69	python3="1"	131	python3="1"
70	python_versions=("${_CPYTHON3_SUPPORTED_ABIS[@]}")	132	python_versions=("${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}")
71	python3_minimal_version="${minimal_version}"	133	python3_minimal_version="${minimal_version}"
72	python3_maximal_version="${maximal_version}"	134	python3_maximal_version="${maximal_version}"
73	else	135	else
74	python_all="1"	136	python_all="1"
75	python_versions=("${_CPYTHON2_SUPPORTED_ABIS[@]}" "${_CPYTHON3_SUPPORTED_ABIS[@]}")	137	python_versions=("${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}" "${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}")
76	python_minimal_version="${minimal_version}"	138	python_minimal_version="${minimal_version}"
77	python_maximal_version="${maximal_version}"	139	python_maximal_version="${maximal_version}"
78	fi	140	fi
79		141
80	if [[ -n "${minimal_version}" ]] && ! has "${minimal_version}" "${python_versions[@]}"; then	142	if [[ -n "${minimal_version}" ]] && ! has "${minimal_version}" "${python_versions[@]}"; then
…		…
108		170
109	if [[ "${python_all}" == "1" ]]; then	171	if [[ "${python_all}" == "1" ]]; then
110	if [[ -z "${python_minimal_version}" && -z "${python_maximal_version}" ]]; then	172	if [[ -z "${python_minimal_version}" && -z "${python_maximal_version}" ]]; then
111	_PYTHON_ATOMS+=("dev-lang/python")	173	_PYTHON_ATOMS+=("dev-lang/python")
112	else	174	else
113	python_versions=("${_CPYTHON2_SUPPORTED_ABIS[@]}" "${_CPYTHON3_SUPPORTED_ABIS[@]}")	175	python_versions=("${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}" "${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}")
114	python_minimal_version="${python_minimal_version:-${python_versions[0]}}"	176	python_minimal_version="${python_minimal_version:-${python_versions[0]}}"
115	python_maximal_version="${python_maximal_version:-${python_versions[${#python_versions[@]}-1]}}"	177	python_maximal_version="${python_maximal_version:-${python_versions[${#python_versions[@]}-1]}}"
116	_append_accepted_versions_range	178	_append_accepted_versions_range
117	fi	179	fi
118	else	180	else
119	if [[ "${python3}" == "1" ]]; then	181	if [[ "${python3}" == "1" ]]; then
120	if [[ -z "${python3_minimal_version}" && -z "${python3_maximal_version}" ]]; then	182	if [[ -z "${python3_minimal_version}" && -z "${python3_maximal_version}" ]]; then
121	_PYTHON_ATOMS+=("=dev-lang/python-3*")	183	_PYTHON_ATOMS+=("=dev-lang/python-3*")
122	else	184	else
123	python_versions=("${_CPYTHON3_SUPPORTED_ABIS[@]}")	185	python_versions=("${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}")
124	python_minimal_version="${python3_minimal_version:-${python_versions[0]}}"	186	python_minimal_version="${python3_minimal_version:-${python_versions[0]}}"
125	python_maximal_version="${python3_maximal_version:-${python_versions[${#python_versions[@]}-1]}}"	187	python_maximal_version="${python3_maximal_version:-${python_versions[${#python_versions[@]}-1]}}"
126	_append_accepted_versions_range	188	_append_accepted_versions_range
127	fi	189	fi
128	fi	190	fi
129	if [[ "${python2}" == "1" ]]; then	191	if [[ "${python2}" == "1" ]]; then
130	if [[ -z "${python2_minimal_version}" && -z "${python2_maximal_version}" ]]; then	192	if [[ -z "${python2_minimal_version}" && -z "${python2_maximal_version}" ]]; then
131	_PYTHON_ATOMS+=("=dev-lang/python-2*")	193	_PYTHON_ATOMS+=("=dev-lang/python-2*")
132	else	194	else
133	python_versions=("${_CPYTHON2_SUPPORTED_ABIS[@]}")	195	python_versions=("${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}")
134	python_minimal_version="${python2_minimal_version:-${python_versions[0]}}"	196	python_minimal_version="${python2_minimal_version:-${python_versions[0]}}"
135	python_maximal_version="${python2_maximal_version:-${python_versions[${#python_versions[@]}-1]}}"	197	python_maximal_version="${python2_maximal_version:-${python_versions[${#python_versions[@]}-1]}}"
136	_append_accepted_versions_range	198	_append_accepted_versions_range
137	fi	199	fi
138	fi	200	fi
…		…
153	}	215	}
154		216
155	DEPEND=">=app-admin/eselect-python-20091230"	217	DEPEND=">=app-admin/eselect-python-20091230"
156	RDEPEND="${DEPEND}"	218	RDEPEND="${DEPEND}"
157		219
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	220	if [[ -n "${PYTHON_DEPEND}" ]]; then
161	_parse_PYTHON_DEPEND	221	_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	222	else
171	_PYTHON_ATOMS=("dev-lang/python")	223	_PYTHON_ATOMS=("dev-lang/python")
		224	fi
		225	unset -f _python_parse_PYTHON_DEPEND
		226
		227	if [[ -n "${NEED_PYTHON}" ]]; then
		228	eerror "Use PYTHON_DEPEND variable instead of NEED_PYTHON variable."
		229	die "NEED_PYTHON variable is banned"
172	fi	230	fi
173		231
174	# @ECLASS-VARIABLE: PYTHON_USE_WITH	232	# @ECLASS-VARIABLE: PYTHON_USE_WITH
175	# @DESCRIPTION:	233	# @DESCRIPTION:
176	# Set this to a space separated list of USE flags the Python slot in use must be built with.	234	# Set this to a space separated list of USE flags the Python slot in use must be built with.
…		…
241	else	299	else
242	die "${FUNCNAME}(): Support for EAPI=\"${EAPI}\" not implemented"	300	die "${FUNCNAME}(): Support for EAPI=\"${EAPI}\" not implemented"
243	fi	301	fi
244	}	302	}
245		303
		304	_python_abi-specific_local_scope() {
		305	[[ " ${FUNCNAME[@]:2} " =~ " "(_python_final_sanity_checks\|python_execute_function\|python_mod_optimize\|python_mod_cleanup)" " ]]
		306	}
		307
246	_python_initialize_prefix_variables() {	308	_python_initialize_prefix_variables() {
247	if has "${EAPI:-0}" 0 1 2; then	309	if has "${EAPI:-0}" 0 1 2; then
248	if [[ -n "${ROOT}" && -z "${EROOT}" ]]; then	310	if [[ -n "${ROOT}" && -z "${EROOT}" ]]; then
249	EROOT="${ROOT%/}${EPREFIX}/"	311	EROOT="${ROOT%/}${EPREFIX}/"
250	fi	312	fi
…		…
252	ED="${D%/}${EPREFIX}/"	314	ED="${D%/}${EPREFIX}/"
253	fi	315	fi
254	fi	316	fi
255	}	317	}
256		318
257	unset PYTHON_SANITY_CHECKS	319	unset PYTHON_SANITY_CHECKS_EXECUTED PYTHON_SKIP_SANITY_CHECKS
258		320
259	_python_initial_sanity_checks() {	321	_python_initial_sanity_checks() {
260	if [[ "$(declare -p PYTHON_SANITY_CHECKS 2> /dev/null)" != "declare -- PYTHON_SANITY_CHECKS="* ]]; then	322	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.	323	# Ensure that /usr/bin/python and /usr/bin/python-config are valid.
262	if [[ "$(readlink "${EPREFIX}/usr/bin/python")" != "python-wrapper" ]]; then	324	if [[ "$(readlink "${EPREFIX}/usr/bin/python")" != "python-wrapper" ]]; then
263	eerror "'${EPREFIX}/usr/bin/python' is not valid symlink."	325	eerror "'${EPREFIX}/usr/bin/python' is not valid symlink."
264	eerror "Use \`eselect python set \${python_interpreter}\` to fix this problem."	326	eerror "Use \`eselect python set \${python_interpreter}\` to fix this problem."
265	die "'${EPREFIX}/usr/bin/python' is not valid symlink"	327	die "'${EPREFIX}/usr/bin/python' is not valid symlink"
…		…
271	fi	333	fi
272	fi	334	fi
273	}	335	}
274		336
275	_python_final_sanity_checks() {	337	_python_final_sanity_checks() {
276	if ! _python_implementation && [[ "$(declare -p PYTHON_SANITY_CHECKS 2> /dev/null)" != "declare -- PYTHON_SANITY_CHECKS="* ]]; then	338	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}"	339	local PYTHON_ABI="${PYTHON_ABI}"
278	for PYTHON_ABI in ${PYTHON_ABIS-${PYTHON_ABI}}; do	340	for PYTHON_ABI in ${PYTHON_ABIS-${PYTHON_ABI}}; do
279	# Ensure that appropriate version of Python is installed.	341	# Ensure that appropriate version of Python is installed.
280	if ! has_version "$(python_get_implementational_package)"; then	342	if ! has_version "$(python_get_implementational_package)"; then
281	die "$(python_get_implementational_package) is not installed"	343	die "$(python_get_implementational_package) is not installed"
…		…
291	eerror "Locally active version of Python: '$(EPYTHON="$(PYTHON)" python -c "${_PYTHON_ABI_EXTRACTION_COMMAND}")'"	353	eerror "Locally active version of Python: '$(EPYTHON="$(PYTHON)" python -c "${_PYTHON_ABI_EXTRACTION_COMMAND}")'"
292	die "'python' does not respect EPYTHON variable"	354	die "'python' does not respect EPYTHON variable"
293	fi	355	fi
294	done	356	done
295	fi	357	fi
296	PYTHON_SANITY_CHECKS="1"	358	PYTHON_SANITY_CHECKS_EXECUTED="1"
297	}	359	}
		360
		361	# @ECLASS-VARIABLE: PYTHON_COLORS
		362	# @DESCRIPTION:
		363	# User-configurable colored output.
		364	PYTHON_COLORS="${PYTHON_COLORS:-0}"
298		365
299	_python_set_color_variables() {	366	_python_set_color_variables() {
300	if [[ "${NOCOLOR:-false}" =~ ^(false\|no)$ ]]; then	367	if [[ "${PYTHON_COLORS}" != "0" && "${NOCOLOR:-false}" =~ ^(false\|no)$ ]]; then
301	_BOLD=$'\e[1m'	368	_BOLD=$'\e[1m'
302	_RED=$'\e[1;31m'	369	_RED=$'\e[1;31m'
303	_GREEN=$'\e[1;32m'	370	_GREEN=$'\e[1;32m'
304	_BLUE=$'\e[1;34m'	371	_BLUE=$'\e[1;34m'
305	_CYAN=$'\e[1;36m'	372	_CYAN=$'\e[1;36m'
…		…
314	fi	381	fi
315	}	382	}
316		383
317	unset PYTHON_PKG_SETUP_EXECUTED	384	unset PYTHON_PKG_SETUP_EXECUTED
318		385
		386	_python_check_python_pkg_setup_execution() {
		387	[[ " ${FUNCNAME[@]:1} " =~ " "(python_set_active_version\|python_pkg_setup)" " ]] && return
		388
		389	if ! has "${EAPI:-0}" 0 1 2 3 && [[ -z "${PYTHON_PKG_SETUP_EXECUTED}" ]]; then
		390	die "python_pkg_setup() not called"
		391	fi
		392	}
		393
319	# @FUNCTION: python_pkg_setup	394	# @FUNCTION: python_pkg_setup
320	# @DESCRIPTION:	395	# @DESCRIPTION:
321	# Perform sanity checks and initialize environment.	396	# Perform sanity checks and initialize environment.
322	#	397	#
323	# This function is exported in EAPI 2 and 3 when PYTHON_USE_WITH or PYTHON_USE_WITH_OR variable	398	# 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.	399	# 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() {	400	python_pkg_setup() {
328	# Check if phase is pkg_setup().	401	if [[ "${EBUILD_PHASE}" != "setup" ]]; then
329	[[ "${EBUILD_PHASE}" != "setup" ]] && die "${FUNCNAME}() can be used only in pkg_setup() phase"	402	die "${FUNCNAME}() can be used only in pkg_setup() phase"
		403	fi
		404
		405	if [[ "$#" -ne 0 ]]; then
		406	die "${FUNCNAME}() does not accept arguments"
		407	fi
		408
		409	export JYTHON_SYSTEM_CACHEDIR="1"
		410	addwrite "${EPREFIX}/var/cache/jython"
330		411
331	if _python_package_supporting_installation_for_multiple_python_abis; then	412	if _python_package_supporting_installation_for_multiple_python_abis; then
332	_python_calculate_PYTHON_ABIS	413	_python_calculate_PYTHON_ABIS
333	export EPYTHON="$(PYTHON -f)"	414	export EPYTHON="$(PYTHON -f)"
334	else	415	else
…		…
366	die "Please rebuild ${python_atom} with at least one of the following USE flags enabled: ${PYTHON_USE_WITH_OR}"	447	die "Please rebuild ${python_atom} with at least one of the following USE flags enabled: ${PYTHON_USE_WITH_OR}"
367	fi	448	fi
368	}	449	}
369		450
370	if _python_package_supporting_installation_for_multiple_python_abis; then	451	if _python_package_supporting_installation_for_multiple_python_abis; then
371	python_execute_function -q python_pkg_setup_check_USE_flags	452	PYTHON_SKIP_SANITY_CHECKS="1" python_execute_function -q python_pkg_setup_check_USE_flags
372	else	453	else
373	python_pkg_setup_check_USE_flags	454	python_pkg_setup_check_USE_flags
374	fi	455	fi
375		456
376	unset -f python_pkg_setup_check_USE_flags	457	unset -f python_pkg_setup_check_USE_flags
377	fi	458	fi
378		459
379	PYTHON_PKG_SETUP_EXECUTED="1"	460	PYTHON_PKG_SETUP_EXECUTED="1"
380	}	461	}
381		462
382	if ! has "${EAPI:-0}" 0 1 2 3 \|\| has "${EAPI:-0}" 2 3 && [[ -n "${PYTHON_USE_WITH}" \|\| -n "${PYTHON_USE_WITH_OR}" ]]; then	463	if ! has "${EAPI:-0}" 0 1 2 3 \|\| { has "${EAPI:-0}" 2 3 && [[ -n "${PYTHON_USE_WITH}" \|\| -n "${PYTHON_USE_WITH_OR}" ]]; }; then
383	EXPORT_FUNCTIONS pkg_setup	464	EXPORT_FUNCTIONS pkg_setup
384	fi	465	fi
385		466
		467	_PYTHON_SHEBANG_BASE_PART_REGEX='^#![[:space:]]([^[:space:]]/usr/bin/env[[:space:]]+)?([^[:space:]]*/)?(jython\|python)'
		468
386	# @FUNCTION: python_convert_shebangs	469	# @FUNCTION: python_convert_shebangs
387	# @USAGE: [-q\|--quiet] [-r\|--recursive] [-x\|--only-executables] [--] <Python_version> <file\|directory> [files\|directories]	470	# @USAGE: [-q\|--quiet] [-r\|--recursive] [-x\|--only-executables] [--] <Python_ABI\|Python_version> <file\|directory> [files\|directories]
388	# @DESCRIPTION:	471	# @DESCRIPTION:
389	# Convert shebangs in specified files. Directories can be specified only with --recursive option.	472	# Convert shebangs in specified files. Directories can be specified only with --recursive option.
390	python_convert_shebangs() {	473	python_convert_shebangs() {
		474	_python_check_python_pkg_setup_execution
		475
391	local argument file files=() only_executables="0" python_version quiet="0" recursive="0"	476	local argument file files=() only_executables="0" python_interpreter quiet="0" recursive="0"
392		477
393	while (($#)); do	478	while (($#)); do
394	case "$1" in	479	case "$1" in
395	-r\|--recursive)	480	-r\|--recursive)
396	recursive="1"	481	recursive="1"
…		…
419	die "${FUNCNAME}(): Missing Python version and files or directories"	504	die "${FUNCNAME}(): Missing Python version and files or directories"
420	elif [[ "$#" -eq 1 ]]; then	505	elif [[ "$#" -eq 1 ]]; then
421	die "${FUNCNAME}(): Missing files or directories"	506	die "${FUNCNAME}(): Missing files or directories"
422	fi	507	fi
423		508
424	python_version="$1"	509	if [[ -n "$(_python_get_implementation --ignore-invalid "$1")" ]]; then
		510	python_interpreter="$(PYTHON "$1")"
		511	else
		512	python_interpreter="python$1"
		513	fi
425	shift	514	shift
426		515
427	for argument in "$@"; do	516	for argument in "$@"; do
428	if [[ ! -e "${argument}" ]]; then	517	if [[ ! -e "${argument}" ]]; then
429	die "${FUNCNAME}(): '${argument}' does not exist"	518	die "${FUNCNAME}(): '${argument}' does not exist"
…		…
444		533
445	for file in "${files[@]}"; do	534	for file in "${files[@]}"; do
446	file="${file#./}"	535	file="${file#./}"
447	[[ "${only_executables}" == "1" && ! -x "${file}" ]] && continue	536	[[ "${only_executables}" == "1" && ! -x "${file}" ]] && continue
448		537
449	if [[ "$(head -n1 "${file}")" =~ ^'#!'.*python ]]; then	538	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	539	[[ "$(sed -ne "2p" "${file}")" =~ ^"# Gentoo '".*"' wrapper script generated by python_generate_wrapper_scripts()"$ ]] && continue
451		540
452	if [[ "${quiet}" == "0" ]]; then	541	if [[ "${quiet}" == "0" ]]; then
453	einfo "Converting shebang in '${file}'"	542	einfo "Converting shebang in '${file}'"
454	fi	543	fi
455		544
456	sed -e "1s/python$[[:digit:]]\+\(\.[[:digit:]]\+$\?\)\?/python${python_version}/" -i "${file}" \|\| die "Conversion of shebang in '${file}' failed"	545	sed -e "1s:^#![[:space:]]$[^[:space:]]/usr/bin/env[[:space:]]$\?[[:space:]]$[^[:space:]]/$\?$jython\\|python$$[[:digit:]]\+\(\.[[:digit:]]\+$\?\)\?$\$\\|[[:space:]].*$:#!\1\2${python_interpreter}\6:" -i "${file}" \|\| die "Conversion of shebang in '${file}' failed"
457
458	# Delete potential whitespace after "#!".
459	sed -e '1s/$^#!$[[:space:]]*/\1/' -i "${file}" \|\| die "sed '${file}' failed"
460	fi	546	fi
461	done	547	done
462	}	548	}
463		549
464	# @FUNCTION: python_clean_installation_image	550	# @FUNCTION: python_clean_installation_image
465	# @USAGE: [-q\|--quiet]	551	# @USAGE: [-q\|--quiet]
466	# @DESCRIPTION:	552	# @DESCRIPTION:
467	# Delete needless files in installation image.	553	# Delete needless files in installation image.
		554	#
		555	# This function can be used only in src_install() phase.
468	python_clean_installation_image() {	556	python_clean_installation_image() {
		557	if [[ "${EBUILD_PHASE}" != "install" ]]; then
		558	die "${FUNCNAME}() can be used only in src_install() phase"
		559	fi
		560
		561	_python_check_python_pkg_setup_execution
469	_python_initialize_prefix_variables	562	_python_initialize_prefix_variables
470		563
471	local file files=() quiet="0"	564	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		565
476	while (($#)); do	566	while (($#)); do
477	case "$1" in	567	case "$1" in
478	-q\|--quiet)	568	-q\|--quiet)
479	quiet="1"	569	quiet="1"
…		…
533	# multiple Python ABIs.	623	# multiple Python ABIs.
534		624
535	# @ECLASS-VARIABLE: PYTHON_EXPORT_PHASE_FUNCTIONS	625	# @ECLASS-VARIABLE: PYTHON_EXPORT_PHASE_FUNCTIONS
536	# @DESCRIPTION:	626	# @DESCRIPTION:
537	# Set this to export phase functions for the following ebuild phases:	627	# Set this to export phase functions for the following ebuild phases:
538	# src_prepare, src_configure, src_compile, src_test, src_install.	628	# src_prepare(), src_configure(), src_compile(), src_test(), src_install().
539	if ! has "${EAPI:-0}" 0 1; then	629	if ! has "${EAPI:-0}" 0 1; then
540	python_src_prepare() {	630	python_src_prepare() {
		631	if [[ "${EBUILD_PHASE}" != "prepare" ]]; then
		632	die "${FUNCNAME}() can be used only in src_prepare() phase"
		633	fi
		634
541	if ! _python_package_supporting_installation_for_multiple_python_abis; then	635	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"	636	die "${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
543	fi	637	fi
544		638
		639	_python_check_python_pkg_setup_execution
		640
		641	if [[ "$#" -ne 0 ]]; then
		642	die "${FUNCNAME}() does not accept arguments"
		643	fi
		644
545	python_copy_sources	645	python_copy_sources
546	}	646	}
547		647
548	for python_default_function in src_configure src_compile src_test src_install; do	648	for python_default_function in src_configure src_compile src_test; do
549	eval "python_${python_default_function}() {	649	eval "python_${python_default_function}() {
		650	if [[ \"\${EBUILD_PHASE}\" != \"${python_default_function#src_}\" ]]; then
		651	die \"\${FUNCNAME}() can be used only in ${python_default_function}() phase\"
		652	fi
		653
550	if ! _python_package_supporting_installation_for_multiple_python_abis; then	654	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\"	655	die \"\${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs\"
552	fi	656	fi
553		657
		658	_python_check_python_pkg_setup_execution
		659
554	python_execute_function -d -s -- \"\$@\"	660	python_execute_function -d -s -- \"\$@\"
555	}"	661	}"
556	done	662	done
557	unset python_default_function	663	unset python_default_function
558		664
		665	python_src_install() {
		666	if [[ "${EBUILD_PHASE}" != "install" ]]; then
		667	die "${FUNCNAME}() can be used only in src_install() phase"
		668	fi
		669
		670	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		671	die "${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		672	fi
		673
		674	_python_check_python_pkg_setup_execution
		675
		676	if has "${EAPI:-0}" 0 1 2 3; then
		677	python_execute_function -d -s -- "$@"
		678	else
		679	python_installation() {
		680	emake DESTDIR="${T}/images/${PYTHON_ABI}" install "$@"
		681	}
		682	python_execute_function -s python_installation "$@"
		683	unset python_installation
		684
		685	python_merge_intermediate_installation_images "${T}/images"
		686	fi
		687	}
		688
559	if [[ -n "${PYTHON_EXPORT_PHASE_FUNCTIONS}" ]]; then	689	if [[ -n "${PYTHON_EXPORT_PHASE_FUNCTIONS}" ]]; then
560	EXPORT_FUNCTIONS src_prepare src_configure src_compile src_test src_install	690	EXPORT_FUNCTIONS src_prepare src_configure src_compile src_test src_install
561	fi	691	fi
562	fi	692	fi
563		693
		694	if has "${EAPI:-0}" 0 1 2 3 4; then
564	unset PYTHON_ABIS	695	unset PYTHON_ABIS
		696	fi
565		697
566	_python_calculate_PYTHON_ABIS() {	698	_python_calculate_PYTHON_ABIS() {
567	if ! _python_package_supporting_installation_for_multiple_python_abis; then	699	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"	700	die "${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
569	fi	701	fi
570		702
571	_python_initial_sanity_checks	703	_python_initial_sanity_checks
572		704
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	705	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=	706	local PYTHON_ABI restricted_ABI restricted_ABIs support_ABI supported_PYTHON_ABIS
576	PYTHON_ABI_SUPPORTED_VALUES="${_CPYTHON2_SUPPORTED_ABIS[@]} ${_CPYTHON3_SUPPORTED_ABIS[@]} ${_JYTHON_SUPPORTED_ABIS[@]}"	707
		708	restricted_ABIs="${RESTRICT_PYTHON_ABIS// /$'\n'}"
577		709
578	if [[ "$(declare -p USE_PYTHON 2> /dev/null)" == "declare -x USE_PYTHON="* ]]; then	710	if [[ "$(declare -p USE_PYTHON 2> /dev/null)" == "declare -x USE_PYTHON="* ]]; then
579	local cpython_enabled="0"	711	local cpython_enabled="0"
580		712
581	if [[ -z "${USE_PYTHON}" ]]; then	713	if [[ -z "${USE_PYTHON}" ]]; then
582	die "USE_PYTHON variable is empty"	714	die "USE_PYTHON variable is empty"
583	fi	715	fi
584		716
585	for PYTHON_ABI in ${USE_PYTHON}; do	717	for PYTHON_ABI in ${USE_PYTHON}; do
586	if ! has "${PYTHON_ABI}" ${PYTHON_ABI_SUPPORTED_VALUES}; then	718	if ! has "${PYTHON_ABI}" "${_PYTHON_GLOBALLY_SUPPORTED_ABIS[@]}"; then
587	die "USE_PYTHON variable contains invalid value '${PYTHON_ABI}'"	719	die "USE_PYTHON variable contains invalid value '${PYTHON_ABI}'"
588	fi	720	fi
589		721
590	if has "${PYTHON_ABI}" "${_CPYTHON2_SUPPORTED_ABIS[@]}" "${_CPYTHON3_SUPPORTED_ABIS[@]}"; then	722	if has "${PYTHON_ABI}" "${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}" "${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}"; then
591	cpython_enabled="1"	723	cpython_enabled="1"
592	fi	724	fi
593		725
594	support_ABI="1"	726	support_ABI="1"
595	for restricted_ABI in ${RESTRICT_PYTHON_ABIS}; do	727	while read restricted_ABI; do
596	if [[ "${PYTHON_ABI}" == ${restricted_ABI} ]]; then	728	if _python_check_python_abi_matching "${PYTHON_ABI}" "${restricted_ABI}"; then
597	support_ABI="0"	729	support_ABI="0"
598	break	730	break
599	fi	731	fi
600	done	732	done <<< "${restricted_ABIs}"
601	[[ "${support_ABI}" == "1" ]] && export PYTHON_ABIS+="${PYTHON_ABIS:+ }${PYTHON_ABI}"	733	[[ "${support_ABI}" == "1" ]] && export PYTHON_ABIS+="${PYTHON_ABIS:+ }${PYTHON_ABI}"
602	done	734	done
603		735
604	if [[ -z "${PYTHON_ABIS//[${IFS}]/}" ]]; then	736	if [[ -z "${PYTHON_ABIS//[${IFS}]/}" ]]; then
605	die "USE_PYTHON variable does not enable any Python ABI supported by ${CATEGORY}/${PF}"	737	die "USE_PYTHON variable does not enable any Python ABI supported by ${CATEGORY}/${PF}"
…		…
607		739
608	if [[ "${cpython_enabled}" == "0" ]]; then	740	if [[ "${cpython_enabled}" == "0" ]]; then
609	die "USE_PYTHON variable does not enable any CPython ABI"	741	die "USE_PYTHON variable does not enable any CPython ABI"
610	fi	742	fi
611	else	743	else
612	local python_version python2_version= python3_version= support_python_major_version	744	local python_version python2_version python3_version support_python_major_version
613		745
614	if ! has_version "dev-lang/python"; then	746	if ! has_version "dev-lang/python"; then
615	die "${FUNCNAME}(): 'dev-lang/python' is not installed"	747	die "${FUNCNAME}(): 'dev-lang/python' is not installed"
616	fi	748	fi
617		749
…		…
622	die "'${EPREFIX}/usr/bin/python2' is not valid symlink"	754	die "'${EPREFIX}/usr/bin/python2' is not valid symlink"
623	fi	755	fi
624		756
625	python2_version="$("${EPREFIX}/usr/bin/python2" -c 'from sys import version_info; print(".".join(str(x) for x in version_info[:2]))')"	757	python2_version="$("${EPREFIX}/usr/bin/python2" -c 'from sys import version_info; print(".".join(str(x) for x in version_info[:2]))')"
626		758
627	for PYTHON_ABI in "${_CPYTHON2_SUPPORTED_ABIS[@]}"; do	759	for PYTHON_ABI in "${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}"; do
628	support_python_major_version="1"	760	support_python_major_version="1"
629	for restricted_ABI in ${RESTRICT_PYTHON_ABIS}; do	761	while read restricted_ABI; do
630	if [[ "${PYTHON_ABI}" == ${restricted_ABI} ]]; then	762	if _python_check_python_abi_matching "${PYTHON_ABI}" "${restricted_ABI}"; then
631	support_python_major_version="0"	763	support_python_major_version="0"
632	fi	764	fi
633	done	765	done <<< "${restricted_ABIs}"
634	[[ "${support_python_major_version}" == "1" ]] && break	766	[[ "${support_python_major_version}" == "1" ]] && break
635	done	767	done
636	if [[ "${support_python_major_version}" == "1" ]]; then	768	if [[ "${support_python_major_version}" == "1" ]]; then
637	for restricted_ABI in ${RESTRICT_PYTHON_ABIS}; do	769	while read restricted_ABI; do
638	if [[ "${python2_version}" == ${restricted_ABI} ]]; then	770	if _python_check_python_abi_matching "${python2_version}" "${restricted_ABI}"; then
639	die "Active version of Python 2 is not supported by ${CATEGORY}/${PF}"	771	die "Active version of CPython 2 is not supported by ${CATEGORY}/${PF}"
640	fi	772	fi
641	done	773	done <<< "${restricted_ABIs}"
642	else	774	else
643	python2_version=""	775	python2_version=""
644	fi	776	fi
645	fi	777	fi
646		778
…		…
649	die "'${EPREFIX}/usr/bin/python3' is not valid symlink"	781	die "'${EPREFIX}/usr/bin/python3' is not valid symlink"
650	fi	782	fi
651		783
652	python3_version="$("${EPREFIX}/usr/bin/python3" -c 'from sys import version_info; print(".".join(str(x) for x in version_info[:2]))')"	784	python3_version="$("${EPREFIX}/usr/bin/python3" -c 'from sys import version_info; print(".".join(str(x) for x in version_info[:2]))')"
653		785
654	for PYTHON_ABI in "${_CPYTHON3_SUPPORTED_ABIS[@]}"; do	786	for PYTHON_ABI in "${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}"; do
655	support_python_major_version="1"	787	support_python_major_version="1"
656	for restricted_ABI in ${RESTRICT_PYTHON_ABIS}; do	788	while read restricted_ABI; do
657	if [[ "${PYTHON_ABI}" == ${restricted_ABI} ]]; then	789	if _python_check_python_abi_matching "${PYTHON_ABI}" "${restricted_ABI}"; then
658	support_python_major_version="0"	790	support_python_major_version="0"
659	fi	791	fi
660	done	792	done <<< "${restricted_ABIs}"
661	[[ "${support_python_major_version}" == "1" ]] && break	793	[[ "${support_python_major_version}" == "1" ]] && break
662	done	794	done
663	if [[ "${support_python_major_version}" == "1" ]]; then	795	if [[ "${support_python_major_version}" == "1" ]]; then
664	for restricted_ABI in ${RESTRICT_PYTHON_ABIS}; do	796	while read restricted_ABI; do
665	if [[ "${python3_version}" == ${restricted_ABI} ]]; then	797	if _python_check_python_abi_matching "${python3_version}" "${restricted_ABI}"; then
666	die "Active version of Python 3 is not supported by ${CATEGORY}/${PF}"	798	die "Active version of CPython 3 is not supported by ${CATEGORY}/${PF}"
667	fi	799	fi
668	done	800	done <<< "${restricted_ABIs}"
669	else	801	else
670	python3_version=""	802	python3_version=""
671	fi	803	fi
672	fi	804	fi
673		805
…		…
687	export PYTHON_ABIS="${PYTHON_ABIS% }"	819	export PYTHON_ABIS="${PYTHON_ABIS% }"
688	fi	820	fi
689	fi	821	fi
690		822
691	_python_final_sanity_checks	823	_python_final_sanity_checks
		824	}
		825
		826	_python_prepare_flags() {
		827	local array=() deleted_flag element flags new_value old_flag old_value operator pattern prefix variable
		828
		829	for variable in CPPFLAGS CFLAGS CXXFLAGS LDFLAGS; do
		830	eval "_PYTHON_SAVED_${variable}=\"\${!variable}\""
		831	for prefix in PYTHON_USER_ PYTHON_; do
		832	if [[ "$(declare -p ${prefix}${variable} 2> /dev/null)" == "declare -a ${prefix}${variable}="* ]]; then
		833	eval "array=(\"\${${prefix}${variable}[@]}\")"
		834	for element in "${array[@]}"; do
		835	if [[ "${element}" =~ ^([[:alnum:]]\|\.\|-\|\*\|\[\|\])+\ (\+\|-)\ .+ ]]; then
		836	pattern="${element%% *}"
		837	element="${element#* }"
		838	operator="${element%% *}"
		839	flags="${element#* }"
		840	if _python_check_python_abi_matching "${PYTHON_ABI}" "${pattern}"; then
		841	if [[ "${operator}" == "+" ]]; then
		842	eval "export ${variable}+=\"\${variable:+ }${flags}\""
		843	elif [[ "${operator}" == "-" ]]; then
		844	flags="${flags// /$'\n'}"
		845	old_value="${!variable// /$'\n'}"
		846	new_value=""
		847	while read old_flag; do
		848	while read deleted_flag; do
		849	if [[ "${old_flag}" == ${deleted_flag} ]]; then
		850	continue 2
		851	fi
		852	done <<< "${flags}"
		853	new_value+="${new_value:+ }${old_flag}"
		854	done <<< "${old_value}"
		855	eval "export ${variable}=\"\${new_value}\""
		856	fi
		857	fi
		858	else
		859	die "Element '${element}' of ${prefix}${variable} array has invalid syntax"
		860	fi
		861	done
		862	elif [[ -n "$(declare -p ${prefix}${variable} 2> /dev/null)" ]]; then
		863	die "${prefix}${variable} should be indexed array"
		864	fi
		865	done
		866	done
		867	}
		868
		869	_python_restore_flags() {
		870	local variable
		871
		872	for variable in CPPFLAGS CFLAGS CXXFLAGS LDFLAGS; do
		873	eval "${variable}=\"\${_PYTHON_SAVED_${variable}}\""
		874	unset _PYTHON_SAVED_${variable}
		875	done
692	}	876	}
693		877
694	# @FUNCTION: python_execute_function	878	# @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]	879	# @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:	880	# @DESCRIPTION:
…		…
699	python_execute_function() {	883	python_execute_function() {
700	if ! _python_package_supporting_installation_for_multiple_python_abis; then	884	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"	885	die "${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
702	fi	886	fi
703		887
		888	_python_check_python_pkg_setup_execution
704	_python_set_color_variables	889	_python_set_color_variables
705		890
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=	891	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		892
708	while (($#)); do	893	while (($#)); do
709	case "$1" in	894	case "$1" in
710	--action-message)	895	--action-message)
711	action_message_template="$2"	896	action_message_template="$2"
…		…
798	fi	983	fi
799	function="python_default_function"	984	function="python_default_function"
800	fi	985	fi
801		986
802	# Ensure that python_execute_function() cannot be directly or indirectly called by python_execute_function().	987	# Ensure that python_execute_function() cannot be directly or indirectly called by python_execute_function().
803	for ((i = 1; i < "${#FUNCNAME[@]}"; i++)); do	988	if _python_abi-specific_local_scope; then
804	if [[ "${FUNCNAME[${i}]}" == "${FUNCNAME}" ]]; then
805	die "${FUNCNAME}(): Invalid call stack"	989	die "${FUNCNAME}(): Invalid call stack"
806	fi	990	fi
807	done
808		991
809	if [[ "${quiet}" == "0" ]]; then	992	if [[ "${quiet}" == "0" ]]; then
810	[[ "${EBUILD_PHASE}" == "setup" ]] && action="Setting up"	993	[[ "${EBUILD_PHASE}" == "setup" ]] && action="Setting up"
811	[[ "${EBUILD_PHASE}" == "unpack" ]] && action="Unpacking"	994	[[ "${EBUILD_PHASE}" == "unpack" ]] && action="Unpacking"
812	[[ "${EBUILD_PHASE}" == "prepare" ]] && action="Preparation"	995	[[ "${EBUILD_PHASE}" == "prepare" ]] && action="Preparation"
…		…
825	iterated_PYTHON_ABIS="$(PYTHON -f --ABI)"	1008	iterated_PYTHON_ABIS="$(PYTHON -f --ABI)"
826	else	1009	else
827	iterated_PYTHON_ABIS="${PYTHON_ABIS}"	1010	iterated_PYTHON_ABIS="${PYTHON_ABIS}"
828	fi	1011	fi
829	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do	1012	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do
		1013	_python_prepare_flags
		1014
830	if [[ "${quiet}" == "0" ]]; then	1015	if [[ "${quiet}" == "0" ]]; then
831	if [[ -n "${action_message_template}" ]]; then	1016	if [[ -n "${action_message_template}" ]]; then
832	action_message="$(eval echo -n "${action_message_template}")"	1017	eval "action_message=\"${action_message_template}\""
833	else	1018	else
834	action_message="${action} of ${CATEGORY}/${PF} with $(python_get_implementation) $(python_get_version)..."	1019	action_message="${action} of ${CATEGORY}/${PF} with $(python_get_implementation) $(python_get_version)..."
835	fi	1020	fi
836	echo " ${_GREEN}*${_NORMAL} ${_BLUE}${action_message}${_NORMAL}"	1021	echo " ${_GREEN}*${_NORMAL} ${_BLUE}${action_message}${_NORMAL}"
837	fi	1022	fi
…		…
855	EPYTHON="$(PYTHON)" nonfatal "${function}" "$@"	1040	EPYTHON="$(PYTHON)" nonfatal "${function}" "$@"
856	else	1041	else
857	EPYTHON="$(PYTHON)" "${function}" "$@"	1042	EPYTHON="$(PYTHON)" "${function}" "$@"
858	fi	1043	fi
859		1044
860	if [[ "$?" != "0" ]]; then	1045	return_code="$?"
		1046
		1047	_python_restore_flags
		1048
		1049	if [[ "${return_code}" -ne 0 ]]; then
861	if [[ -n "${failure_message_template}" ]]; then	1050	if [[ -n "${failure_message_template}" ]]; then
862	failure_message="$(eval echo -n "${failure_message_template}")"	1051	eval "failure_message=\"${failure_message_template}\""
863	else	1052	else
864	failure_message="${action} failed with $(python_get_implementation) $(python_get_version) in ${function}() function"	1053	failure_message="${action} failed with $(python_get_implementation) $(python_get_version) in ${function}() function"
865	fi	1054	fi
866		1055
867	if [[ "${nonfatal}" == "1" ]]; then	1056	if [[ "${nonfatal}" == "1" ]]; then
868	if [[ "${quiet}" == "0" ]]; then	1057	if [[ "${quiet}" == "0" ]]; then
869	ewarn "${_RED}${failure_message}${_NORMAL}"	1058	ewarn "${failure_message}"
870	fi	1059	fi
871	elif [[ "${final_ABI}" == "0" ]] && has "${PYTHON_ABI}" ${FAILURE_TOLERANT_PYTHON_ABIS}; then	1060	elif [[ "${final_ABI}" == "0" ]] && has "${PYTHON_ABI}" ${FAILURE_TOLERANT_PYTHON_ABIS}; then
872	if [[ "${EBUILD_PHASE}" != "test" ]] \|\| ! has test-fail-continue ${FEATURES}; then	1061	if [[ "${EBUILD_PHASE}" != "test" ]] \|\| ! has test-fail-continue ${FEATURES}; then
873	local enabled_PYTHON_ABIS= other_PYTHON_ABI	1062	local enabled_PYTHON_ABIS= other_PYTHON_ABI
874	for other_PYTHON_ABI in ${PYTHON_ABIS}; do	1063	for other_PYTHON_ABI in ${PYTHON_ABIS}; do
875	[[ "${other_PYTHON_ABI}" != "${PYTHON_ABI}" ]] && enabled_PYTHON_ABIS+="${enabled_PYTHON_ABIS:+ }${other_PYTHON_ABI}"	1064	[[ "${other_PYTHON_ABI}" != "${PYTHON_ABI}" ]] && enabled_PYTHON_ABIS+="${enabled_PYTHON_ABIS:+ }${other_PYTHON_ABI}"
876	done	1065	done
877	export PYTHON_ABIS="${enabled_PYTHON_ABIS}"	1066	export PYTHON_ABIS="${enabled_PYTHON_ABIS}"
878	fi	1067	fi
879	if [[ "${quiet}" == "0" ]]; then	1068	if [[ "${quiet}" == "0" ]]; then
880	ewarn "${_RED}${failure_message}${_NORMAL}"	1069	ewarn "${failure_message}"
881	fi	1070	fi
882	if [[ -z "${PYTHON_ABIS}" ]]; then	1071	if [[ -z "${PYTHON_ABIS}" ]]; then
883	die "${function}() function failed with all enabled Python ABIs"	1072	die "${function}() function failed with all enabled Python ABIs"
884	fi	1073	fi
885	else	1074	else
…		…
926	python_copy_sources() {	1115	python_copy_sources() {
927	if ! _python_package_supporting_installation_for_multiple_python_abis; then	1116	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"	1117	die "${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
929	fi	1118	fi
930		1119
		1120	_python_check_python_pkg_setup_execution
		1121
931	local dir dirs=() PYTHON_ABI	1122	local dir dirs=() PYTHON_ABI
932		1123
933	if [[ "$#" -eq 0 ]]; then	1124	if [[ "$#" -eq 0 ]]; then
934	if [[ "${WORKDIR}" == "${S}" ]]; then	1125	if [[ "${WORKDIR}" == "${S}" ]]; then
935	die "${FUNCNAME}() cannot be used with current value of S variable"	1126	die "${FUNCNAME}() cannot be used with current value of S variable"
…		…
951	# @USAGE: [-E\|--respect-EPYTHON] [-f\|--force] [-q\|--quiet] [--] <file> [files]	1142	# @USAGE: [-E\|--respect-EPYTHON] [-f\|--force] [-q\|--quiet] [--] <file> [files]
952	# @DESCRIPTION:	1143	# @DESCRIPTION:
953	# Generate wrapper scripts. Existing files are overwritten only with --force option.	1144	# Generate wrapper scripts. Existing files are overwritten only with --force option.
954	# If --respect-EPYTHON option is specified, then generated wrapper scripts will	1145	# If --respect-EPYTHON option is specified, then generated wrapper scripts will
955	# respect EPYTHON variable at run time.	1146	# respect EPYTHON variable at run time.
		1147	#
		1148	# This function can be used only in src_install() phase.
956	python_generate_wrapper_scripts() {	1149	python_generate_wrapper_scripts() {
		1150	if [[ "${EBUILD_PHASE}" != "install" ]]; then
		1151	die "${FUNCNAME}() can be used only in src_install() phase"
		1152	fi
		1153
957	if ! _python_package_supporting_installation_for_multiple_python_abis; then	1154	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"	1155	die "${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
959	fi	1156	fi
960		1157
		1158	_python_check_python_pkg_setup_execution
961	_python_initialize_prefix_variables	1159	_python_initialize_prefix_variables
962		1160
963	local eselect_python_option file force="0" quiet="0" PYTHON_ABI python2_enabled="0" python3_enabled="0" respect_EPYTHON="0"	1161	local eselect_python_option file force="0" quiet="0" PYTHON_ABI PYTHON_ABIS_list python2_enabled="0" python3_enabled="0" respect_EPYTHON="0"
964		1162
965	while (($#)); do	1163	while (($#)); do
966	case "$1" in	1164	case "$1" in
967	-E\|--respect-EPYTHON)	1165	-E\|--respect-EPYTHON)
968	respect_EPYTHON="1"	1166	respect_EPYTHON="1"
…		…
990	if [[ "$#" -eq 0 ]]; then	1188	if [[ "$#" -eq 0 ]]; then
991	die "${FUNCNAME}(): Missing arguments"	1189	die "${FUNCNAME}(): Missing arguments"
992	fi	1190	fi
993		1191
994	_python_calculate_PYTHON_ABIS	1192	_python_calculate_PYTHON_ABIS
995	for PYTHON_ABI in "${_CPYTHON2_SUPPORTED_ABIS[@]}"; do	1193	for PYTHON_ABI in "${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}"; do
996	if has "${PYTHON_ABI}" ${PYTHON_ABIS}; then	1194	if has "${PYTHON_ABI}" ${PYTHON_ABIS}; then
997	python2_enabled="1"	1195	python2_enabled="1"
998	fi	1196	fi
999	done	1197	done
1000	for PYTHON_ABI in "${_CPYTHON3_SUPPORTED_ABIS[@]}"; do	1198	for PYTHON_ABI in "${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}"; do
1001	if has "${PYTHON_ABI}" ${PYTHON_ABIS}; then	1199	if has "${PYTHON_ABI}" ${PYTHON_ABIS}; then
1002	python3_enabled="1"	1200	python3_enabled="1"
1003	fi	1201	fi
1004	done	1202	done
1005		1203
…		…
1011	eselect_python_option="--python3"	1209	eselect_python_option="--python3"
1012	else	1210	else
1013	die "${FUNCNAME}(): Unsupported environment"	1211	die "${FUNCNAME}(): Unsupported environment"
1014	fi	1212	fi
1015		1213
		1214	PYTHON_ABIS_list="$("$(PYTHON -f)" -c "print(', '.join('\"%s\"' % x for x in reversed('${PYTHON_ABIS}'.split())))")"
		1215
1016	for file in "$@"; do	1216	for file in "$@"; do
1017	if [[ -f "${file}" && "${force}" == "0" ]]; then	1217	if [[ -f "${file}" && "${force}" == "0" ]]; then
1018	die "${FUNCNAME}(): '$1' already exists"	1218	die "${FUNCNAME}(): '${file}' already exists"
1019	fi	1219	fi
1020		1220
1021	if [[ "${quiet}" == "0" ]]; then	1221	if [[ "${quiet}" == "0" ]]; then
1022	einfo "Generating '${file#${ED%/}}' wrapper script"	1222	einfo "Generating '${file#${ED%/}}' wrapper script"
1023	fi	1223	fi
…		…
1029	import os	1229	import os
1030	import re	1230	import re
1031	import subprocess	1231	import subprocess
1032	import sys	1232	import sys
1033		1233
1034	EPYTHON_re = re.compile(r"^python(\d+\.\d+)$")	1234	cpython_re = re.compile(r"^python(\d+\.\d+)$")
		1235	jython_re = re.compile(r"^jython(\d+\.\d+)$")
1035	python_shebang_re = re.compile(r"^#! *(${EPREFIX}/usr/bin/python\|(${EPREFIX})?/usr/bin/env +(${EPREFIX}/usr/bin/)?python)")	1236	python_shebang_re = re.compile(r"^#! *(${EPREFIX}/usr/bin/python\|(${EPREFIX})?/usr/bin/env +(${EPREFIX}/usr/bin/)?python)")
1036	python_verification_output_re = re.compile("^GENTOO_PYTHON_TARGET_SCRIPT_PATH supported\n$")	1237	python_verification_output_re = re.compile("^GENTOO_PYTHON_TARGET_SCRIPT_PATH supported\n$")
		1238
		1239	def get_PYTHON_ABI(EPYTHON):
		1240	cpython_matched = cpython_re.match(EPYTHON)
		1241	jython_matched = jython_re.match(EPYTHON)
		1242	if cpython_matched is not None:
		1243	PYTHON_ABI = cpython_matched.group(1)
		1244	elif jython_matched is not None:
		1245	PYTHON_ABI = jython_matched.group(1) + "-jython"
		1246	else:
		1247	PYTHON_ABI = None
		1248	return PYTHON_ABI
1037		1249
1038	EOF	1250	EOF
1039	if [[ "$?" != "0" ]]; then	1251	if [[ "$?" != "0" ]]; then
1040	die "${FUNCNAME}(): Generation of '$1' failed"	1252	die "${FUNCNAME}(): Generation of '$1' failed"
1041	fi	1253	fi
1042	if [[ "${respect_EPYTHON}" == "1" ]]; then	1254	if [[ "${respect_EPYTHON}" == "1" ]]; then
1043	cat << EOF >> "${file}"	1255	cat << EOF >> "${file}"
1044	EPYTHON = os.environ.get("EPYTHON")	1256	EPYTHON = os.environ.get("EPYTHON")
1045	if EPYTHON:	1257	if EPYTHON:
1046	EPYTHON_matched = EPYTHON_re.match(EPYTHON)	1258	PYTHON_ABI = get_PYTHON_ABI(EPYTHON)
1047	if EPYTHON_matched:	1259	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)	1260	sys.stderr.write("EPYTHON variable has unrecognized value '%s'\n" % EPYTHON)
1051	sys.exit(1)	1261	sys.exit(1)
1052	else:	1262	else:
1053	try:	1263	try:
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)	1264	eselect_process = subprocess.Popen(["${EPREFIX}/usr/bin/eselect", "python", "show"${eselect_python_option:+, $(echo "\"")}${eselect_python_option}${eselect_python_option:+$(echo "\"")}], stdout=subprocess.PIPE)
…		…
1062	if not isinstance(EPYTHON, str):	1272	if not isinstance(EPYTHON, str):
1063	# Python 3	1273	# Python 3
1064	EPYTHON = EPYTHON.decode()	1274	EPYTHON = EPYTHON.decode()
1065	EPYTHON = EPYTHON.rstrip("\n")	1275	EPYTHON = EPYTHON.rstrip("\n")
1066		1276
1067	EPYTHON_matched = EPYTHON_re.match(EPYTHON)	1277	PYTHON_ABI = get_PYTHON_ABI(EPYTHON)
1068	if EPYTHON_matched:	1278	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)	1279	sys.stderr.write("'eselect python show${eselect_python_option:+ }${eselect_python_option}' printed unrecognized value '%s'\n" % EPYTHON)
1072	sys.exit(1)	1280	sys.exit(1)
		1281
		1282	wrapper_script_path = os.path.realpath(sys.argv[0])
		1283	target_executable_path = "%s-%s" % (wrapper_script_path, PYTHON_ABI)
		1284	if not os.path.exists(target_executable_path):
		1285	sys.stderr.write("'%s' does not exist\n" % target_executable_path)
		1286	sys.exit(1)
1073	EOF	1287	EOF
1074	if [[ "$?" != "0" ]]; then	1288	if [[ "$?" != "0" ]]; then
1075	die "${FUNCNAME}(): Generation of '$1' failed"	1289	die "${FUNCNAME}(): Generation of '$1' failed"
1076	fi	1290	fi
1077	else	1291	else
…		…
1088	if not isinstance(EPYTHON, str):	1302	if not isinstance(EPYTHON, str):
1089	# Python 3	1303	# Python 3
1090	EPYTHON = EPYTHON.decode()	1304	EPYTHON = EPYTHON.decode()
1091	EPYTHON = EPYTHON.rstrip("\n")	1305	EPYTHON = EPYTHON.rstrip("\n")
1092		1306
1093	EPYTHON_matched = EPYTHON_re.match(EPYTHON)	1307	PYTHON_ABI = get_PYTHON_ABI(EPYTHON)
1094	if EPYTHON_matched:	1308	if PYTHON_ABI is None:
1095	PYTHON_ABI = EPYTHON_matched.group(1)	1309	sys.stderr.write("'eselect python show${eselect_python_option:+ }${eselect_python_option}' printed unrecognized value '%s'\n" % EPYTHON)
		1310	sys.exit(1)
		1311
		1312	wrapper_script_path = os.path.realpath(sys.argv[0])
		1313	for PYTHON_ABI in [PYTHON_ABI, ${PYTHON_ABIS_list}]:
		1314	target_executable_path = "%s-%s" % (wrapper_script_path, PYTHON_ABI)
		1315	if os.path.exists(target_executable_path):
		1316	break
1096	else:	1317	else:
1097	sys.stderr.write("'eselect python show${eselect_python_option:+ }${eselect_python_option}' printed unrecognized value '%s'\n" % EPYTHON)	1318	sys.stderr.write("No target script exists for '%s'\n" % wrapper_script_path)
1098	sys.exit(1)	1319	sys.exit(1)
1099	EOF	1320	EOF
1100	if [[ "$?" != "0" ]]; then	1321	if [[ "$?" != "0" ]]; then
1101	die "${FUNCNAME}(): Generation of '$1' failed"	1322	die "${FUNCNAME}(): Generation of '$1' failed"
1102	fi	1323	fi
1103	fi	1324	fi
1104	cat << EOF >> "${file}"	1325	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		1326
1115	target_executable = open(target_executable_path, "rb")	1327	target_executable = open(target_executable_path, "rb")
1116	target_executable_first_line = target_executable.readline()	1328	target_executable_first_line = target_executable.readline()
1117	if not isinstance(target_executable_first_line, str):	1329	if not isinstance(target_executable_first_line, str):
1118	# Python 3	1330	# Python 3
1119	target_executable_first_line = target_executable_first_line.decode("utf_8", "replace")	1331	target_executable_first_line = target_executable_first_line.decode("utf_8", "replace")
1120		1332
1121	python_shebang_matched = python_shebang_re.match(target_executable_first_line)	1333	python_shebang_matched = python_shebang_re.match(target_executable_first_line)
1122	target_executable.close()	1334	target_executable.close()
1123		1335
1124	if python_shebang_matched:	1336	if python_shebang_matched is not None:
1125	try:	1337	try:
1126	python_interpreter_path = "${EPREFIX}/usr/bin/%s" % EPYTHON	1338	python_interpreter_path = "${EPREFIX}/usr/bin/%s" % EPYTHON
1127	os.environ["GENTOO_PYTHON_TARGET_SCRIPT_PATH_VERIFICATION"] = "1"	1339	os.environ["GENTOO_PYTHON_TARGET_SCRIPT_PATH_VERIFICATION"] = "1"
1128	python_verification_process = subprocess.Popen([python_interpreter_path, "-c", "pass"], stdout=subprocess.PIPE)	1340	python_verification_process = subprocess.Popen([python_interpreter_path, "-c", "pass"], stdout=subprocess.PIPE)
1129	del os.environ["GENTOO_PYTHON_TARGET_SCRIPT_PATH_VERIFICATION"]	1341	del os.environ["GENTOO_PYTHON_TARGET_SCRIPT_PATH_VERIFICATION"]
…		…
1136	python_verification_output = python_verification_output.decode()	1348	python_verification_output = python_verification_output.decode()
1137		1349
1138	if not python_verification_output_re.match(python_verification_output):	1350	if not python_verification_output_re.match(python_verification_output):
1139	raise ValueError	1351	raise ValueError
1140		1352
		1353	if cpython_re.match(EPYTHON) is not None:
		1354	os.environ["GENTOO_PYTHON_PROCESS_NAME"] = os.path.basename(sys.argv[0])
		1355	os.environ["GENTOO_PYTHON_WRAPPER_SCRIPT_PATH"] = sys.argv[0]
		1356	os.environ["GENTOO_PYTHON_TARGET_SCRIPT_PATH"] = target_executable_path
		1357
		1358	if hasattr(os, "execv"):
1141	os.execv(python_interpreter_path, [python_interpreter_path] + sys.argv)	1359	os.execv(python_interpreter_path, [python_interpreter_path] + sys.argv)
		1360	else:
		1361	sys.exit(subprocess.Popen([python_interpreter_path] + sys.argv).wait())
		1362	except (KeyboardInterrupt, SystemExit):
		1363	raise
1142	except:	1364	except:
1143	pass	1365	pass
1144	if "GENTOO_PYTHON_TARGET_SCRIPT_PATH_VERIFICATION" in os.environ:	1366	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"]	1367	if variable in os.environ:
		1368	del os.environ[variable]
1146		1369
		1370	if hasattr(os, "execv"):
1147	os.execv(target_executable_path, sys.argv)	1371	os.execv(target_executable_path, sys.argv)
		1372	else:
		1373	sys.exit(subprocess.Popen([target_executable_path] + sys.argv[1:]).wait())
1148	EOF	1374	EOF
1149	if [[ "$?" != "0" ]]; then	1375	if [[ "$?" != "0" ]]; then
1150	die "${FUNCNAME}(): Generation of '$1' failed"	1376	die "${FUNCNAME}(): Generation of '$1' failed"
1151	fi	1377	fi
1152	fperms +x "${file#${ED%/}}" \|\| die "fperms '${file}' failed"	1378	fperms +x "${file#${ED%/}}" \|\| die "fperms '${file}' failed"
1153	done	1379	done
1154	}	1380	}
1155		1381
		1382	# @ECLASS-VARIABLE: PYTHON_VERSIONED_SCRIPTS
		1383	# @DESCRIPTION:
		1384	# Array of regular expressions of paths to versioned Python scripts.
		1385	# Python scripts in /usr/bin and /usr/sbin are versioned by default.
		1386
		1387	# @ECLASS-VARIABLE: PYTHON_VERSIONED_EXECUTABLES
		1388	# @DESCRIPTION:
		1389	# Array of regular expressions of paths to versioned executables (including Python scripts).
		1390
		1391	# @ECLASS-VARIABLE: PYTHON_NONVERSIONED_EXECUTABLES
		1392	# @DESCRIPTION:
		1393	# Array of regular expressions of paths to nonversioned executables (including Python scripts).
		1394
		1395	# @FUNCTION: python_merge_intermediate_installation_images
		1396	# @USAGE: [-q\|--quiet] [--] <intermediate_installation_images_directory>
		1397	# @DESCRIPTION:
		1398	# Merge intermediate installation images into installation image.
		1399	#
		1400	# This function can be used only in src_install() phase.
		1401	python_merge_intermediate_installation_images() {
		1402	if [[ "${EBUILD_PHASE}" != "install" ]]; then
		1403	die "${FUNCNAME}() can be used only in src_install() phase"
		1404	fi
		1405
		1406	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		1407	die "${FUNCNAME}() cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		1408	fi
		1409
		1410	_python_check_python_pkg_setup_execution
		1411	_python_initialize_prefix_variables
		1412
		1413	local b file files=() intermediate_installation_images_directory PYTHON_ABI quiet="0" regex shebang version_executable wrapper_scripts=() wrapper_scripts_set=()
		1414
		1415	while (($#)); do
		1416	case "$1" in
		1417	-q\|--quiet)
		1418	quiet="1"
		1419	;;
		1420	--)
		1421	shift
		1422	break
		1423	;;
		1424	-*)
		1425	die "${FUNCNAME}(): Unrecognized option '$1'"
		1426	;;
		1427	*)
		1428	break
		1429	;;
		1430	esac
		1431	shift
		1432	done
		1433
		1434	if [[ "$#" -ne 1 ]]; then
		1435	die "${FUNCNAME}() requires 1 argument"
		1436	fi
		1437
		1438	intermediate_installation_images_directory="$1"
		1439
		1440	if [[ ! -d "${intermediate_installation_images_directory}" ]]; then
		1441	die "${FUNCNAME}(): Intermediate installation images directory '${intermediate_installation_images_directory}' does not exist"
		1442	fi
		1443
		1444	_python_calculate_PYTHON_ABIS
		1445	if [[ "$(PYTHON -f --ABI)" == 3.* ]]; then
		1446	b="b"
		1447	fi
		1448
		1449	while read -d $'\0' -r file; do
		1450	files+=("${file}")
		1451	done < <("$(PYTHON -f)" -c \
		1452	"import os
		1453	import sys
		1454
		1455	if hasattr(sys.stdout, 'buffer'):
		1456	# Python 3
		1457	stdout = sys.stdout.buffer
		1458	else:
		1459	# Python 2
		1460	stdout = sys.stdout
		1461
		1462	files_set = set()
		1463
		1464	os.chdir(${b}'${intermediate_installation_images_directory}')
		1465
		1466	for PYTHON_ABI in ${b}'${PYTHON_ABIS}'.split():
		1467	for root, dirs, files in os.walk(PYTHON_ABI + ${b}'${EPREFIX}'):
		1468	root = root[len(PYTHON_ABI + ${b}'${EPREFIX}')+1:]
		1469	files_set.update(root + ${b}'/' + file for file in files)
		1470
		1471	for file in sorted(files_set):
		1472	stdout.write(file)
		1473	stdout.write(${b}'\x00')" \|\| die "${FUNCNAME}(): Failure of extraction of files in intermediate installation images")
		1474
		1475	for PYTHON_ABI in ${PYTHON_ABIS}; do
		1476	if [[ ! -d "${intermediate_installation_images_directory}/${PYTHON_ABI}" ]]; then
		1477	die "${FUNCNAME}(): Intermediate installation image for Python ABI '${PYTHON_ABI}' does not exist"
		1478	fi
		1479
		1480	pushd "${intermediate_installation_images_directory}/${PYTHON_ABI}${EPREFIX}" > /dev/null \|\| die "pushd failed"
		1481
		1482	for file in "${files[@]}"; do
		1483	version_executable="0"
		1484	for regex in "/usr/bin/." "/usr/sbin/." "${PYTHON_VERSIONED_SCRIPTS[@]}"; do
		1485	if [[ "/${file}" =~ ^${regex}$ ]]; then
		1486	version_executable="1"
		1487	break
		1488	fi
		1489	done
		1490	for regex in "${PYTHON_VERSIONED_EXECUTABLES[@]}"; do
		1491	if [[ "/${file}" =~ ^${regex}$ ]]; then
		1492	version_executable="2"
		1493	break
		1494	fi
		1495	done
		1496	if [[ "${version_executable}" != "0" ]]; then
		1497	for regex in "${PYTHON_NONVERSIONED_EXECUTABLES[@]}"; do
		1498	if [[ "/${file}" =~ ^${regex}$ ]]; then
		1499	version_executable="0"
		1500	break
		1501	fi
		1502	done
		1503	fi
		1504
		1505	[[ "${version_executable}" == "0" \|\| ! -x "${file}" ]] && continue
		1506
		1507	shebang="$(head -n1 "${file}")" \|\| die "Extraction of shebang from '${file}' failed"
		1508
		1509	if [[ "${version_executable}" == "2" ]]; then
		1510	wrapper_scripts+=("${ED}${file}")
		1511	elif [[ "${version_executable}" == "1" ]]; then
		1512	if [[ "${shebang}" =~ ${_PYTHON_SHEBANG_BASE_PART_REGEX}([[:digit:]]+(\.[[:digit:]]+)?)?($\|[[:space:]]+) ]]; then
		1513	wrapper_scripts+=("${ED}${file}")
		1514	else
		1515	version_executable="0"
		1516	fi
		1517	fi
		1518
		1519	[[ "${version_executable}" == "0" ]] && continue
		1520
		1521	if [[ -e "${file}-${PYTHON_ABI}" ]]; then
		1522	die "${FUNCNAME}(): '${EPREFIX}/${file}-${PYTHON_ABI}' already exists"
		1523	fi
		1524
		1525	mv "${file}" "${file}-${PYTHON_ABI}" \|\| die "Renaming of '${file}' failed"
		1526
		1527	if [[ "${shebang}" =~ ${_PYTHON_SHEBANG_BASE_PART_REGEX}[[:digit:]]*($\|[[:space:]]+) ]]; then
		1528	python_convert_shebangs $([[ "${quiet}" == "1" ]] && echo --quiet) "${PYTHON_ABI}" "${file}-${PYTHON_ABI}"
		1529	fi
		1530	done
		1531
		1532	popd > /dev/null \|\| die "popd failed"
		1533
		1534	if ROOT="/" has_version sys-apps/coreutils; then
		1535	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"
		1536	else
		1537	cp -fpr "${intermediate_installation_images_directory}/${PYTHON_ABI}/"* "${D}" \|\| die "Merging of intermediate installation image for Python ABI '${PYTHON_ABI} into installation image failed"
		1538	fi
		1539	done
		1540
		1541	rm -fr "${intermediate_installation_images_directory}"
		1542
		1543	if [[ "${#wrapper_scripts[@]}" -ge 1 ]]; then
		1544	rm -f "${T}/python_wrapper_scripts"
		1545
		1546	for file in "${wrapper_scripts[@]}"; do
		1547	echo -n "${file}" >> "${T}/python_wrapper_scripts"
		1548	echo -en "\x00" >> "${T}/python_wrapper_scripts"
		1549	done
		1550
		1551	while read -d $'\0' -r file; do
		1552	wrapper_scripts_set+=("${file}")
		1553	done < <("$(PYTHON -f)" -c \
		1554	"import sys
		1555
		1556	if hasattr(sys.stdout, 'buffer'):
		1557	# Python 3
		1558	stdout = sys.stdout.buffer
		1559	else:
		1560	# Python 2
		1561	stdout = sys.stdout
		1562
		1563	files = set(open('${T}/python_wrapper_scripts', 'rb').read().rstrip(${b}'\x00').split(${b}'\x00'))
		1564
		1565	for file in sorted(files):
		1566	stdout.write(file)
		1567	stdout.write(${b}'\x00')" \|\| die "${FUNCNAME}(): Failure of extraction of set of wrapper scripts")
		1568
		1569	python_generate_wrapper_scripts $([[ "${quiet}" == "1" ]] && echo --quiet) "${wrapper_scripts_set[@]}"
		1570	fi
		1571	}
		1572
1156	# ================================================================================================	1573	# ================================================================================================
1157	# ========= FUNCTIONS FOR PACKAGES NOT SUPPORTING INSTALLATION FOR MULTIPLE PYTHON ABIS ==========	1574	# ========= FUNCTIONS FOR PACKAGES NOT SUPPORTING INSTALLATION FOR MULTIPLE PYTHON ABIS ==========
1158	# ================================================================================================	1575	# ================================================================================================
1159		1576
		1577	unset EPYTHON PYTHON_ABI
		1578
1160	# @FUNCTION: python_set_active_version	1579	# @FUNCTION: python_set_active_version
1161	# @USAGE: <CPython_ABI\|2\|3>	1580	# @USAGE: <Python_ABI\|2\|3>
1162	# @DESCRIPTION:	1581	# @DESCRIPTION:
1163	# Set specified version of CPython as active version of Python.	1582	# Set locally active version of Python.
		1583	# If Python_ABI argument is specified, then version of Python corresponding to Python_ABI is used.
		1584	# If 2 argument is specified, then active version of CPython 2 is used.
		1585	# If 3 argument is specified, then active version of CPython 3 is used.
		1586	#
		1587	# This function can be used only in pkg_setup() phase.
1164	python_set_active_version() {	1588	python_set_active_version() {
		1589	if [[ "${EBUILD_PHASE}" != "setup" ]]; then
		1590	die "${FUNCNAME}() can be used only in pkg_setup() phase"
		1591	fi
		1592
1165	if _python_package_supporting_installation_for_multiple_python_abis; then	1593	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"	1594	die "${FUNCNAME}() cannot be used in ebuilds of packages supporting installation for multiple Python ABIs"
1167	fi	1595	fi
1168		1596
1169	if [[ "$#" -ne 1 ]]; then	1597	if [[ "$#" -ne 1 ]]; then
1170	die "${FUNCNAME}() requires 1 argument"	1598	die "${FUNCNAME}() requires 1 argument"
1171	fi	1599	fi
1172		1600
1173	_python_initial_sanity_checks	1601	_python_initial_sanity_checks
1174		1602
1175	if [[ "$1" =~ ^[[:digit:]]+\.[[:digit:]]+$ ]]; then	1603	if [[ -z "${PYTHON_ABI}" ]]; then
1176	if ! _python_implementation && ! has_version "dev-lang/python:$1"; then	1604	if [[ -n "$(_python_get_implementation --ignore-invalid "$1")" ]]; then
1177	die "${FUNCNAME}(): 'dev-lang/python:$1' is not installed"	1605	# PYTHON_ABI variable is intended to be used only in ebuilds/eclasses,
		1606	# so it does not need to be exported to subprocesses.
		1607	PYTHON_ABI="$1"
		1608	if ! _python_implementation && ! has_version "$(python_get_implementational_package)"; then
		1609	die "${FUNCNAME}(): '$(python_get_implementational_package)' is not installed"
1178	fi	1610	fi
1179	export EPYTHON="$(PYTHON "$1")"	1611	export EPYTHON="$(PYTHON "$1")"
1180	elif [[ "$1" == "2" ]]; then	1612	elif [[ "$1" == "2" ]]; then
1181	if ! _python_implementation && ! has_version "=dev-lang/python-2*"; then	1613	if ! _python_implementation && ! has_version "=dev-lang/python-2*"; then
1182	die "${FUNCNAME}(): '=dev-lang/python-2*' is not installed"	1614	die "${FUNCNAME}(): '=dev-lang/python-2*' is not installed"
1183	fi	1615	fi
1184	export EPYTHON="$(PYTHON -2)"	1616	export EPYTHON="$(PYTHON -2)"
		1617	PYTHON_ABI="${EPYTHON#python}"
		1618	PYTHON_ABI="${PYTHON_ABI%%-*}"
1185	elif [[ "$1" == "3" ]]; then	1619	elif [[ "$1" == "3" ]]; then
1186	if ! _python_implementation && ! has_version "=dev-lang/python-3*"; then	1620	if ! _python_implementation && ! has_version "=dev-lang/python-3*"; then
1187	die "${FUNCNAME}(): '=dev-lang/python-3*' is not installed"	1621	die "${FUNCNAME}(): '=dev-lang/python-3*' is not installed"
1188	fi	1622	fi
1189	export EPYTHON="$(PYTHON -3)"	1623	export EPYTHON="$(PYTHON -3)"
		1624	PYTHON_ABI="${EPYTHON#python}"
		1625	PYTHON_ABI="${PYTHON_ABI%%-*}"
1190	else	1626	else
1191	die "${FUNCNAME}(): Unrecognized argument '$1'"	1627	die "${FUNCNAME}(): Unrecognized argument '$1'"
1192	fi	1628	fi
1193		1629	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		1630
1199	_python_final_sanity_checks	1631	_python_final_sanity_checks
1200		1632
1201	# python-updater checks PYTHON_REQUESTED_ACTIVE_VERSION variable.	1633	# python-updater checks PYTHON_REQUESTED_ACTIVE_VERSION variable.
1202	PYTHON_REQUESTED_ACTIVE_VERSION="$1"	1634	PYTHON_REQUESTED_ACTIVE_VERSION="$1"
…		…
1208	python_need_rebuild() {	1640	python_need_rebuild() {
1209	if _python_package_supporting_installation_for_multiple_python_abis; then	1641	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"	1642	die "${FUNCNAME}() cannot be used in ebuilds of packages supporting installation for multiple Python ABIs"
1211	fi	1643	fi
1212		1644
		1645	_python_check_python_pkg_setup_execution
		1646
		1647	if [[ "$#" -ne 0 ]]; then
		1648	die "${FUNCNAME}() does not accept arguments"
		1649	fi
		1650
1213	export PYTHON_NEED_REBUILD="$(PYTHON --ABI)"	1651	export PYTHON_NEED_REBUILD="$(PYTHON --ABI)"
1214	}	1652	}
1215		1653
1216	# ================================================================================================	1654	# ================================================================================================
1217	# ======================================= GETTER FUNCTIONS =======================================	1655	# ======================================= GETTER FUNCTIONS =======================================
…		…
1222	sys.stdout.write(".".join(str(x) for x in sys.version_info[:2]))	1660	sys.stdout.write(".".join(str(x) for x in sys.version_info[:2]))
1223	if platform.system()[:4] == "Java":	1661	if platform.system()[:4] == "Java":
1224	sys.stdout.write("-jython")'	1662	sys.stdout.write("-jython")'
1225		1663
1226	_python_get_implementation() {	1664	_python_get_implementation() {
		1665	local ignore_invalid="0"
		1666
		1667	while (($#)); do
		1668	case "$1" in
		1669	--ignore-invalid)
		1670	ignore_invalid="1"
		1671	;;
		1672	--)
		1673	shift
		1674	break
		1675	;;
		1676	-*)
		1677	die "${FUNCNAME}(): Unrecognized option '$1'"
		1678	;;
		1679	*)
		1680	break
		1681	;;
		1682	esac
		1683	shift
		1684	done
		1685
1227	if [[ "$#" -ne 1 ]]; then	1686	if [[ "$#" -ne 1 ]]; then
1228	die "${FUNCNAME}() requires 1 argument"	1687	die "${FUNCNAME}() requires 1 argument"
1229	fi	1688	fi
1230		1689
1231	if [[ "$1" =~ ^[[:digit:]]+\.[[:digit:]]+$ ]]; then	1690	if [[ "$1" =~ ^[[:digit:]]+\.[[:digit:]]+$ ]]; then
1232	echo "CPython"	1691	echo "CPython"
1233	elif [[ "$1" =~ ^[[:digit:]]+\.[[:digit:]]+-jython$ ]]; then	1692	elif [[ "$1" =~ ^[[:digit:]]+\.[[:digit:]]+-jython$ ]]; then
1234	echo "Jython"	1693	echo "Jython"
1235	else	1694	else
		1695	if [[ "${ignore_invalid}" == "0" ]]; then
1236	die "${FUNCNAME}(): Unrecognized Python ABI '$1'"	1696	die "${FUNCNAME}(): Unrecognized Python ABI '$1'"
		1697	fi
1237	fi	1698	fi
1238	}	1699	}
1239		1700
1240	# @FUNCTION: PYTHON	1701	# @FUNCTION: PYTHON
1241	# @USAGE: [-2] [-3] [--ABI] [-a\|--absolute-path] [-f\|--final-ABI] [--] <Python_ABI="${PYTHON_ABI}">	1702	# @USAGE: [-2] [-3] [--ABI] [-a\|--absolute-path] [-f\|--final-ABI] [--] <Python_ABI="${PYTHON_ABI}">
1242	# @DESCRIPTION:	1703	# @DESCRIPTION:
1243	# Print filename of Python interpreter for specified Python ABI. If Python_ABI argument	1704	# 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.	1705	# 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.	1706	# 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.	1707	# 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.	1708	# 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.	1709	# -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	1710	# If --ABI option is specified, then only specified Python ABI is printed instead of
1250	# filename of Python interpreter.	1711	# filename of Python interpreter.
1251	# If --absolute-path option is specified, then absolute path to Python interpreter is printed.	1712	# If --absolute-path option is specified, then absolute path to Python interpreter is printed.
1252	# --ABI and --absolute-path options cannot be specified simultaneously.	1713	# --ABI and --absolute-path options cannot be specified simultaneously.
1253	PYTHON() {	1714	PYTHON() {
		1715	_python_check_python_pkg_setup_execution
		1716
1254	local ABI_output="0" absolute_path_output="0" final_ABI="0" PYTHON_ABI="${PYTHON_ABI}" python_interpreter python2="0" python3="0"	1717	local ABI_output="0" absolute_path_output="0" final_ABI="0" PYTHON_ABI="${PYTHON_ABI}" python_interpreter python2="0" python3="0"
1255		1718
1256	while (($#)); do	1719	while (($#)); do
1257	case "$1" in	1720	case "$1" in
1258	-2)	1721	-2)
…		…
1283	esac	1746	esac
1284	shift	1747	shift
1285	done	1748	done
1286		1749
1287	if [[ "${ABI_output}" == "1" && "${absolute_path_output}" == "1" ]]; then	1750	if [[ "${ABI_output}" == "1" && "${absolute_path_output}" == "1" ]]; then
1288	die "${FUNCNAME}(): '--ABI and '--absolute-path' options cannot be specified simultaneously"	1751	die "${FUNCNAME}(): '--ABI' and '--absolute-path' options cannot be specified simultaneously"
1289	fi	1752	fi
1290		1753
1291	if [[ "$((${python2} + ${python3} + ${final_ABI}))" -gt 1 ]]; then	1754	if [[ "$((${python2} + ${python3} + ${final_ABI}))" -gt 1 ]]; then
1292	die "${FUNCNAME}(): '-2', '-3' or '--final-ABI' options cannot be specified simultaneously"	1755	die "${FUNCNAME}(): '-2', '-3' or '--final-ABI' options cannot be specified simultaneously"
1293	fi	1756	fi
…		…
1300	_python_calculate_PYTHON_ABIS	1763	_python_calculate_PYTHON_ABIS
1301	PYTHON_ABI="${PYTHON_ABIS##* }"	1764	PYTHON_ABI="${PYTHON_ABIS##* }"
1302	elif [[ "${python2}" == "1" ]]; then	1765	elif [[ "${python2}" == "1" ]]; then
1303	PYTHON_ABI="$(eselect python show --python2 --ABI)"	1766	PYTHON_ABI="$(eselect python show --python2 --ABI)"
1304	if [[ -z "${PYTHON_ABI}" ]]; then	1767	if [[ -z "${PYTHON_ABI}" ]]; then
1305	die "${FUNCNAME}(): Active version of Python 2 not set"	1768	die "${FUNCNAME}(): Active version of CPython 2 not set"
1306	elif [[ "${PYTHON_ABI}" != "2."* ]]; then	1769	elif [[ "${PYTHON_ABI}" != "2."* ]]; then
1307	die "${FUNCNAME}(): Internal error in \`eselect python show --python2\`"	1770	die "${FUNCNAME}(): Internal error in \`eselect python show --python2\`"
1308	fi	1771	fi
1309	elif [[ "${python3}" == "1" ]]; then	1772	elif [[ "${python3}" == "1" ]]; then
1310	PYTHON_ABI="$(eselect python show --python3 --ABI)"	1773	PYTHON_ABI="$(eselect python show --python3 --ABI)"
1311	if [[ -z "${PYTHON_ABI}" ]]; then	1774	if [[ -z "${PYTHON_ABI}" ]]; then
1312	die "${FUNCNAME}(): Active version of Python 3 not set"	1775	die "${FUNCNAME}(): Active version of CPython 3 not set"
1313	elif [[ "${PYTHON_ABI}" != "3."* ]]; then	1776	elif [[ "${PYTHON_ABI}" != "3."* ]]; then
1314	die "${FUNCNAME}(): Internal error in \`eselect python show --python3\`"	1777	die "${FUNCNAME}(): Internal error in \`eselect python show --python3\`"
1315	fi	1778	fi
1316	elif ! _python_package_supporting_installation_for_multiple_python_abis; then	1779	elif _python_package_supporting_installation_for_multiple_python_abis; then
		1780	if ! _python_abi-specific_local_scope; then
		1781	die "${FUNCNAME}() should be used in ABI-specific local scope"
		1782	fi
		1783	else
1317	PYTHON_ABI="$("${EPREFIX}/usr/bin/python" -c "${_PYTHON_ABI_EXTRACTION_COMMAND}")"	1784	PYTHON_ABI="$("${EPREFIX}/usr/bin/python" -c "${_PYTHON_ABI_EXTRACTION_COMMAND}")"
1318	if [[ -z "${PYTHON_ABI}" ]]; then	1785	if [[ -z "${PYTHON_ABI}" ]]; then
1319	die "${FUNCNAME}(): Failure of extraction of locally active version of Python"	1786	die "${FUNCNAME}(): Failure of extraction of locally active version of Python"
1320	fi	1787	fi
1321	elif [[ -z "${PYTHON_ABI}" ]]; then
1322	die "${FUNCNAME}(): Invalid usage: ${FUNCNAME}() should be used in ABI-specific local scope"
1323	fi	1788	fi
1324	elif [[ "$#" -eq 1 ]]; then	1789	elif [[ "$#" -eq 1 ]]; then
1325	if [[ "${final_ABI}" == "1" ]]; then	1790	if [[ "${final_ABI}" == "1" ]]; then
1326	die "${FUNCNAME}(): '--final-ABI' option and Python ABI cannot be specified simultaneously"	1791	die "${FUNCNAME}(): '--final-ABI' option and Python ABI cannot be specified simultaneously"
1327	fi	1792	fi
…		…
1341	return	1806	return
1342	else	1807	else
1343	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then	1808	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
1344	python_interpreter="python${PYTHON_ABI}"	1809	python_interpreter="python${PYTHON_ABI}"
1345	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then	1810	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
1346	python_interpreter="jython-${PYTHON_ABI%-jython}"	1811	python_interpreter="jython${PYTHON_ABI%-jython}"
1347	fi	1812	fi
1348		1813
1349	if [[ "${absolute_path_output}" == "1" ]]; then	1814	if [[ "${absolute_path_output}" == "1" ]]; then
1350	echo -n "${EPREFIX}/usr/bin/${python_interpreter}"	1815	echo -n "${EPREFIX}/usr/bin/${python_interpreter}"
1351	else	1816	else
…		…
1362	# @USAGE: [-f\|--final-ABI]	1827	# @USAGE: [-f\|--final-ABI]
1363	# @DESCRIPTION:	1828	# @DESCRIPTION:
1364	# Print name of Python implementation.	1829	# Print name of Python implementation.
1365	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.	1830	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
1366	python_get_implementation() {	1831	python_get_implementation() {
		1832	_python_check_python_pkg_setup_execution
		1833
1367	local final_ABI="0" PYTHON_ABI="${PYTHON_ABI}"	1834	local final_ABI="0" PYTHON_ABI="${PYTHON_ABI}"
1368		1835
1369	while (($#)); do	1836	while (($#)); do
1370	case "$1" in	1837	case "$1" in
1371	-f\|--final-ABI)	1838	-f\|--final-ABI)
…		…
1384	if [[ "${final_ABI}" == "1" ]]; then	1851	if [[ "${final_ABI}" == "1" ]]; then
1385	if ! _python_package_supporting_installation_for_multiple_python_abis; then	1852	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"	1853	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
1387	fi	1854	fi
1388	PYTHON_ABI="$(PYTHON -f --ABI)"	1855	PYTHON_ABI="$(PYTHON -f --ABI)"
1389	elif [[ -z "${PYTHON_ABI}" ]]; then	1856	else
		1857	if _python_package_supporting_installation_for_multiple_python_abis; then
		1858	if ! _python_abi-specific_local_scope; then
		1859	die "${FUNCNAME}() should be used in ABI-specific local scope"
		1860	fi
		1861	else
1390	PYTHON_ABI="$(PYTHON --ABI)"	1862	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		1863	fi
1391	fi	1864	fi
1392		1865
1393	echo "$(_python_get_implementation "${PYTHON_ABI}")"	1866	echo "$(_python_get_implementation "${PYTHON_ABI}")"
1394	}	1867	}
1395		1868
…		…
1397	# @USAGE: [-f\|--final-ABI]	1870	# @USAGE: [-f\|--final-ABI]
1398	# @DESCRIPTION:	1871	# @DESCRIPTION:
1399	# Print category, name and slot of package providing Python implementation.	1872	# 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.	1873	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
1401	python_get_implementational_package() {	1874	python_get_implementational_package() {
		1875	_python_check_python_pkg_setup_execution
		1876
1402	local final_ABI="0" PYTHON_ABI="${PYTHON_ABI}"	1877	local final_ABI="0" PYTHON_ABI="${PYTHON_ABI}"
1403		1878
1404	while (($#)); do	1879	while (($#)); do
1405	case "$1" in	1880	case "$1" in
1406	-f\|--final-ABI)	1881	-f\|--final-ABI)
…		…
1419	if [[ "${final_ABI}" == "1" ]]; then	1894	if [[ "${final_ABI}" == "1" ]]; then
1420	if ! _python_package_supporting_installation_for_multiple_python_abis; then	1895	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"	1896	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
1422	fi	1897	fi
1423	PYTHON_ABI="$(PYTHON -f --ABI)"	1898	PYTHON_ABI="$(PYTHON -f --ABI)"
1424	elif [[ -z "${PYTHON_ABI}" ]]; then	1899	else
		1900	if _python_package_supporting_installation_for_multiple_python_abis; then
		1901	if ! _python_abi-specific_local_scope; then
		1902	die "${FUNCNAME}() should be used in ABI-specific local scope"
		1903	fi
		1904	else
1425	PYTHON_ABI="$(PYTHON --ABI)"	1905	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
1426	fi	1906	fi
		1907	fi
1427		1908
		1909	if [[ "${EAPI:-0}" == "0" ]]; then
1428	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then	1910	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
1429	echo "dev-lang/python:${PYTHON_ABI}"	1911	echo "=dev-lang/python-${PYTHON_ABI}*"
1430	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then	1912	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
		1913	echo "=dev-java/jython-${PYTHON_ABI%-jython}*"
		1914	fi
		1915	else
		1916	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
		1917	echo "dev-lang/python:${PYTHON_ABI}"
		1918	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
1431	echo "dev-java/jython:${PYTHON_ABI%-jython}"	1919	echo "dev-java/jython:${PYTHON_ABI%-jython}"
		1920	fi
1432	fi	1921	fi
1433	}	1922	}
1434		1923
1435	# @FUNCTION: python_get_includedir	1924	# @FUNCTION: python_get_includedir
1436	# @USAGE: [-f\|--final-ABI]	1925	# @USAGE: [-b\|--base-path] [-f\|--final-ABI]
1437	# @DESCRIPTION:	1926	# @DESCRIPTION:
1438	# Print path to Python include directory.	1927	# Print path to Python include directory.
		1928	# 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.	1929	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
1440	python_get_includedir() {	1930	python_get_includedir() {
		1931	_python_check_python_pkg_setup_execution
		1932
1441	local final_ABI="0" PYTHON_ABI="${PYTHON_ABI}"	1933	local base_path="0" final_ABI="0" prefix PYTHON_ABI="${PYTHON_ABI}"
1442		1934
1443	while (($#)); do	1935	while (($#)); do
1444	case "$1" in	1936	case "$1" in
		1937	-b\|--base-path)
		1938	base_path="1"
		1939	;;
1445	-f\|--final-ABI)	1940	-f\|--final-ABI)
1446	final_ABI="1"	1941	final_ABI="1"
1447	;;	1942	;;
1448	-*)	1943	-*)
1449	die "${FUNCNAME}(): Unrecognized option '$1'"	1944	die "${FUNCNAME}(): Unrecognized option '$1'"
…		…
1452	die "${FUNCNAME}(): Invalid usage"	1947	die "${FUNCNAME}(): Invalid usage"
1453	;;	1948	;;
1454	esac	1949	esac
1455	shift	1950	shift
1456	done	1951	done
		1952
		1953	if [[ "${base_path}" == "0" ]]; then
		1954	prefix="/"
		1955	fi
1457		1956
1458	if [[ "${final_ABI}" == "1" ]]; then	1957	if [[ "${final_ABI}" == "1" ]]; then
1459	if ! _python_package_supporting_installation_for_multiple_python_abis; then	1958	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"	1959	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
1461	fi	1960	fi
1462	PYTHON_ABI="$(PYTHON -f --ABI)"	1961	PYTHON_ABI="$(PYTHON -f --ABI)"
1463	elif [[ -z "${PYTHON_ABI}" ]]; then	1962	else
		1963	if _python_package_supporting_installation_for_multiple_python_abis; then
		1964	if ! _python_abi-specific_local_scope; then
		1965	die "${FUNCNAME}() should be used in ABI-specific local scope"
		1966	fi
		1967	else
1464	PYTHON_ABI="$(PYTHON --ABI)"	1968	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		1969	fi
1465	fi	1970	fi
1466		1971
1467	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then	1972	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
1468	echo "/usr/include/python${PYTHON_ABI}"	1973	echo "${prefix}usr/include/python${PYTHON_ABI}"
1469	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then	1974	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
1470	echo "/usr/share/jython-${PYTHON_ABI%-jython}/Include"	1975	echo "${prefix}usr/share/jython-${PYTHON_ABI%-jython}/Include"
1471	fi	1976	fi
1472	}	1977	}
1473		1978
1474	# @FUNCTION: python_get_libdir	1979	# @FUNCTION: python_get_libdir
1475	# @USAGE: [-f\|--final-ABI]	1980	# @USAGE: [-b\|--base-path] [-f\|--final-ABI]
1476	# @DESCRIPTION:	1981	# @DESCRIPTION:
1477	# Print path to Python library directory.	1982	# Print path to Python library directory.
		1983	# If --base-path option is specified, then path not prefixed with "/" is printed.
1478	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.	1984	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
1479	python_get_libdir() {	1985	python_get_libdir() {
		1986	_python_check_python_pkg_setup_execution
		1987
1480	local final_ABI="0" PYTHON_ABI="${PYTHON_ABI}"	1988	local base_path="0" final_ABI="0" prefix PYTHON_ABI="${PYTHON_ABI}"
1481		1989
1482	while (($#)); do	1990	while (($#)); do
1483	case "$1" in	1991	case "$1" in
		1992	-b\|--base-path)
		1993	base_path="1"
		1994	;;
1484	-f\|--final-ABI)	1995	-f\|--final-ABI)
1485	final_ABI="1"	1996	final_ABI="1"
1486	;;	1997	;;
1487	-*)	1998	-*)
1488	die "${FUNCNAME}(): Unrecognized option '$1'"	1999	die "${FUNCNAME}(): Unrecognized option '$1'"
…		…
1491	die "${FUNCNAME}(): Invalid usage"	2002	die "${FUNCNAME}(): Invalid usage"
1492	;;	2003	;;
1493	esac	2004	esac
1494	shift	2005	shift
1495	done	2006	done
		2007
		2008	if [[ "${base_path}" == "0" ]]; then
		2009	prefix="/"
		2010	fi
1496		2011
1497	if [[ "${final_ABI}" == "1" ]]; then	2012	if [[ "${final_ABI}" == "1" ]]; then
1498	if ! _python_package_supporting_installation_for_multiple_python_abis; then	2013	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"	2014	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
1500	fi	2015	fi
1501	PYTHON_ABI="$(PYTHON -f --ABI)"	2016	PYTHON_ABI="$(PYTHON -f --ABI)"
1502	elif [[ -z "${PYTHON_ABI}" ]]; then	2017	else
		2018	if _python_package_supporting_installation_for_multiple_python_abis; then
		2019	if ! _python_abi-specific_local_scope; then
		2020	die "${FUNCNAME}() should be used in ABI-specific local scope"
		2021	fi
		2022	else
1503	PYTHON_ABI="$(PYTHON --ABI)"	2023	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		2024	fi
1504	fi	2025	fi
1505		2026
1506	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then	2027	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
1507	echo "/usr/$(get_libdir)/python${PYTHON_ABI}"	2028	echo "${prefix}usr/$(get_libdir)/python${PYTHON_ABI}"
1508	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then	2029	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
1509	echo "/usr/share/jython-${PYTHON_ABI%-jython}/Lib"	2030	echo "${prefix}usr/share/jython-${PYTHON_ABI%-jython}/Lib"
1510	fi	2031	fi
1511	}	2032	}
1512		2033
1513	# @FUNCTION: python_get_sitedir	2034	# @FUNCTION: python_get_sitedir
1514	# @USAGE: [-f\|--final-ABI]	2035	# @USAGE: [-b\|--base-path] [-f\|--final-ABI]
1515	# @DESCRIPTION:	2036	# @DESCRIPTION:
1516	# Print path to Python site-packages directory.	2037	# Print path to Python site-packages directory.
		2038	# If --base-path option is specified, then path not prefixed with "/" is printed.
1517	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.	2039	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
1518	python_get_sitedir() {	2040	python_get_sitedir() {
1519	local options=()	2041	_python_check_python_pkg_setup_execution
		2042
		2043	local final_ABI="0" options=()
1520		2044
1521	while (($#)); do	2045	while (($#)); do
1522	case "$1" in	2046	case "$1" in
		2047	-b\|--base-path)
		2048	options+=("$1")
		2049	;;
1523	-f\|--final-ABI)	2050	-f\|--final-ABI)
1524	if ! _python_package_supporting_installation_for_multiple_python_abis; then	2051	final_ABI="1"
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")	2052	options+=("$1")
1528	;;	2053	;;
1529	-*)	2054	-*)
1530	die "${FUNCNAME}(): Unrecognized option '$1'"	2055	die "${FUNCNAME}(): Unrecognized option '$1'"
1531	;;	2056	;;
…		…
1534	;;	2059	;;
1535	esac	2060	esac
1536	shift	2061	shift
1537	done	2062	done
1538		2063
		2064	if [[ "${final_ABI}" == "1" ]]; then
		2065	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		2066	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		2067	fi
		2068	else
		2069	if _python_package_supporting_installation_for_multiple_python_abis && ! _python_abi-specific_local_scope; then
		2070	die "${FUNCNAME}() should be used in ABI-specific local scope"
		2071	fi
		2072	fi
		2073
1539	echo "$(python_get_libdir "${options[@]}")/site-packages"	2074	echo "$(python_get_libdir "${options[@]}")/site-packages"
1540	}	2075	}
1541		2076
1542	# @FUNCTION: python_get_library	2077	# @FUNCTION: python_get_library
1543	# @USAGE: [-f\|--final-ABI] [-l\|--linker-option]	2078	# @USAGE: [-b\|--base-path] [-f\|--final-ABI] [-l\|--linker-option]
1544	# @DESCRIPTION:	2079	# @DESCRIPTION:
1545	# Print path to Python library.	2080	# Print path to Python library.
		2081	# If --base-path option is specified, then path not prefixed with "/" is printed.
1546	# If --linker-option is specified, then "-l${library}" linker option is printed.	2082	# 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.	2083	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
1548	python_get_library() {	2084	python_get_library() {
		2085	_python_check_python_pkg_setup_execution
		2086
1549	local final_ABI="0" linker_option="0" PYTHON_ABI="${PYTHON_ABI}"	2087	local base_path="0" final_ABI="0" linker_option="0" prefix PYTHON_ABI="${PYTHON_ABI}"
1550		2088
1551	while (($#)); do	2089	while (($#)); do
1552	case "$1" in	2090	case "$1" in
		2091	-b\|--base-path)
		2092	base_path="1"
		2093	;;
1553	-f\|--final-ABI)	2094	-f\|--final-ABI)
1554	final_ABI="1"	2095	final_ABI="1"
1555	;;	2096	;;
1556	-l\|--linker-option)	2097	-l\|--linker-option)
1557	linker_option="1"	2098	linker_option="1"
…		…
1563	die "${FUNCNAME}(): Invalid usage"	2104	die "${FUNCNAME}(): Invalid usage"
1564	;;	2105	;;
1565	esac	2106	esac
1566	shift	2107	shift
1567	done	2108	done
		2109
		2110	if [[ "${base_path}" == "0" ]]; then
		2111	prefix="/"
		2112	fi
		2113
		2114	if [[ "${base_path}" == "1" && "${linker_option}" == "1" ]]; then
		2115	die "${FUNCNAME}(): '--base-path' and '--linker-option' options cannot be specified simultaneously"
		2116	fi
1568		2117
1569	if [[ "${final_ABI}" == "1" ]]; then	2118	if [[ "${final_ABI}" == "1" ]]; then
1570	if ! _python_package_supporting_installation_for_multiple_python_abis; then	2119	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"	2120	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
1572	fi	2121	fi
1573	PYTHON_ABI="$(PYTHON -f --ABI)"	2122	PYTHON_ABI="$(PYTHON -f --ABI)"
1574	elif [[ -z "${PYTHON_ABI}" ]]; then	2123	else
		2124	if _python_package_supporting_installation_for_multiple_python_abis; then
		2125	if ! _python_abi-specific_local_scope; then
		2126	die "${FUNCNAME}() should be used in ABI-specific local scope"
		2127	fi
		2128	else
1575	PYTHON_ABI="$(PYTHON --ABI)"	2129	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		2130	fi
1576	fi	2131	fi
1577		2132
1578	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then	2133	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
1579	if [[ "${linker_option}" == "1" ]]; then	2134	if [[ "${linker_option}" == "1" ]]; then
1580	echo "-lpython${PYTHON_ABI}"	2135	echo "-lpython${PYTHON_ABI}"
1581	else	2136	else
1582	echo "/usr/$(get_libdir)/libpython${PYTHON_ABI}$(get_libname)"	2137	echo "${prefix}usr/$(get_libdir)/libpython${PYTHON_ABI}$(get_libname)"
1583	fi	2138	fi
1584	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then	2139	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
1585	die "${FUNCNAME}(): Jython does not have shared library"	2140	die "${FUNCNAME}(): Jython does not have shared library"
1586	fi	2141	fi
1587	}	2142	}
…		…
1592	# Print Python version.	2147	# Print Python version.
1593	# --full, --major, --minor and --micro options cannot be specified simultaneously.	2148	# --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.	2149	# 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.	2150	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
1596	python_get_version() {	2151	python_get_version() {
		2152	_python_check_python_pkg_setup_execution
		2153
1597	local final_ABI="0" full="0" major="0" minor="0" micro="0" python_command	2154	local final_ABI="0" full="0" major="0" minor="0" micro="0" python_command
1598		2155
1599	while (($#)); do	2156	while (($#)); do
1600	case "$1" in	2157	case "$1" in
1601	-f\|--final-ABI)	2158	-f\|--final-ABI)
…		…
1651	if ! _python_package_supporting_installation_for_multiple_python_abis; then	2208	if ! _python_package_supporting_installation_for_multiple_python_abis; then
1652	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"	2209	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
1653	fi	2210	fi
1654	"$(PYTHON -f)" -c "${python_command}"	2211	"$(PYTHON -f)" -c "${python_command}"
1655	else	2212	else
		2213	if _python_package_supporting_installation_for_multiple_python_abis && ! _python_abi-specific_local_scope; then
		2214	die "${FUNCNAME}() should be used in ABI-specific local scope"
		2215	fi
1656	"$(PYTHON ${PYTHON_ABI})" -c "${python_command}"	2216	"$(PYTHON ${PYTHON_ABI})" -c "${python_command}"
1657	fi	2217	fi
1658	}	2218	}
1659		2219
1660	# ================================================================================================	2220	# ================================================================================================
…		…
1682	# @DESCRIPTION:	2242	# @DESCRIPTION:
1683	# Execute nosetests for all enabled Python ABIs.	2243	# Execute nosetests for all enabled Python ABIs.
1684	# In ebuilds of packages supporting installation for multiple Python ABIs, this function calls	2244	# 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.	2245	# python_execute_nosetests_pre_hook() and python_execute_nosetests_post_hook(), if they are defined.
1686	python_execute_nosetests() {	2246	python_execute_nosetests() {
		2247	_python_check_python_pkg_setup_execution
1687	_python_set_color_variables	2248	_python_set_color_variables
1688		2249
1689	local PYTHONPATH_template= separate_build_dirs=	2250	local PYTHONPATH_template separate_build_dirs
1690		2251
1691	while (($#)); do	2252	while (($#)); do
1692	case "$1" in	2253	case "$1" in
1693	-P\|--PYTHONPATH)	2254	-P\|--PYTHONPATH)
1694	PYTHONPATH_template="$2"	2255	PYTHONPATH_template="$2"
…		…
1710	esac	2271	esac
1711	shift	2272	shift
1712	done	2273	done
1713		2274
1714	python_test_function() {	2275	python_test_function() {
1715	local evaluated_PYTHONPATH=	2276	local evaluated_PYTHONPATH
1716		2277
1717	if [[ -n "${PYTHONPATH_template}" ]]; then
1718	evaluated_PYTHONPATH="$(eval echo -n "${PYTHONPATH_template}")"	2278	eval "evaluated_PYTHONPATH=\"${PYTHONPATH_template}\""
1719	if [[ ! -e "${evaluated_PYTHONPATH}" ]]; then
1720	unset evaluated_PYTHONPATH
1721	fi
1722	fi
1723		2279
1724	_python_test_hook pre	2280	_python_test_hook pre
1725		2281
1726	if [[ -n "${evaluated_PYTHONPATH}" ]]; then	2282	if [[ -n "${evaluated_PYTHONPATH}" ]]; then
1727	echo ${_BOLD}PYTHONPATH="${evaluated_PYTHONPATH}" nosetests --verbosity="${PYTHON_TEST_VERBOSITY}" "$@"${_NORMAL}	2283	echo ${_BOLD}PYTHONPATH="${evaluated_PYTHONPATH}" nosetests --verbosity="${PYTHON_TEST_VERBOSITY}" "$@"${_NORMAL}
…		…
1750	# @DESCRIPTION:	2306	# @DESCRIPTION:
1751	# Execute py.test for all enabled Python ABIs.	2307	# Execute py.test for all enabled Python ABIs.
1752	# In ebuilds of packages supporting installation for multiple Python ABIs, this function calls	2308	# 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.	2309	# python_execute_py.test_pre_hook() and python_execute_py.test_post_hook(), if they are defined.
1754	python_execute_py.test() {	2310	python_execute_py.test() {
		2311	_python_check_python_pkg_setup_execution
1755	_python_set_color_variables	2312	_python_set_color_variables
1756		2313
1757	local PYTHONPATH_template= separate_build_dirs=	2314	local PYTHONPATH_template separate_build_dirs
1758		2315
1759	while (($#)); do	2316	while (($#)); do
1760	case "$1" in	2317	case "$1" in
1761	-P\|--PYTHONPATH)	2318	-P\|--PYTHONPATH)
1762	PYTHONPATH_template="$2"	2319	PYTHONPATH_template="$2"
…		…
1778	esac	2335	esac
1779	shift	2336	shift
1780	done	2337	done
1781		2338
1782	python_test_function() {	2339	python_test_function() {
1783	local evaluated_PYTHONPATH=	2340	local evaluated_PYTHONPATH
1784		2341
1785	if [[ -n "${PYTHONPATH_template}" ]]; then
1786	evaluated_PYTHONPATH="$(eval echo -n "${PYTHONPATH_template}")"	2342	eval "evaluated_PYTHONPATH=\"${PYTHONPATH_template}\""
1787	if [[ ! -e "${evaluated_PYTHONPATH}" ]]; then
1788	unset evaluated_PYTHONPATH
1789	fi
1790	fi
1791		2343
1792	_python_test_hook pre	2344	_python_test_hook pre
1793		2345
1794	if [[ -n "${evaluated_PYTHONPATH}" ]]; then	2346	if [[ -n "${evaluated_PYTHONPATH}" ]]; then
1795	echo ${_BOLD}PYTHONPATH="${evaluated_PYTHONPATH}" py.test $([[ "${PYTHON_TEST_VERBOSITY}" -ge 2 ]] && echo -v) "$@"${_NORMAL}	2347	echo ${_BOLD}PYTHONPATH="${evaluated_PYTHONPATH}" py.test $([[ "${PYTHON_TEST_VERBOSITY}" -ge 2 ]] && echo -v) "$@"${_NORMAL}
…		…
1818	# @DESCRIPTION:	2370	# @DESCRIPTION:
1819	# Execute trial for all enabled Python ABIs.	2371	# Execute trial for all enabled Python ABIs.
1820	# In ebuilds of packages supporting installation for multiple Python ABIs, this function	2372	# 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.	2373	# calls python_execute_trial_pre_hook() and python_execute_trial_post_hook(), if they are defined.
1822	python_execute_trial() {	2374	python_execute_trial() {
		2375	_python_check_python_pkg_setup_execution
1823	_python_set_color_variables	2376	_python_set_color_variables
1824		2377
1825	local PYTHONPATH_template= separate_build_dirs=	2378	local PYTHONPATH_template separate_build_dirs
1826		2379
1827	while (($#)); do	2380	while (($#)); do
1828	case "$1" in	2381	case "$1" in
1829	-P\|--PYTHONPATH)	2382	-P\|--PYTHONPATH)
1830	PYTHONPATH_template="$2"	2383	PYTHONPATH_template="$2"
…		…
1846	esac	2399	esac
1847	shift	2400	shift
1848	done	2401	done
1849		2402
1850	python_test_function() {	2403	python_test_function() {
1851	local evaluated_PYTHONPATH=	2404	local evaluated_PYTHONPATH
1852		2405
1853	if [[ -n "${PYTHONPATH_template}" ]]; then
1854	evaluated_PYTHONPATH="$(eval echo -n "${PYTHONPATH_template}")"	2406	eval "evaluated_PYTHONPATH=\"${PYTHONPATH_template}\""
1855	if [[ ! -e "${evaluated_PYTHONPATH}" ]]; then
1856	unset evaluated_PYTHONPATH
1857	fi
1858	fi
1859		2407
1860	_python_test_hook pre	2408	_python_test_hook pre
1861		2409
1862	if [[ -n "${evaluated_PYTHONPATH}" ]]; then	2410	if [[ -n "${evaluated_PYTHONPATH}" ]]; then
1863	echo ${_BOLD}PYTHONPATH="${evaluated_PYTHONPATH}" trial $([[ "${PYTHON_TEST_VERBOSITY}" -ge 4 ]] && echo --spew) "$@"${_NORMAL}	2411	echo ${_BOLD}PYTHONPATH="${evaluated_PYTHONPATH}" trial $([[ "${PYTHON_TEST_VERBOSITY}" -ge 4 ]] && echo --spew) "$@"${_NORMAL}
…		…
1888	# @FUNCTION: python_enable_pyc	2436	# @FUNCTION: python_enable_pyc
1889	# @DESCRIPTION:	2437	# @DESCRIPTION:
1890	# Tell Python to automatically recompile modules to .pyc/.pyo if the	2438	# Tell Python to automatically recompile modules to .pyc/.pyo if the
1891	# timestamps/version stamps have changed.	2439	# timestamps/version stamps have changed.
1892	python_enable_pyc() {	2440	python_enable_pyc() {
		2441	_python_check_python_pkg_setup_execution
		2442
		2443	if [[ "$#" -ne 0 ]]; then
		2444	die "${FUNCNAME}() does not accept arguments"
		2445	fi
		2446
1893	unset PYTHONDONTWRITEBYTECODE	2447	unset PYTHONDONTWRITEBYTECODE
1894	}	2448	}
1895		2449
1896	# @FUNCTION: python_disable_pyc	2450	# @FUNCTION: python_disable_pyc
1897	# @DESCRIPTION:	2451	# @DESCRIPTION:
1898	# Tell Python not to automatically recompile modules to .pyc/.pyo	2452	# Tell Python not to automatically recompile modules to .pyc/.pyo
1899	# even if the timestamps/version stamps do not match. This is done	2453	# even if the timestamps/version stamps do not match. This is done
1900	# to protect sandbox.	2454	# to protect sandbox.
1901	python_disable_pyc() {	2455	python_disable_pyc() {
		2456	_python_check_python_pkg_setup_execution
		2457
		2458	if [[ "$#" -ne 0 ]]; then
		2459	die "${FUNCNAME}() does not accept arguments"
		2460	fi
		2461
1902	export PYTHONDONTWRITEBYTECODE="1"	2462	export PYTHONDONTWRITEBYTECODE="1"
1903	}	2463	}
1904		2464
1905	_python_clean_compiled_modules() {	2465	_python_clean_compiled_modules() {
1906	_python_initialize_prefix_variables	2466	_python_initialize_prefix_variables
1907	_python_set_color_variables	2467	_python_set_color_variables
1908		2468
1909	[[ "${FUNCNAME[1]}" =~ ^(python_mod_optimize\|python_mod_compile\|python_mod_cleanup)$ ]] \|\| die "${FUNCNAME}(): Invalid usage"	2469	[[ "${FUNCNAME[1]}" =~ ^(python_mod_optimize\|python_mod_cleanup)$ ]] \|\| die "${FUNCNAME}(): Invalid usage"
1910		2470
1911	local base_module_name compiled_file compiled_files=() dir path py_file root	2471	local base_module_name compiled_file compiled_files=() dir path py_file root
1912		2472
1913	# Strip trailing slash from EROOT.	2473	# Strip trailing slash from EROOT.
1914	root="${EROOT%/}"	2474	root="${EROOT%/}"
…		…
1921	done < <(find "${path}" "(" -name ".py[co]" -o -name "\$py.class" ")" -print0)	2481	done < <(find "${path}" "(" -name ".py[co]" -o -name "\$py.class" ")" -print0)
1922		2482
1923	if [[ "${EBUILD_PHASE}" == "postrm" ]]; then	2483	if [[ "${EBUILD_PHASE}" == "postrm" ]]; then
1924	# Delete empty child directories.	2484	# Delete empty child directories.
1925	find "${path}" -type d \| sort -r \| while read -r dir; do	2485	find "${path}" -type d \| sort -r \| while read -r dir; do
1926	rmdir "${dir}" 2> /dev/null && echo "${_CYAN}<<< ${dir}${_NORMAL}"	2486	if rmdir "${dir}" 2> /dev/null; then
		2487	echo "${_CYAN}<<< ${dir}${_NORMAL}"
		2488	fi
1927	done	2489	done
1928	fi	2490	fi
1929	elif [[ "${path}" == *.py ]]; then	2491	elif [[ "${path}" == *.py ]]; then
1930	base_module_name="${path##*/}"	2492	base_module_name="${path##*/}"
1931	base_module_name="${base_module_name%.py}"	2493	base_module_name="${base_module_name%.py}"
…		…
1961	if [[ "${dir}" == "__pycache__" ]]; then	2523	if [[ "${dir}" == "__pycache__" ]]; then
1962	base_module_name="${compiled_file##*/}"	2524	base_module_name="${compiled_file##*/}"
1963	base_module_name="${base_module_name%\$py.class}"	2525	base_module_name="${base_module_name%\$py.class}"
1964	py_file="${compiled_file%__pycache__/*}${base_module_name}.py"	2526	py_file="${compiled_file%__pycache__/*}${base_module_name}.py"
1965	else	2527	else
1966	py_file="${compiled_file%\$py.class}"	2528	py_file="${compiled_file%\$py.class}.py"
1967	fi	2529	fi
1968	if [[ "${EBUILD_PHASE}" == "postinst" ]]; then	2530	if [[ "${EBUILD_PHASE}" == "postinst" ]]; then
1969	[[ -f "${py_file}" && "${compiled_file}" -nt "${py_file}" ]] && continue	2531	[[ -f "${py_file}" && "${compiled_file}" -nt "${py_file}" ]] && continue
1970	else	2532	else
1971	[[ -f "${py_file}" ]] && continue	2533	[[ -f "${py_file}" ]] && continue
…		…
1977	fi	2539	fi
1978		2540
1979	# Delete empty parent directories.	2541	# Delete empty parent directories.
1980	dir="${compiled_file%/*}"	2542	dir="${compiled_file%/*}"
1981	while [[ "${dir}" != "${root}" ]]; do	2543	while [[ "${dir}" != "${root}" ]]; do
1982	if rmdir "${compiled_file%/*}" 2> /dev/null; then	2544	if rmdir "${dir}" 2> /dev/null; then
1983	echo "${_CYAN}<<< ${compiled_file%/*}${_NORMAL}"	2545	echo "${_CYAN}<<< ${dir}${_NORMAL}"
1984	else	2546	else
1985	break	2547	break
1986	fi	2548	fi
1987	dir="${dir%/*}"	2549	dir="${dir%/*}"
1988	done	2550	done
1989	done	2551	done
1990	done	2552	done
1991	}	2553	}
1992		2554
1993	# @FUNCTION: python_mod_optimize	2555	# @FUNCTION: python_mod_optimize
1994	# @USAGE: [options] [directory\|file]	2556	# @USAGE: [--allow-evaluated-non-sitedir-paths] [-d directory] [-f] [-l] [-q] [-x regular_expression] [--] <file\|directory> [files\|directories]
1995	# @DESCRIPTION:	2557	# @DESCRIPTION:
1996	# If no arguments supplied, it will recompile not recursively all modules	2558	# 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.	2559	# -d, -f, -l, -q and -x options passed to this function are passed to compileall.py.
2003	#	2560	#
2004	# This function can be used only in pkg_postinst() phase.	2561	# This function can be used only in pkg_postinst() phase.
2005	python_mod_optimize() {	2562	python_mod_optimize() {
		2563	if [[ "${EBUILD_PHASE}" != "postinst" ]]; then
		2564	die "${FUNCNAME}() can be used only in pkg_postinst() phase"
		2565	fi
		2566
		2567	_python_check_python_pkg_setup_execution
2006	_python_initialize_prefix_variables	2568	_python_initialize_prefix_variables
2007		2569
2008	# Check if phase is pkg_postinst().	2570	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.	2571	# 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=()	2572	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=()
2014		2573
2015	if _python_package_supporting_installation_for_multiple_python_abis; then	2574	if _python_package_supporting_installation_for_multiple_python_abis; then
2016	if [[ -z "${PYTHON_ABIS}" ]]; then	2575	if has "${EAPI:-0}" 0 1 2 3 && [[ -z "${PYTHON_ABIS}" ]]; then
2017	die "${FUNCNAME}(): Environment not initialized"	2576	die "${FUNCNAME}(): python_pkg_setup() or python_execute_function() not called"
2018	fi	2577	fi
2019	iterated_PYTHON_ABIS="${PYTHON_ABIS}"	2578	iterated_PYTHON_ABIS="${PYTHON_ABIS}"
2020	else	2579	else
		2580	if has "${EAPI:-0}" 0 1 2 3; then
2021	iterated_PYTHON_ABIS="${PYTHON_ABI:=$(PYTHON --ABI)}"	2581	iterated_PYTHON_ABIS="${PYTHON_ABI:=$(PYTHON --ABI)}"
		2582	else
		2583	iterated_PYTHON_ABIS="${PYTHON_ABI}"
		2584	fi
2022	fi	2585	fi
2023		2586
2024	# Strip trailing slash from EROOT.	2587	# Strip trailing slash from EROOT.
2025	root="${EROOT%/}"	2588	root="${EROOT%/}"
2026		2589
2027	while (($#)); do	2590	while (($#)); do
2028	case "$1" in	2591	case "$1" in
		2592	--allow-evaluated-non-sitedir-paths)
		2593	allow_evaluated_non_sitedir_paths="1"
		2594	;;
2029	-l\|-f\|-q)	2595	-l\|-f\|-q)
2030	options+=("$1")	2596	options+=("$1")
2031	;;	2597	;;
2032	-d\|-x)	2598	-d\|-x)
2033	options+=("$1" "$2")	2599	options+=("$1" "$2")
2034	shift	2600	shift
2035	;;	2601	;;
		2602	--)
		2603	shift
		2604	break
		2605	;;
2036	-*)	2606	-*)
2037	ewarn "${FUNCNAME}(): Ignoring option '$1'"	2607	die "${FUNCNAME}(): Unrecognized option '$1'"
2038	;;	2608	;;
2039	*)	2609	*)
2040	break	2610	break
2041	;;	2611	;;
2042	esac	2612	esac
2043	shift	2613	shift
2044	done	2614	done
2045		2615
		2616	if [[ "${allow_evaluated_non_sitedir_paths}" == "1" ]] && ! _python_package_supporting_installation_for_multiple_python_abis; then
		2617	die "${FUNCNAME}(): '--allow-evaluated-non-sitedir-paths' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		2618	fi
		2619
2046	if [[ "$#" -eq 0 ]]; then	2620	if [[ "$#" -eq 0 ]]; then
2047	_python_set_color_variables	2621	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	2622	fi
2061		2623
2062	while (($#)); do	2624	while (($#)); do
		2625	if [[ "$1" =~ ^($\|(\.\|\.\.\|/)($\|/)) ]]; then
		2626	die "${FUNCNAME}(): Invalid argument '$1'"
2063	if ! _python_implementation && [[ "$1" =~ ^/usr/lib(32\|64)?/python[[:digit:]]+\.[[:digit:]]+ ]]; then	2627	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"	2628	die "${FUNCNAME}(): Paths of directories / files in site-packages directories must be relative to site-packages directories"
2065	elif [[ "$1" =~ ^/ ]]; then	2629	elif [[ "$1" =~ ^/ ]]; then
2066	if _python_package_supporting_installation_for_multiple_python_abis; then	2630	if _python_package_supporting_installation_for_multiple_python_abis; then
		2631	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"	2632	die "${FUNCNAME}(): Absolute paths cannot be used in ebuilds of packages supporting installation for multiple Python ABIs"
2068	fi	2633	fi
2069	if [[ -d "${root}$1" ]]; then	2634	if [[ "$1" != \$ ]]; then
2070	other_dirs+=("${root}$1")	2635	die "${FUNCNAME}(): '$1' has invalid syntax"
2071	elif [[ -f "${root}$1" ]]; then	2636	fi
2072	other_files+=("${root}$1")	2637	if [[ "$1" == *.py ]]; then
2073	elif [[ -e "${root}$1" ]]; then	2638	evaluated_files+=("$1")
2074	eerror "'${root}$1' is not a file or a directory!"	2639	else
		2640	evaluated_dirs+=("$1")
		2641	fi
2075	else	2642	else
		2643	if [[ -d "${root}$1" ]]; then
		2644	other_dirs+=("${root}$1")
		2645	elif [[ -f "${root}$1" ]]; then
		2646	other_files+=("${root}$1")
		2647	elif [[ -e "${root}$1" ]]; then
		2648	eerror "${FUNCNAME}(): '${root}$1' is not a regular file or a directory"
		2649	else
2076	eerror "'${root}$1' does not exist!"	2650	eerror "${FUNCNAME}(): '${root}$1' does not exist"
		2651	fi
2077	fi	2652	fi
2078	else	2653	else
2079	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do	2654	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do
2080	if [[ -d "${root}$(python_get_sitedir)/$1" ]]; then	2655	if [[ -d "${root}$(python_get_sitedir)/$1" ]]; then
2081	site_packages_dirs+=("$1")	2656	site_packages_dirs+=("$1")
2082	break	2657	break
2083	elif [[ -f "${root}$(python_get_sitedir)/$1" ]]; then	2658	elif [[ -f "${root}$(python_get_sitedir)/$1" ]]; then
2084	site_packages_files+=("$1")	2659	site_packages_files+=("$1")
2085	break	2660	break
2086	elif [[ -e "${root}$(python_get_sitedir)/$1" ]]; then	2661	elif [[ -e "${root}$(python_get_sitedir)/$1" ]]; then
2087	eerror "'$1' is not a file or a directory!"	2662	eerror "${FUNCNAME}(): '$1' is not a regular file or a directory"
2088	else	2663	else
2089	eerror "'$1' does not exist!"	2664	eerror "${FUNCNAME}(): '$1' does not exist"
2090	fi	2665	fi
2091	done	2666	done
2092	fi	2667	fi
2093	shift	2668	shift
2094	done	2669	done
2095		2670
2096	# Set additional options.	2671	# Set additional options.
2097	options+=("-q")	2672	options+=("-q")
2098		2673
2099	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do	2674	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do
2100	if ((${#site_packages_dirs[@]})) \|\| ((${#site_packages_files[@]})); then	2675	if ((${#site_packages_dirs[@]})) \|\| ((${#site_packages_files[@]})) \|\| ((${#evaluated_dirs[@]})) \|\| ((${#evaluated_files[@]})); then
2101	return_code="0"	2676	return_code="0"
2102	ebegin "Compilation and optimization of Python modules for $(python_get_implementation) $(python_get_version)"	2677	ebegin "Compilation and optimization of Python modules for $(python_get_implementation) $(python_get_version)"
2103	if ((${#site_packages_dirs[@]})); then	2678	if ((${#site_packages_dirs[@]})) \|\| ((${#evaluated_dirs[@]})); then
2104	for dir in "${site_packages_dirs[@]}"; do	2679	for dir in "${site_packages_dirs[@]}"; do
2105	site_packages_absolute_dirs+=("${root}$(python_get_sitedir)/${dir}")	2680	dirs+=("${root}$(python_get_sitedir)/${dir}")
2106	done	2681	done
		2682	for dir in "${evaluated_dirs[@]}"; do
		2683	eval "dirs+=(\"\${root}${dir}\")"
		2684	done
2107	"$(PYTHON)" "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${site_packages_absolute_dirs[@]}" \|\| return_code="1"	2685	"$(PYTHON)" "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${dirs[@]}" \|\| return_code="1"
2108	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" != "Jython" ]]; then	2686	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" != "Jython" ]]; then
2109	"$(PYTHON)" -O "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${site_packages_absolute_dirs[@]}" &> /dev/null \|\| return_code="1"	2687	"$(PYTHON)" -O "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${dirs[@]}" &> /dev/null \|\| return_code="1"
2110	fi	2688	fi
2111	_python_clean_compiled_modules "${site_packages_absolute_dirs[@]}"	2689	_python_clean_compiled_modules "${dirs[@]}"
2112	fi	2690	fi
2113	if ((${#site_packages_files[@]})); then	2691	if ((${#site_packages_files[@]})) \|\| ((${#evaluated_files[@]})); then
2114	for file in "${site_packages_files[@]}"; do	2692	for file in "${site_packages_files[@]}"; do
2115	site_packages_absolute_files+=("${root}$(python_get_sitedir)/${file}")	2693	files+=("${root}$(python_get_sitedir)/${file}")
2116	done	2694	done
		2695	for file in "${evaluated_files[@]}"; do
		2696	eval "files+=(\"\${root}${file}\")"
		2697	done
2117	"$(PYTHON)" "${root}$(python_get_libdir)/py_compile.py" "${site_packages_absolute_files[@]}" \|\| return_code="1"	2698	"$(PYTHON)" "${root}$(python_get_libdir)/py_compile.py" "${files[@]}" \|\| return_code="1"
2118	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" != "Jython" ]]; then	2699	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" != "Jython" ]]; then
2119	"$(PYTHON)" -O "${root}$(python_get_libdir)/py_compile.py" "${site_packages_absolute_files[@]}" &> /dev/null \|\| return_code="1"	2700	"$(PYTHON)" -O "${root}$(python_get_libdir)/py_compile.py" "${files[@]}" &> /dev/null \|\| return_code="1"
2120	fi	2701	fi
2121	_python_clean_compiled_modules "${site_packages_absolute_files[@]}"	2702	_python_clean_compiled_modules "${files[@]}"
2122	fi	2703	fi
2123	eend "${return_code}"	2704	eend "${return_code}"
2124	fi	2705	fi
2125	unset site_packages_absolute_dirs site_packages_absolute_files	2706	unset dirs files
2126	done	2707	done
2127		2708
2128	if _python_package_supporting_installation_for_multiple_python_abis; then	2709	if _python_package_supporting_installation_for_multiple_python_abis; then
2129	# Restore previous value of PYTHON_ABI.	2710	# Restore previous value of PYTHON_ABI.
2130	if [[ -n "${previous_PYTHON_ABI}" ]]; then	2711	if [[ -n "${previous_PYTHON_ABI}" ]]; then
…		…
2147	if ((${#other_files[@]})); then	2728	if ((${#other_files[@]})); then
2148	"$(PYTHON ${PYTHON_ABI})" "${root}$(python_get_libdir)/py_compile.py" "${other_files[@]}" \|\| return_code="1"	2729	"$(PYTHON ${PYTHON_ABI})" "${root}$(python_get_libdir)/py_compile.py" "${other_files[@]}" \|\| return_code="1"
2149	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" != "Jython" ]]; then	2730	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" != "Jython" ]]; then
2150	"$(PYTHON ${PYTHON_ABI})" -O "${root}$(python_get_libdir)/py_compile.py" "${other_files[@]}" &> /dev/null \|\| return_code="1"	2731	"$(PYTHON ${PYTHON_ABI})" -O "${root}$(python_get_libdir)/py_compile.py" "${other_files[@]}" &> /dev/null \|\| return_code="1"
2151	fi	2732	fi
2152	_python_clean_compiled_modules "${other_dirs[@]}"	2733	_python_clean_compiled_modules "${other_files[@]}"
2153	fi	2734	fi
2154	eend "${return_code}"	2735	eend "${return_code}"
2155	fi	2736	fi
2156	else	2737	else
2157	# Deprecated part of python_mod_optimize()	2738	# Deprecated part of python_mod_optimize()
		2739	ewarn
		2740	ewarn "Deprecation Warning: Usage of ${FUNCNAME}() in packages not supporting installation"
		2741	ewarn "for multiple Python ABIs in EAPI <=2 is deprecated and will be disallowed on 2011-08-01."
		2742	ewarn "Use EAPI >=3 and call ${FUNCNAME}() with paths having appropriate syntax."
		2743	ewarn "The ebuild needs to be fixed. Please report a bug, if it has not been already reported."
		2744	ewarn
2158		2745
2159	local myroot mydirs=() myfiles=() myopts=() return_code="0"	2746	local myroot mydirs=() myfiles=() myopts=() return_code="0"
2160		2747
2161	# strip trailing slash	2748	# strip trailing slash
2162	myroot="${EROOT%/}"	2749	myroot="${EROOT%/}"
…		…
2169	;;	2756	;;
2170	-d\|-x)	2757	-d\|-x)
2171	myopts+=("$1" "$2")	2758	myopts+=("$1" "$2")
2172	shift	2759	shift
2173	;;	2760	;;
		2761	--)
		2762	shift
		2763	break
		2764	;;
2174	-*)	2765	-*)
2175	ewarn "${FUNCNAME}(): Ignoring option '$1'"	2766	die "${FUNCNAME}(): Unrecognized option '$1'"
2176	;;	2767	;;
2177	*)	2768	*)
2178	break	2769	break
2179	;;	2770	;;
2180	esac	2771	esac
2181	shift	2772	shift
2182	done	2773	done
2183		2774
2184	if [[ "$#" -eq 0 ]]; then	2775	if [[ "$#" -eq 0 ]]; then
2185	_python_set_color_variables	2776	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	2777	fi
2199		2778
2200	while (($#)); do	2779	while (($#)); do
		2780	if [[ "$1" =~ ^($\|(\.\|\.\.\|/)($\|/)) ]]; then
		2781	die "${FUNCNAME}(): Invalid argument '$1'"
2201	if [[ -d "${myroot}/${1#/}" ]]; then	2782	elif [[ -d "${myroot}/${1#/}" ]]; then
2202	mydirs+=("${myroot}/${1#/}")	2783	mydirs+=("${myroot}/${1#/}")
2203	elif [[ -f "${myroot}/${1#/}" ]]; then	2784	elif [[ -f "${myroot}/${1#/}" ]]; then
2204	# Files are passed to python_mod_compile which is EROOT-aware	2785	myfiles+=("${myroot}/${1#/}")
2205	myfiles+=("$1")
2206	elif [[ -e "${myroot}/${1#/}" ]]; then	2786	elif [[ -e "${myroot}/${1#/}" ]]; then
2207	eerror "${myroot}/${1#/} is not a file or directory!"	2787	eerror "${FUNCNAME}(): ${myroot}/${1#/} is not a regular file or directory"
2208	else	2788	else
2209	eerror "${myroot}/${1#/} does not exist!"	2789	eerror "${FUNCNAME}(): ${myroot}/${1#/} does not exist"
2210	fi	2790	fi
2211	shift	2791	shift
2212	done	2792	done
2213		2793
2214	# set additional opts	2794	# set additional opts
…		…
2222	"$(PYTHON ${PYTHON_ABI})" -O "${myroot}$(python_get_libdir)/compileall.py" "${myopts[@]}" "${mydirs[@]}" &> /dev/null \|\| return_code="1"	2802	"$(PYTHON ${PYTHON_ABI})" -O "${myroot}$(python_get_libdir)/compileall.py" "${myopts[@]}" "${mydirs[@]}" &> /dev/null \|\| return_code="1"
2223	_python_clean_compiled_modules "${mydirs[@]}"	2803	_python_clean_compiled_modules "${mydirs[@]}"
2224	fi	2804	fi
2225		2805
2226	if ((${#myfiles[@]})); then	2806	if ((${#myfiles[@]})); then
		2807	"$(PYTHON ${PYTHON_ABI})" "${myroot}$(python_get_libdir)/py_compile.py" "${myfiles[@]}" \|\| return_code="1"
		2808	"$(PYTHON ${PYTHON_ABI})" -O "${myroot}$(python_get_libdir)/py_compile.py" "${myfiles[@]}" &> /dev/null \|\| return_code="1"
2227	python_mod_compile "${myfiles[@]}"	2809	_python_clean_compiled_modules "${myfiles[@]}"
2228	fi	2810	fi
2229		2811
2230	eend "${return_code}"	2812	eend "${return_code}"
2231	fi	2813	fi
2232	}	2814	}
2233		2815
2234	# @FUNCTION: python_mod_cleanup	2816	# @FUNCTION: python_mod_cleanup
2235	# @USAGE: [directory\|file]	2817	# @USAGE: [--allow-evaluated-non-sitedir-paths] [--] <file\|directory> [files\|directories]
2236	# @DESCRIPTION:	2818	# @DESCRIPTION:
2237	# Run with optional arguments, where arguments are Python modules. If none given,	2819	# 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	#	2820	#
2244	# This function can be used only in pkg_postrm() phase.	2821	# This function can be used only in pkg_postrm() phase.
2245	python_mod_cleanup() {	2822	python_mod_cleanup() {
		2823	if [[ "${EBUILD_PHASE}" != "postrm" ]]; then
		2824	die "${FUNCNAME}() can be used only in pkg_postrm() phase"
		2825	fi
		2826
		2827	_python_check_python_pkg_setup_execution
2246	_python_initialize_prefix_variables	2828	_python_initialize_prefix_variables
2247		2829
2248	local dir iterated_PYTHON_ABIS PYTHON_ABI="${PYTHON_ABI}" root search_paths=() sitedir	2830	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		2831
2253	if _python_package_supporting_installation_for_multiple_python_abis; then	2832	if _python_package_supporting_installation_for_multiple_python_abis; then
2254	if [[ -z "${PYTHON_ABIS}" ]]; then	2833	if has "${EAPI:-0}" 0 1 2 3 && [[ -z "${PYTHON_ABIS}" ]]; then
2255	die "${FUNCNAME}(): Environment not initialized"	2834	die "${FUNCNAME}(): python_pkg_setup() or python_execute_function() not called"
2256	fi	2835	fi
2257	iterated_PYTHON_ABIS="${PYTHON_ABIS}"	2836	iterated_PYTHON_ABIS="${PYTHON_ABIS}"
2258	else	2837	else
		2838	if has "${EAPI:-0}" 0 1 2 3; then
2259	iterated_PYTHON_ABIS="${PYTHON_ABI:-$(PYTHON --ABI)}"	2839	iterated_PYTHON_ABIS="${PYTHON_ABI:-$(PYTHON --ABI)}"
		2840	else
		2841	iterated_PYTHON_ABIS="${PYTHON_ABI}"
		2842	fi
2260	fi	2843	fi
2261		2844
2262	# Strip trailing slash from EROOT.	2845	# Strip trailing slash from EROOT.
2263	root="${EROOT%/}"	2846	root="${EROOT%/}"
2264		2847
		2848	while (($#)); do
		2849	case "$1" in
		2850	--allow-evaluated-non-sitedir-paths)
		2851	allow_evaluated_non_sitedir_paths="1"
		2852	;;
		2853	--)
		2854	shift
		2855	break
		2856	;;
		2857	-*)
		2858	die "${FUNCNAME}(): Unrecognized option '$1'"
		2859	;;
		2860	*)
		2861	break
		2862	;;
		2863	esac
		2864	shift
		2865	done
		2866
		2867	if [[ "${allow_evaluated_non_sitedir_paths}" == "1" ]] && ! _python_package_supporting_installation_for_multiple_python_abis; then
		2868	die "${FUNCNAME}(): '--allow-evaluated-non-sitedir-paths' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		2869	fi
		2870
2265	if [[ "$#" -gt 0 ]]; then	2871	if [[ "$#" -eq 0 ]]; then
2266	if ! has "${EAPI:-0}" 0 1 2 \|\| _python_package_supporting_installation_for_multiple_python_abis; then	2872	die "${FUNCNAME}(): Missing files or directories"
		2873	fi
		2874
		2875	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	2876	while (($#)); do
		2877	if [[ "$1" =~ ^($\|(\.\|\.\.\|/)($\|/)) ]]; then
		2878	die "${FUNCNAME}(): Invalid argument '$1'"
2268	if ! _python_implementation && [[ "$1" =~ ^/usr/lib(32\|64)?/python[[:digit:]]+\.[[:digit:]]+ ]]; then	2879	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"	2880	die "${FUNCNAME}(): Paths of directories / files in site-packages directories must be relative to site-packages directories"
2270	elif [[ "$1" =~ ^/ ]]; then	2881	elif [[ "$1" =~ ^/ ]]; then
2271	if _python_package_supporting_installation_for_multiple_python_abis; then	2882	if _python_package_supporting_installation_for_multiple_python_abis; then
		2883	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"	2884	die "${FUNCNAME}(): Absolute paths cannot be used in ebuilds of packages supporting installation for multiple Python ABIs"
2273	fi	2885	fi
		2886	if [[ "$1" != \$ ]]; then
		2887	die "${FUNCNAME}(): '$1' has invalid syntax"
		2888	fi
		2889	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do
		2890	eval "search_paths+=(\"\${root}$1\")"
		2891	done
		2892	else
2274	search_paths+=("${root}$1")	2893	search_paths+=("${root}$1")
		2894	fi
2275	else	2895	else
2276	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do	2896	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do
2277	search_paths+=("${root}$(python_get_sitedir)/$1")	2897	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	2898	done
2310	fi	2899	fi
		2900	shift
2311	done	2901	done
2312	for sitedir in "${root}"/usr/share/jython-*/Lib/site-packages; do	2902	else
2313	if [[ -d "${sitedir}" ]]; then	2903	# Deprecated part of python_mod_cleanup()
		2904	ewarn
		2905	ewarn "Deprecation Warning: Usage of ${FUNCNAME}() in packages not supporting installation"
		2906	ewarn "for multiple Python ABIs in EAPI <=2 is deprecated and will be disallowed on 2011-08-01."
		2907	ewarn "Use EAPI >=3 and call ${FUNCNAME}() with paths having appropriate syntax."
		2908	ewarn "The ebuild needs to be fixed. Please report a bug, if it has not been already reported."
		2909	ewarn
		2910
2314	search_paths+=("${sitedir}")	2911	search_paths=("${@#/}")
2315	fi	2912	search_paths=("${search_paths[@]/#/${root}/}")
2316	done
2317	fi	2913	fi
2318		2914
2319	_python_clean_compiled_modules "${search_paths[@]}"	2915	_python_clean_compiled_modules "${search_paths[@]}"
2320	}	2916	}
2321		2917
2322	# ================================================================================================	2918	# ================================================================================================
2323	# ===================================== DEPRECATED FUNCTIONS =====================================	2919	# ===================================== DEPRECATED FUNCTIONS =====================================
2324	# ================================================================================================	2920	# ================================================================================================
2325
2326	# @FUNCTION: python_version
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	if [[ "${FUNCNAME[1]}" != "python_mod_optimize" ]]; then
2460	echo
2461	echo " ${_RED}*${_NORMAL} ${_RED}Deprecation Warning: ${FUNCNAME}() is deprecated and will be banned on 2010-09-01.${_NORMAL}"
2462	echo " ${_RED}*${_NORMAL} ${_RED}Use python_mod_optimize() instead of ${FUNCNAME}().${_NORMAL}"
2463	echo " ${_RED}*${_NORMAL} ${_RED}The ebuild needs to be fixed. Please report a bug, if it has not been already reported.${_NORMAL}"
2464	echo
2465
2466	einfo &> /dev/null
2467	einfo "Deprecation Warning: ${FUNCNAME}() is deprecated and will be banned on 2010-09-01." &> /dev/null
2468	einfo "Use python_mod_optimize() instead of ${FUNCNAME}()." &> /dev/null
2469	einfo "The ebuild needs to be fixed. Please report a bug, if it has not been already reported." &> /dev/null
2470	einfo &> /dev/null
2471	fi
2472
2473	local f myroot myfiles=()
2474
2475	# Check if phase is pkg_postinst()
2476	[[ "${EBUILD_PHASE}" != "postinst" ]] && die "${FUNCNAME}() can be used only in pkg_postinst() phase"
2477
2478	# strip trailing slash
2479	myroot="${EROOT%/}"
2480
2481	# respect EROOT
2482	for f in "$@"; do
2483	[[ -f "${myroot}/${f}" ]] && myfiles+=("${myroot}/${f}")
2484	done
2485
2486	PYTHON_ABI="$(PYTHON --ABI)"
2487
2488	if ((${#myfiles[@]})); then
2489	"$(PYTHON ${PYTHON_ABI})" "${myroot}$(python_get_libdir)/py_compile.py" "${myfiles[@]}"
2490	"$(PYTHON ${PYTHON_ABI})" -O "${myroot}$(python_get_libdir)/py_compile.py" "${myfiles[@]}" &> /dev/null
2491	_python_clean_compiled_modules "${myfiles[@]}"
2492	else
2493	ewarn "No files to compile!"
2494	fi
2495	}

 Legend:



Removed from v.1.99
 


changed lines


 
Added in v.1.115
 Legend:



Removed from v.1.99
 


changed lines


 
Added in v.1.115
-Removed from v.1.99
+Added in v.1.115

	ViewVC Help
Powered by ViewVC 1.1.17