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

Diff of /eclass/python.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.54
 


changed lines


 
Added in v.1.106
 Legend:



Removed from v.1.54
 


changed lines


 
Added in v.1.106
-Removed from v.1.54
+Added in v.1.106

	ViewVC Help
Powered by ViewVC 1.1.20