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

Diff of /eclass/python.eclass

Parent Directory | Revision Log | View Patch Patch

Revision 1.72		Revision 1.110
1	# Copyright 1999-2009 Gentoo Foundation	1	# Copyright 1999-2011 Gentoo Foundation
2	# Distributed under the terms of the GNU General Public License v2	2	# Distributed under the terms of the GNU General Public License v2
3	# $Header: /var/cvsroot/gentoo-x86/eclass/python.eclass,v 1.72 2009/09/11 19:55:05 arfrever Exp $	3	# $Header: /var/cvsroot/gentoo-x86/eclass/python.eclass,v 1.110 2011/03/10 17:49:49 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 3.3)
		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.
		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"
13		368
14	inherit multilib	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	PYTHON_ATOM=">=dev-lang/python-${NEED_PYTHON}"	374	addwrite "${EPREFIX}/var/cache/jython"
18	DEPEND="${PYTHON_ATOM}"	375
19	RDEPEND="${DEPEND}"	376	if _python_package_supporting_installation_for_multiple_python_abis; then
		377	_python_calculate_PYTHON_ABIS
		378	export EPYTHON="$(PYTHON -f)"
20	else	379	else
21	PYTHON_ATOM="dev-lang/python"	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
22	fi	429	fi
23		430
24	DEPEND="${DEPEND} >=app-shells/bash-3.2"	431	_PYTHON_SHEBANG_BASE_PART_REGEX='^#![[:space:]]([^[:space:]]/usr/bin/env[[:space:]]+)?([^[:space:]]*/)?(jython\|python)'
25	if ! has "${EAPI:-0}" 0 1 2 \|\| [[ -n "${SUPPORT_PYTHON_ABIS}" ]]; then
26	DEPEND="${DEPEND} >=app-admin/eselect-python-20090804"
27	fi
28		432
29	__python_eclass_test() {
30	__python_version_extract 2.3
31	echo -n "2.3 -> PYVER: $PYVER PYVER_MAJOR: $PYVER_MAJOR"
32	echo " PYVER_MINOR: $PYVER_MINOR PYVER_MICRO: $PYVER_MICRO"
33	__python_version_extract 2.3.4
34	echo -n "2.3.4 -> PYVER: $PYVER PYVER_MAJOR: $PYVER_MAJOR"
35	echo " PYVER_MINOR: $PYVER_MINOR PYVER_MICRO: $PYVER_MICRO"
36	__python_version_extract 2.3.5
37	echo -n "2.3.5 -> PYVER: $PYVER PYVER_MAJOR: $PYVER_MAJOR"
38	echo " PYVER_MINOR: $PYVER_MINOR PYVER_MICRO: $PYVER_MICRO"
39	__python_version_extract 2.4
40	echo -n "2.4 -> PYVER: $PYVER PYVER_MAJOR: $PYVER_MAJOR"
41	echo " PYVER_MINOR: $PYVER_MINOR PYVER_MICRO: $PYVER_MICRO"
42	__python_version_extract 2.5b3
43	echo -n "2.5b3 -> PYVER: $PYVER PYVER_MAJOR: $PYVER_MAJOR"
44	echo " PYVER_MINOR: $PYVER_MINOR PYVER_MICRO: $PYVER_MICRO"
45	}
46
47	# @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]
48	# @DESCRIPTION:	435	# @DESCRIPTION:
49	# 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.
50	# currently in use as $PYVER; sets PYVER/PYVER_MAJOR/PYVER_MINOR	437	python_convert_shebangs() {
51	__python_version_extract() {	438	_python_check_python_pkg_setup_execution
52	local verstr=$1
53	export PYVER_MAJOR=${verstr:0:1}
54	export PYVER_MINOR=${verstr:2:1}
55	if [[ ${verstr:3:1} == . ]]; then
56	export PYVER_MICRO=${verstr:4}
57	fi
58	export PYVER="${PYVER_MAJOR}.${PYVER_MINOR}"
59	}
60		439
61	python_version() {	440	local argument file files=() only_executables="0" python_interpreter quiet="0" recursive="0"
62	[[ -n "${PYVER}" ]] && return 0
63	local tmpstr
64	python=${python:-/usr/bin/python}
65	tmpstr="$(${python} -V 2>&1 )"
66	export PYVER_ALL="${tmpstr#Python }"
67	__python_version_extract $PYVER_ALL
68	}
69
70	# @FUNCTION: PYTHON
71	# @USAGE: [-a\|--absolute-path] [--] <Python_ABI="${PYTHON_ABI}">
72	# @DESCRIPTION:
73	# Get Python interpreter filename for specified Python ABI. If Python_ABI argument
74	# is ommitted, then PYTHON_ABI environment variable must be set and is used.
75	PYTHON() {
76	local absolute_path="0" slot=
77		441
78	while (($#)); do	442	while (($#)); do
79	case "$1" in	443	case "$1" in
80	-a\|--absolute-path)	444	-r\|--recursive)
81	absolute_path="1"	445	recursive="1"
		446	;;
		447	-q\|--quiet)
		448	quiet="1"
		449	;;
		450	-x\|--only-executables)
		451	only_executables="1"
82	;;	452	;;
83	--)	453	--)
		454	shift
84	break	455	break
85	;;	456	;;
86	-*)	457	-*)
87	die "${FUNCNAME}(): Unrecognized option $1"	458	die "${FUNCNAME}(): Unrecognized option '$1'"
88	;;	459	;;
89	*)	460	*)
90	break	461	break
91	;;	462	;;
92	esac	463	esac
93	shift	464	shift
94	done	465	done
95		466
96	if [[ "$#" -eq "0" ]]; then	467	if [[ "$#" -eq 0 ]]; then
97	if [[ -n "${PYTHON_ABI}" ]]; then	468	die "${FUNCNAME}(): Missing Python version and files or directories"
98	slot="${PYTHON_ABI}"	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
99	else	493	else
		494	die "${FUNCNAME}(): '${argument}' is not a regular file or a directory"
		495	fi
		496	done
		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	*)
100	die "${FUNCNAME}(): Invalid usage"	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}"
101	fi	553	fi
102	elif [[ "$#" -eq "1" ]]; then	554	rm -f "${file}"
103	slot="$1"	555
104	else	556	# Delete empty __pycache__ directories.
105	die "${FUNCNAME}(): Invalid usage"	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
106	fi	566	fi
107		567	}
108	if [[ "${absolute_path}" == "1" ]]; then	568	if _python_package_supporting_installation_for_multiple_python_abis; then
109	echo -n "/usr/bin/python${slot}"	569	python_execute_function -q python_clean_sitedirs
110	else	570	else
111	echo -n "python${slot}"	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"
112	fi	596	fi
113	}
114		597
115	# @FUNCTION: validate_PYTHON_ABIS	598	if [[ "$#" -ne 0 ]]; then
116	# @DESCRIPTION:	599	die "${FUNCNAME}() does not accept arguments"
117	# Make sure PYTHON_ABIS variable has valid value.
118	validate_PYTHON_ABIS() {
119	# Ensure that some functions cannot be accidentally successfully used in EAPI <= 2 without setting SUPPORT_PYTHON_ABIS variable.
120	if has "${EAPI:-0}" 0 1 2 && [[ -z "${SUPPORT_PYTHON_ABIS}" ]]; then
121	die "${FUNCNAME}() cannot be used in this EAPI without setting SUPPORT_PYTHON_ABIS variable"
122	fi	600	fi
123		601
124	# Ensure that /usr/bin/python and /usr/bin/python-config are valid.	602	python_copy_sources
125	if [[ "$(readlink /usr/bin/python)" != "python-wrapper" ]]; then	603	}
126	die "'/usr/bin/python' isn't valid symlink"	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
127	fi	621	fi
128	if [[ "$(</usr/bin/python-config)" != "Gentoo python-config wrapper script" ]]; then	622
129	die "'/usr/bin/python-config' isn't valid script"	623	if has "${EAPI:-0}" 0 1 2 3 4; then
		624	unset PYTHON_ABIS
130	fi	625	fi
131		626
132	# USE_${ABI_TYPE^^} and RESTRICT_${ABI_TYPE^^}_ABIS variables hopefully will be included in EAPI >= 4.	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
133	if [[ "$(declare -p PYTHON_ABIS 2> /dev/null)" != "declare -x PYTHON_ABIS="* ]] && has "${EAPI:-0}" 0 1 2 3; then	634	if [[ "$(declare -p PYTHON_ABIS 2> /dev/null)" != "declare -x PYTHON_ABIS="* ]] && has "${EAPI:-0}" 0 1 2 3 4; then
134	local ABI support_ABI supported_PYTHON_ABIS= restricted_ABI	635	local PYTHON_ABI restricted_ABI restricted_ABIs support_ABI supported_PYTHON_ABIS
135	PYTHON_ABI_SUPPORTED_VALUES="2.4 2.5 2.6 2.7 3.0 3.1 3.2"	636
		637	restricted_ABIs="${RESTRICT_PYTHON_ABIS// /$'\n'}"
136		638
137	if [[ "$(declare -p USE_PYTHON 2> /dev/null)" == "declare -x USE_PYTHON="* ]]; then	639	if [[ "$(declare -p USE_PYTHON 2> /dev/null)" == "declare -x USE_PYTHON="* ]]; then
		640	local cpython_enabled="0"
		641
138	if [[ -z "${USE_PYTHON}" ]]; then	642	if [[ -z "${USE_PYTHON}" ]]; then
139	die "USE_PYTHON variable is empty"	643	die "USE_PYTHON variable is empty"
140	fi	644	fi
141		645
142	for ABI in ${USE_PYTHON}; do	646	for PYTHON_ABI in ${USE_PYTHON}; do
143	if ! has "${ABI}" ${PYTHON_ABI_SUPPORTED_VALUES}; then	647	if ! has "${PYTHON_ABI}" "${_PYTHON_GLOBALLY_SUPPORTED_ABIS[@]}"; then
144	die "USE_PYTHON variable contains invalid value '${ABI}'"	648	die "USE_PYTHON variable contains invalid value '${PYTHON_ABI}'"
145	fi	649	fi
		650
		651	if has "${PYTHON_ABI}" "${_CPYTHON2_GLOBALLY_SUPPORTED_ABIS[@]}" "${_CPYTHON3_GLOBALLY_SUPPORTED_ABIS[@]}"; then
		652	cpython_enabled="1"
		653	fi
		654
146	support_ABI="1"	655	support_ABI="1"
147	for restricted_ABI in ${RESTRICT_PYTHON_ABIS}; do	656	while read restricted_ABI; do
148	if python -c "from fnmatch import fnmatch; exit(not fnmatch('${ABI}', '${restricted_ABI}'))"; then	657	if _python_check_python_abi_matching "${PYTHON_ABI}" "${restricted_ABI}"; then
149	support_ABI="0"	658	support_ABI="0"
150	break	659	break
151	fi	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
152	done	696	done
153	[[ "${support_ABI}" == "1" ]] && supported_PYTHON_ABIS+=" ${ABI}"	697	if [[ "${support_python_major_version}" == "1" ]]; then
154	done	698	while read restricted_ABI; do
155	export PYTHON_ABIS="${supported_PYTHON_ABIS# }"	699	if _python_check_python_abi_matching "${python2_version}" "${restricted_ABI}"; then
156
157	if [[ -z "${PYTHON_ABIS//[${IFS}]/}" ]]; then
158	die "USE_PYTHON variable doesn't enable any Python version supported by ${CATEGORY}/${PF}"
159	fi
160	else
161	local restricted_ABI
162	python_version
163
164	for restricted_ABI in ${RESTRICT_PYTHON_ABIS}; do
165	if python -c "from fnmatch import fnmatch; exit(not fnmatch('${PYVER}', '${restricted_ABI}'))"; then
166	die "Active Python version isn't supported by ${CATEGORY}/${PF}"	700	die "Active version of CPython 2 is not supported by ${CATEGORY}/${PF}"
167	fi	701	fi
168	done	702	done <<< "${restricted_ABIs}"
169	export PYTHON_ABIS="${PYVER}"
170	fi
171	fi
172
173	local PYTHON_ABI
174	for PYTHON_ABI in ${PYTHON_ABIS}; do
175	# Ensure that appropriate Python version is installed.
176	if ! has_version "dev-lang/python:${PYTHON_ABI}"; then
177	die "dev-lang/python:${PYTHON_ABI} isn't installed"
178	fi
179
180	# Ensure that EPYTHON variable is respected.
181	if [[ "$(EPYTHON="$(PYTHON)" python -c 'from sys import version_info; print(".".join([str(x) for x in version_info[:2]]))')" != "${PYTHON_ABI}" ]]; then
182	die "'python' doesn't respect EPYTHON variable"
183	fi
184	done
185	}
186
187	# @FUNCTION: python_copy_sources
188	# @USAGE: [--no-link] [--] [directory]
189	# @DESCRIPTION:
190	# Copy unpacked sources of given package for each Python ABI.
191	python_copy_sources() {
192	local dir dirs=() no_link="0" PYTHON_ABI
193
194	while (($#)); do
195	case "$1" in
196	--no-link)
197	no_link="1"
198	;;
199	--)
200	break
201	;;
202	-*)
203	die "${FUNCNAME}(): Unrecognized option '$1'"
204	;;
205	*)
206	break
207	;;
208	esac
209	shift
210	done
211
212	if [[ "$#" -eq "0" ]]; then
213	if [[ "${WORKDIR}" == "${S}" ]]; then
214	die "${FUNCNAME}() cannot be used"
215	fi
216	dirs="${S}"
217	else
218	dirs="$@"
219	fi
220
221	validate_PYTHON_ABIS
222	for PYTHON_ABI in ${PYTHON_ABIS}; do
223	for dir in "${dirs[@]}"; do
224	if [[ "${no_link}" == "1" ]]; then
225	cp -pr "${dir}" "${dir}-${PYTHON_ABI}" > /dev/null \|\| die "Copying of sources failed"
226	else	703	else
227	cp -lpr "${dir}" "${dir}-${PYTHON_ABI}" > /dev/null \|\| die "Copying of sources failed"	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"
228	fi	793	fi
229	done	794	done
230	done	795	done
231	}	796	}
232		797
233	# @FUNCTION: python_set_build_dir_symlink	798	_python_restore_flags() {
234	# @USAGE: [directory="build"]	799	local variable
235	# @DESCRIPTION:
236	# Create build directory symlink.
237	python_set_build_dir_symlink() {
238	local dir="$1"
239		800
240	[[ -z "${PYTHON_ABI}" ]] && die "PYTHON_ABI variable not set"	801	for variable in CPPFLAGS CFLAGS CXXFLAGS LDFLAGS; do
241	[[ -z "${dir}" ]] && dir="build"	802	eval "${variable}=\"\${_PYTHON_SAVED_${variable}}\""
242		803	unset _PYTHON_SAVED_${variable}
243	# Don't delete preexistent directories.	804	done
244	rm -f "${dir}" \|\| die "Deletion of '${dir}' failed"
245	ln -s "${dir}-${PYTHON_ABI}" "${dir}" \|\| die "Creation of '${dir}' directory symlink failed"
246	}	805	}
247		806
248	# @FUNCTION: python_execute_function	807	# @FUNCTION: python_execute_function
249	# @USAGE: [--action-message message] [-d\|--default-function] [--failure-message message] [--nonfatal] [-q\|--quiet] [-s\|--separate-build-dirs] [--] <function> [arguments]	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]
250	# @DESCRIPTION:	809	# @DESCRIPTION:
251	# Execute specified function for each value of PYTHON_ABIS, optionally passing additional	810	# Execute specified function for each value of PYTHON_ABIS, optionally passing additional
252	# arguments. The specified function can use PYTHON_ABI and BUILDDIR variables.	811	# arguments. The specified function can use PYTHON_ABI and BUILDDIR variables.
253	python_execute_function() {	812	python_execute_function() {
254	local action action_message action_message_template= default_function="0" failure_message failure_message_template= function nonfatal="0" previous_directory_stack_length PYTHON_ABI quiet="0" separate_build_dirs="0"	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=
255		822
256	while (($#)); do	823	while (($#)); do
257	case "$1" in	824	case "$1" in
258	--action-message)	825	--action-message)
259	action_message_template="$2"	826	action_message_template="$2"
…		…
264	;;	831	;;
265	--failure-message)	832	--failure-message)
266	failure_message_template="$2"	833	failure_message_template="$2"
267	shift	834	shift
268	;;	835	;;
		836	-f\|--final-ABI)
		837	final_ABI="1"
		838	;;
269	--nonfatal)	839	--nonfatal)
270	nonfatal="1"	840	nonfatal="1"
271	;;	841	;;
272	-q\|--quiet)	842	-q\|--quiet)
273	quiet="1"	843	quiet="1"
274	;;	844	;;
275	-s\|--separate-build-dirs)	845	-s\|--separate-build-dirs)
276	separate_build_dirs="1"	846	separate_build_dirs="1"
277	;;	847	;;
		848	--source-dir)
		849	source_dir="$2"
		850	shift
		851	;;
278	--)	852	--)
		853	shift
279	break	854	break
280	;;	855	;;
281	-*)	856	-*)
282	die "${FUNCNAME}(): Unrecognized option '$1'"	857	die "${FUNCNAME}(): Unrecognized option '$1'"
283	;;	858	;;
…		…
286	;;	861	;;
287	esac	862	esac
288	shift	863	shift
289	done	864	done
290		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
291	if [[ "${default_function}" == "0" ]]; then	870	if [[ "${default_function}" == "0" ]]; then
292	if [[ "$#" -eq "0" ]]; then	871	if [[ "$#" -eq 0 ]]; then
293	die "${FUNCNAME}(): Missing function name"	872	die "${FUNCNAME}(): Missing function name"
294	fi	873	fi
295	function="$1"	874	function="$1"
296	shift	875	shift
297		876
298	if [[ -z "$(type -t "${function}")" ]]; then	877	if [[ -z "$(type -t "${function}")" ]]; then
299	die "${FUNCNAME}(): '${function}' function isn't defined"	878	die "${FUNCNAME}(): '${function}' function is not defined"
300	fi	879	fi
301	else	880	else
302	if [[ "$#" -ne "0" ]]; then
303	die "${FUNCNAME}(): '--default-function' option and function name cannot be specified simultaneously"
304	fi
305	if has "${EAPI:-0}" 0 1; then	881	if has "${EAPI:-0}" 0 1; then
306	die "${FUNCNAME}(): '--default-function' option cannot be used in this EAPI"	882	die "${FUNCNAME}(): '--default-function' option cannot be used in this EAPI"
307	fi	883	fi
308		884
309	if [[ "${EBUILD_PHASE}" == "configure" ]]; then	885	if [[ "${EBUILD_PHASE}" == "configure" ]]; then
310	if has "${EAPI}" 2; then	886	if has "${EAPI}" 2 3; then
311	python_default_function() {	887	python_default_function() {
312	econf	888	econf "$@"
313	}	889	}
314	else	890	else
315	python_default_function() {	891	python_default_function() {
316	nonfatal econf	892	nonfatal econf "$@"
317	}	893	}
318	fi	894	fi
319	elif [[ "${EBUILD_PHASE}" == "compile" ]]; then	895	elif [[ "${EBUILD_PHASE}" == "compile" ]]; then
320	python_default_function() {	896	python_default_function() {
321	emake	897	emake "$@"
322	}	898	}
323	elif [[ "${EBUILD_PHASE}" == "test" ]]; then	899	elif [[ "${EBUILD_PHASE}" == "test" ]]; then
324	python_default_function() {	900	python_default_function() {
325	if emake -j1 -n check &> /dev/null; then	901	if emake -j1 -n check &> /dev/null; then
326	emake -j1 check	902	emake -j1 check "$@"
327	elif emake -j1 -n test &> /dev/null; then	903	elif emake -j1 -n test &> /dev/null; then
328	emake -j1 test	904	emake -j1 test "$@"
329	fi	905	fi
330	}	906	}
331	elif [[ "${EBUILD_PHASE}" == "install" ]]; then	907	elif [[ "${EBUILD_PHASE}" == "install" ]]; then
332	python_default_function() {	908	python_default_function() {
333	emake DESTDIR="${D}" install	909	emake DESTDIR="${D}" install "$@"
334	}	910	}
335	else	911	else
336	die "${FUNCNAME}(): --default-function option cannot be used in this ebuild phase"	912	die "${FUNCNAME}(): '--default-function' option cannot be used in this ebuild phase"
337	fi	913	fi
338	function="python_default_function"	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"
339	fi	920	fi
340		921
341	if [[ "${quiet}" == "0" ]]; then	922	if [[ "${quiet}" == "0" ]]; then
342	[[ "${EBUILD_PHASE}" == "setup" ]] && action="Setting up"	923	[[ "${EBUILD_PHASE}" == "setup" ]] && action="Setting up"
343	[[ "${EBUILD_PHASE}" == "unpack" ]] && action="Unpacking"	924	[[ "${EBUILD_PHASE}" == "unpack" ]] && action="Unpacking"
…		…
350	[[ "${EBUILD_PHASE}" == "postinst" ]] && action="Postinstallation"	931	[[ "${EBUILD_PHASE}" == "postinst" ]] && action="Postinstallation"
351	[[ "${EBUILD_PHASE}" == "prerm" ]] && action="Preuninstallation"	932	[[ "${EBUILD_PHASE}" == "prerm" ]] && action="Preuninstallation"
352	[[ "${EBUILD_PHASE}" == "postrm" ]] && action="Postuninstallation"	933	[[ "${EBUILD_PHASE}" == "postrm" ]] && action="Postuninstallation"
353	fi	934	fi
354		935
355	local RED GREEN BLUE NORMAL	936	_python_calculate_PYTHON_ABIS
356	if [[ "${NOCOLOR:-false}" =~ ^(false\|no)$ ]]; then	937	if [[ "${final_ABI}" == "1" ]]; then
357	RED=$'\e[1;31m'	938	iterated_PYTHON_ABIS="$(PYTHON -f --ABI)"
358	GREEN=$'\e[1;32m'
359	BLUE=$'\e[1;34m'
360	NORMAL=$'\e[0m'
361	else	939	else
362	RED=	940	iterated_PYTHON_ABIS="${PYTHON_ABIS}"
363	GREEN=
364	BLUE=
365	NORMAL=
366	fi	941	fi
367
368	validate_PYTHON_ABIS
369	for PYTHON_ABI in ${PYTHON_ABIS}; do	942	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do
		943	_python_prepare_flags
		944
370	if [[ "${quiet}" == "0" ]]; then	945	if [[ "${quiet}" == "0" ]]; then
371	if [[ -n "${action_message_template}" ]]; then	946	if [[ -n "${action_message_template}" ]]; then
372	action_message="$(eval echo -n "${action_message_template}")"	947	eval "action_message=\"${action_message_template}\""
373	else	948	else
374	action_message="${action} of ${CATEGORY}/${PF} with Python ${PYTHON_ABI}..."	949	action_message="${action} of ${CATEGORY}/${PF} with $(python_get_implementation) $(python_get_version)..."
375	fi	950	fi
376	echo " ${GREEN}*${NORMAL} ${BLUE}${action_message}${NORMAL}"	951	echo " ${_GREEN}*${_NORMAL} ${_BLUE}${action_message}${_NORMAL}"
377	fi	952	fi
378		953
379	if [[ "${separate_build_dirs}" == "1" ]]; then	954	if [[ "${separate_build_dirs}" == "1" ]]; then
		955	if [[ -n "${source_dir}" ]]; then
		956	export BUILDDIR="${S}/${source_dir}-${PYTHON_ABI}"
		957	else
380	export BUILDDIR="${S}-${PYTHON_ABI}"	958	export BUILDDIR="${S}-${PYTHON_ABI}"
		959	fi
381	pushd "${BUILDDIR}" > /dev/null \|\| die "pushd failed"	960	pushd "${BUILDDIR}" > /dev/null \|\| die "pushd failed"
382	else	961	else
383	export BUILDDIR="${S}"	962	export BUILDDIR="${S}"
384	fi	963	fi
385		964
386	previous_directory_stack_length="${#DIRSTACK[@]}"	965	previous_directory="$(pwd)"
		966	previous_directory_stack="$(dirs -p)"
		967	previous_directory_stack_length="$(dirs -p \| wc -l)"
387		968
388	if ! has "${EAPI}" 0 1 2 && has "${PYTHON_ABI}" ${FAILURE_TOLERANT_PYTHON_ABIS}; then	969	if ! has "${EAPI}" 0 1 2 3 && has "${PYTHON_ABI}" ${FAILURE_TOLERANT_PYTHON_ABIS}; then
389	EPYTHON="$(PYTHON)" nonfatal "${function}" "$@"	970	EPYTHON="$(PYTHON)" nonfatal "${function}" "$@"
390	else	971	else
391	EPYTHON="$(PYTHON)" "${function}" "$@"	972	EPYTHON="$(PYTHON)" "${function}" "$@"
392	fi	973	fi
393		974
394	if [[ "$?" != "0" ]]; then	975	return_code="$?"
		976
		977	_python_restore_flags
		978
		979	if [[ "${return_code}" -ne 0 ]]; then
395	if [[ -n "${failure_message_template}" ]]; then	980	if [[ -n "${failure_message_template}" ]]; then
396	failure_message="$(eval echo -n "${failure_message_template}")"	981	eval "failure_message=\"${failure_message_template}\""
397	else	982	else
398	failure_message="${action} failed with Python ${PYTHON_ABI} in ${function}() function"	983	failure_message="${action} failed with $(python_get_implementation) $(python_get_version) in ${function}() function"
399	fi	984	fi
400		985
401	if [[ "${nonfatal}" == "1" ]]; then	986	if [[ "${nonfatal}" == "1" ]]; then
402	if [[ "${quiet}" == "0" ]]; then	987	if [[ "${quiet}" == "0" ]]; then
403	ewarn "${RED}${failure_message}${NORMAL}"	988	ewarn "${failure_message}"
404	fi	989	fi
405	elif has "${PYTHON_ABI}" ${FAILURE_TOLERANT_PYTHON_ABIS}; then	990	elif [[ "${final_ABI}" == "0" ]] && has "${PYTHON_ABI}" ${FAILURE_TOLERANT_PYTHON_ABIS}; then
406	if [[ "${EBUILD_PHASE}" != "test" ]] \|\| ! has test-fail-continue ${FEATURES}; then	991	if [[ "${EBUILD_PHASE}" != "test" ]] \|\| ! has test-fail-continue ${FEATURES}; then
407	local ABI enabled_PYTHON_ABIS=	992	local enabled_PYTHON_ABIS= other_PYTHON_ABI
408	for ABI in ${PYTHON_ABIS}; do	993	for other_PYTHON_ABI in ${PYTHON_ABIS}; do
409	[[ "${ABI}" != "${PYTHON_ABI}" ]] && enabled_PYTHON_ABIS+=" ${ABI}"	994	[[ "${other_PYTHON_ABI}" != "${PYTHON_ABI}" ]] && enabled_PYTHON_ABIS+="${enabled_PYTHON_ABIS:+ }${other_PYTHON_ABI}"
410	done	995	done
411	export PYTHON_ABIS="${enabled_PYTHON_ABIS# }"	996	export PYTHON_ABIS="${enabled_PYTHON_ABIS}"
412	fi	997	fi
413	if [[ "${quiet}" == "0" ]]; then	998	if [[ "${quiet}" == "0" ]]; then
414	ewarn "${RED}${failure_message}${NORMAL}"	999	ewarn "${failure_message}"
415	fi	1000	fi
416	if [[ -z "${PYTHON_ABIS}" ]]; then	1001	if [[ -z "${PYTHON_ABIS}" ]]; then
417	die "${function}() function failed with all enabled versions of Python"	1002	die "${function}() function failed with all enabled Python ABIs"
418	fi	1003	fi
419	else	1004	else
420	die "${failure_message}"	1005	die "${failure_message}"
421	fi	1006	fi
422	fi	1007	fi
423		1008
		1009	# Ensure that directory stack has not been decreased.
424	if [[ "${#DIRSTACK[@]}" -lt "${previous_directory_stack_length}" ]]; then	1010	if [[ "$(dirs -p \| wc -l)" -lt "${previous_directory_stack_length}" ]]; then
425	die "Directory stack decreased illegally"	1011	die "Directory stack decreased illegally"
426	fi	1012	fi
427		1013
		1014	# Avoid side effects of earlier returning from the specified function.
428	while [[ "${#DIRSTACK[@]}" -gt "${previous_directory_stack_length}" ]]; do	1015	while [[ "$(dirs -p \| wc -l)" -gt "${previous_directory_stack_length}" ]]; do
429	popd > /dev/null \|\| die "popd failed"	1016	popd > /dev/null \|\| die "popd failed"
430	done	1017	done
431		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
432	if [[ "${separate_build_dirs}" == "1" ]]; then	1030	if [[ "${separate_build_dirs}" == "1" ]]; then
433	popd > /dev/null \|\| die "popd failed"	1031	popd > /dev/null \|\| die "popd failed"
434	fi	1032	fi
435	unset BUILDDIR	1033	unset BUILDDIR
436	done	1034	done
…		…
438	if [[ "${default_function}" == "1" ]]; then	1036	if [[ "${default_function}" == "1" ]]; then
439	unset -f python_default_function	1037	unset -f python_default_function
440	fi	1038	fi
441	}	1039	}
442		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
443		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	if ROOT="/" has_version sys-apps/coreutils; then
		1453	cp -fr --preserve=all "${intermediate_installation_images_directory}/${PYTHON_ABI}/"* "${D}" \|\| die "Merging of intermediate installation image for Python ABI '${PYTHON_ABI} into installation image failed"
		1454	else
		1455	cp -fpr "${intermediate_installation_images_directory}/${PYTHON_ABI}/"* "${D}" \|\| die "Merging of intermediate installation image for Python ABI '${PYTHON_ABI} into installation image failed"
		1456	fi
		1457	done
		1458
		1459	rm -fr "${intermediate_installation_images_directory}"
		1460
		1461	if [[ "${#wrapper_scripts[@]}" -ge 1 ]]; then
		1462	rm -f "${T}/python_wrapper_scripts"
		1463
		1464	for file in "${wrapper_scripts[@]}"; do
		1465	echo -n "${file}" >> "${T}/python_wrapper_scripts"
		1466	echo -en "\x00" >> "${T}/python_wrapper_scripts"
		1467	done
		1468
		1469	while read -d $'\0' -r file; do
		1470	wrapper_scripts_set+=("${file}")
		1471	done < <("$(PYTHON -f)" -c \
		1472	"import sys
		1473
		1474	if hasattr(sys.stdout, 'buffer'):
		1475	# Python 3
		1476	stdout = sys.stdout.buffer
		1477	else:
		1478	# Python 2
		1479	stdout = sys.stdout
		1480
		1481	files = set(open('${T}/python_wrapper_scripts', 'rb').read().rstrip(${b}'\x00').split(${b}'\x00'))
		1482
		1483	for file in sorted(files):
		1484	stdout.write(file)
		1485	stdout.write(${b}'\x00')" \|\| die "${FUNCNAME}(): Failure of extraction of set of wrapper scripts")
		1486
		1487	python_generate_wrapper_scripts $([[ "${quiet}" == "1" ]] && echo --quiet) "${wrapper_scripts_set[@]}"
		1488	fi
		1489	}
		1490
		1491	# ================================================================================================
		1492	# ========= FUNCTIONS FOR PACKAGES NOT SUPPORTING INSTALLATION FOR MULTIPLE PYTHON ABIS ==========
		1493	# ================================================================================================
		1494
		1495	unset EPYTHON PYTHON_ABI
		1496
		1497	# @FUNCTION: python_set_active_version
		1498	# @USAGE: <Python_ABI\|2\|3>
		1499	# @DESCRIPTION:
		1500	# Set locally active version of Python.
		1501	# If Python_ABI argument is specified, then version of Python corresponding to Python_ABI is used.
		1502	# If 2 argument is specified, then active version of CPython 2 is used.
		1503	# If 3 argument is specified, then active version of CPython 3 is used.
		1504	#
		1505	# This function can be used only in pkg_setup() phase.
		1506	python_set_active_version() {
		1507	# Check if phase is pkg_setup().
		1508	[[ "${EBUILD_PHASE}" != "setup" ]] && die "${FUNCNAME}() can be used only in pkg_setup() phase"
		1509
		1510	if _python_package_supporting_installation_for_multiple_python_abis; then
		1511	die "${FUNCNAME}() cannot be used in ebuilds of packages supporting installation for multiple Python ABIs"
		1512	fi
		1513
		1514	if [[ "$#" -ne 1 ]]; then
		1515	die "${FUNCNAME}() requires 1 argument"
		1516	fi
		1517
		1518	_python_initial_sanity_checks
		1519
		1520	if [[ -z "${PYTHON_ABI}" ]]; then
		1521	if [[ -n "$(_python_get_implementation --ignore-invalid "$1")" ]]; then
		1522	# PYTHON_ABI variable is intended to be used only in ebuilds/eclasses,
		1523	# so it does not need to be exported to subprocesses.
		1524	PYTHON_ABI="$1"
		1525	if ! _python_implementation && ! has_version "$(python_get_implementational_package)"; then
		1526	die "${FUNCNAME}(): '$(python_get_implementational_package)' is not installed"
		1527	fi
		1528	export EPYTHON="$(PYTHON "$1")"
		1529	elif [[ "$1" == "2" ]]; then
		1530	if ! _python_implementation && ! has_version "=dev-lang/python-2*"; then
		1531	die "${FUNCNAME}(): '=dev-lang/python-2*' is not installed"
		1532	fi
		1533	export EPYTHON="$(PYTHON -2)"
		1534	PYTHON_ABI="${EPYTHON#python}"
		1535	PYTHON_ABI="${PYTHON_ABI%%-*}"
		1536	elif [[ "$1" == "3" ]]; then
		1537	if ! _python_implementation && ! has_version "=dev-lang/python-3*"; then
		1538	die "${FUNCNAME}(): '=dev-lang/python-3*' is not installed"
		1539	fi
		1540	export EPYTHON="$(PYTHON -3)"
		1541	PYTHON_ABI="${EPYTHON#python}"
		1542	PYTHON_ABI="${PYTHON_ABI%%-*}"
		1543	else
		1544	die "${FUNCNAME}(): Unrecognized argument '$1'"
		1545	fi
		1546	fi
		1547
		1548	_python_final_sanity_checks
		1549
		1550	# python-updater checks PYTHON_REQUESTED_ACTIVE_VERSION variable.
		1551	PYTHON_REQUESTED_ACTIVE_VERSION="$1"
		1552	}
		1553
		1554	# @FUNCTION: python_need_rebuild
		1555	# @DESCRIPTION: Mark current package for rebuilding by python-updater after
		1556	# switching of active version of Python.
		1557	python_need_rebuild() {
		1558	_python_check_python_pkg_setup_execution
		1559
		1560	if _python_package_supporting_installation_for_multiple_python_abis; then
		1561	die "${FUNCNAME}() cannot be used in ebuilds of packages supporting installation for multiple Python ABIs"
		1562	fi
		1563
		1564	if [[ "$#" -ne 0 ]]; then
		1565	die "${FUNCNAME}() does not accept arguments"
		1566	fi
		1567
		1568	export PYTHON_NEED_REBUILD="$(PYTHON --ABI)"
		1569	}
		1570
		1571	# ================================================================================================
		1572	# ======================================= GETTER FUNCTIONS =======================================
		1573	# ================================================================================================
		1574
		1575	_PYTHON_ABI_EXTRACTION_COMMAND='import platform
		1576	import sys
		1577	sys.stdout.write(".".join(str(x) for x in sys.version_info[:2]))
		1578	if platform.system()[:4] == "Java":
		1579	sys.stdout.write("-jython")'
		1580
		1581	_python_get_implementation() {
		1582	local ignore_invalid="0"
		1583
		1584	while (($#)); do
		1585	case "$1" in
		1586	--ignore-invalid)
		1587	ignore_invalid="1"
		1588	;;
		1589	--)
		1590	shift
		1591	break
		1592	;;
		1593	-*)
		1594	die "${FUNCNAME}(): Unrecognized option '$1'"
		1595	;;
		1596	*)
		1597	break
		1598	;;
		1599	esac
		1600	shift
		1601	done
		1602
		1603	if [[ "$#" -ne 1 ]]; then
		1604	die "${FUNCNAME}() requires 1 argument"
		1605	fi
		1606
		1607	if [[ "$1" =~ ^[[:digit:]]+\.[[:digit:]]+$ ]]; then
		1608	echo "CPython"
		1609	elif [[ "$1" =~ ^[[:digit:]]+\.[[:digit:]]+-jython$ ]]; then
		1610	echo "Jython"
		1611	else
		1612	if [[ "${ignore_invalid}" == "0" ]]; then
		1613	die "${FUNCNAME}(): Unrecognized Python ABI '$1'"
		1614	fi
		1615	fi
		1616	}
		1617
		1618	# @FUNCTION: PYTHON
		1619	# @USAGE: [-2] [-3] [--ABI] [-a\|--absolute-path] [-f\|--final-ABI] [--] <Python_ABI="${PYTHON_ABI}">
		1620	# @DESCRIPTION:
		1621	# Print filename of Python interpreter for specified Python ABI. If Python_ABI argument
		1622	# is ommitted, then PYTHON_ABI environment variable must be set and is used.
		1623	# If -2 option is specified, then active version of CPython 2 is used.
		1624	# If -3 option is specified, then active version of CPython 3 is used.
		1625	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		1626	# -2, -3 and --final-ABI options and Python_ABI argument cannot be specified simultaneously.
		1627	# If --ABI option is specified, then only specified Python ABI is printed instead of
		1628	# filename of Python interpreter.
		1629	# If --absolute-path option is specified, then absolute path to Python interpreter is printed.
		1630	# --ABI and --absolute-path options cannot be specified simultaneously.
		1631	PYTHON() {
		1632	_python_check_python_pkg_setup_execution
		1633
		1634	local ABI_output="0" absolute_path_output="0" final_ABI="0" PYTHON_ABI="${PYTHON_ABI}" python_interpreter python2="0" python3="0"
		1635
		1636	while (($#)); do
		1637	case "$1" in
		1638	-2)
		1639	python2="1"
		1640	;;
		1641	-3)
		1642	python3="1"
		1643	;;
		1644	--ABI)
		1645	ABI_output="1"
		1646	;;
		1647	-a\|--absolute-path)
		1648	absolute_path_output="1"
		1649	;;
		1650	-f\|--final-ABI)
		1651	final_ABI="1"
		1652	;;
		1653	--)
		1654	shift
		1655	break
		1656	;;
		1657	-*)
		1658	die "${FUNCNAME}(): Unrecognized option '$1'"
		1659	;;
		1660	*)
		1661	break
		1662	;;
		1663	esac
		1664	shift
		1665	done
		1666
		1667	if [[ "${ABI_output}" == "1" && "${absolute_path_output}" == "1" ]]; then
		1668	die "${FUNCNAME}(): '--ABI' and '--absolute-path' options cannot be specified simultaneously"
		1669	fi
		1670
		1671	if [[ "$((${python2} + ${python3} + ${final_ABI}))" -gt 1 ]]; then
		1672	die "${FUNCNAME}(): '-2', '-3' or '--final-ABI' options cannot be specified simultaneously"
		1673	fi
		1674
		1675	if [[ "$#" -eq 0 ]]; then
		1676	if [[ "${final_ABI}" == "1" ]]; then
		1677	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		1678	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		1679	fi
		1680	_python_calculate_PYTHON_ABIS
		1681	PYTHON_ABI="${PYTHON_ABIS##* }"
		1682	elif [[ "${python2}" == "1" ]]; then
		1683	PYTHON_ABI="$(eselect python show --python2 --ABI)"
		1684	if [[ -z "${PYTHON_ABI}" ]]; then
		1685	die "${FUNCNAME}(): Active version of CPython 2 not set"
		1686	elif [[ "${PYTHON_ABI}" != "2."* ]]; then
		1687	die "${FUNCNAME}(): Internal error in \`eselect python show --python2\`"
		1688	fi
		1689	elif [[ "${python3}" == "1" ]]; then
		1690	PYTHON_ABI="$(eselect python show --python3 --ABI)"
		1691	if [[ -z "${PYTHON_ABI}" ]]; then
		1692	die "${FUNCNAME}(): Active version of CPython 3 not set"
		1693	elif [[ "${PYTHON_ABI}" != "3."* ]]; then
		1694	die "${FUNCNAME}(): Internal error in \`eselect python show --python3\`"
		1695	fi
		1696	elif _python_package_supporting_installation_for_multiple_python_abis; then
		1697	if ! _python_abi-specific_local_scope; then
		1698	die "${FUNCNAME}() should be used in ABI-specific local scope"
		1699	fi
		1700	else
		1701	PYTHON_ABI="$("${EPREFIX}/usr/bin/python" -c "${_PYTHON_ABI_EXTRACTION_COMMAND}")"
		1702	if [[ -z "${PYTHON_ABI}" ]]; then
		1703	die "${FUNCNAME}(): Failure of extraction of locally active version of Python"
		1704	fi
		1705	fi
		1706	elif [[ "$#" -eq 1 ]]; then
		1707	if [[ "${final_ABI}" == "1" ]]; then
		1708	die "${FUNCNAME}(): '--final-ABI' option and Python ABI cannot be specified simultaneously"
		1709	fi
		1710	if [[ "${python2}" == "1" ]]; then
		1711	die "${FUNCNAME}(): '-2' option and Python ABI cannot be specified simultaneously"
		1712	fi
		1713	if [[ "${python3}" == "1" ]]; then
		1714	die "${FUNCNAME}(): '-3' option and Python ABI cannot be specified simultaneously"
		1715	fi
		1716	PYTHON_ABI="$1"
		1717	else
		1718	die "${FUNCNAME}(): Invalid usage"
		1719	fi
		1720
		1721	if [[ "${ABI_output}" == "1" ]]; then
		1722	echo -n "${PYTHON_ABI}"
		1723	return
		1724	else
		1725	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
		1726	python_interpreter="python${PYTHON_ABI}"
		1727	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
		1728	python_interpreter="jython${PYTHON_ABI%-jython}"
		1729	fi
		1730
		1731	if [[ "${absolute_path_output}" == "1" ]]; then
		1732	echo -n "${EPREFIX}/usr/bin/${python_interpreter}"
		1733	else
		1734	echo -n "${python_interpreter}"
		1735	fi
		1736	fi
		1737
		1738	if [[ -n "${ABI}" && "${ABI}" != "${DEFAULT_ABI}" && "${DEFAULT_ABI}" != "default" ]]; then
		1739	echo -n "-${ABI}"
		1740	fi
		1741	}
		1742
		1743	# @FUNCTION: python_get_implementation
		1744	# @USAGE: [-f\|--final-ABI]
		1745	# @DESCRIPTION:
		1746	# Print name of Python implementation.
		1747	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		1748	python_get_implementation() {
		1749	_python_check_python_pkg_setup_execution
		1750
		1751	local final_ABI="0" PYTHON_ABI="${PYTHON_ABI}"
		1752
		1753	while (($#)); do
		1754	case "$1" in
		1755	-f\|--final-ABI)
		1756	final_ABI="1"
		1757	;;
		1758	-*)
		1759	die "${FUNCNAME}(): Unrecognized option '$1'"
		1760	;;
		1761	*)
		1762	die "${FUNCNAME}(): Invalid usage"
		1763	;;
		1764	esac
		1765	shift
		1766	done
		1767
		1768	if [[ "${final_ABI}" == "1" ]]; then
		1769	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		1770	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		1771	fi
		1772	PYTHON_ABI="$(PYTHON -f --ABI)"
		1773	else
		1774	if _python_package_supporting_installation_for_multiple_python_abis; then
		1775	if ! _python_abi-specific_local_scope; then
		1776	die "${FUNCNAME}() should be used in ABI-specific local scope"
		1777	fi
		1778	else
		1779	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		1780	fi
		1781	fi
		1782
		1783	echo "$(_python_get_implementation "${PYTHON_ABI}")"
		1784	}
		1785
		1786	# @FUNCTION: python_get_implementational_package
		1787	# @USAGE: [-f\|--final-ABI]
		1788	# @DESCRIPTION:
		1789	# Print category, name and slot of package providing Python implementation.
		1790	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		1791	python_get_implementational_package() {
		1792	_python_check_python_pkg_setup_execution
		1793
		1794	local final_ABI="0" PYTHON_ABI="${PYTHON_ABI}"
		1795
		1796	while (($#)); do
		1797	case "$1" in
		1798	-f\|--final-ABI)
		1799	final_ABI="1"
		1800	;;
		1801	-*)
		1802	die "${FUNCNAME}(): Unrecognized option '$1'"
		1803	;;
		1804	*)
		1805	die "${FUNCNAME}(): Invalid usage"
		1806	;;
		1807	esac
		1808	shift
		1809	done
		1810
		1811	if [[ "${final_ABI}" == "1" ]]; then
		1812	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		1813	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		1814	fi
		1815	PYTHON_ABI="$(PYTHON -f --ABI)"
		1816	else
		1817	if _python_package_supporting_installation_for_multiple_python_abis; then
		1818	if ! _python_abi-specific_local_scope; then
		1819	die "${FUNCNAME}() should be used in ABI-specific local scope"
		1820	fi
		1821	else
		1822	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		1823	fi
		1824	fi
		1825
		1826	if [[ "${EAPI:-0}" == "0" ]]; then
		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	else
		1833	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
		1834	echo "dev-lang/python:${PYTHON_ABI}"
		1835	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
		1836	echo "dev-java/jython:${PYTHON_ABI%-jython}"
		1837	fi
		1838	fi
		1839	}
		1840
		1841	# @FUNCTION: python_get_includedir
		1842	# @USAGE: [-b\|--base-path] [-f\|--final-ABI]
		1843	# @DESCRIPTION:
		1844	# Print path to Python include directory.
		1845	# If --base-path option is specified, then path not prefixed with "/" is printed.
		1846	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		1847	python_get_includedir() {
		1848	_python_check_python_pkg_setup_execution
		1849
		1850	local base_path="0" final_ABI="0" prefix PYTHON_ABI="${PYTHON_ABI}"
		1851
		1852	while (($#)); do
		1853	case "$1" in
		1854	-b\|--base-path)
		1855	base_path="1"
		1856	;;
		1857	-f\|--final-ABI)
		1858	final_ABI="1"
		1859	;;
		1860	-*)
		1861	die "${FUNCNAME}(): Unrecognized option '$1'"
		1862	;;
		1863	*)
		1864	die "${FUNCNAME}(): Invalid usage"
		1865	;;
		1866	esac
		1867	shift
		1868	done
		1869
		1870	if [[ "${base_path}" == "0" ]]; then
		1871	prefix="/"
		1872	fi
		1873
		1874	if [[ "${final_ABI}" == "1" ]]; then
		1875	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		1876	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		1877	fi
		1878	PYTHON_ABI="$(PYTHON -f --ABI)"
		1879	else
		1880	if _python_package_supporting_installation_for_multiple_python_abis; then
		1881	if ! _python_abi-specific_local_scope; then
		1882	die "${FUNCNAME}() should be used in ABI-specific local scope"
		1883	fi
		1884	else
		1885	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		1886	fi
		1887	fi
		1888
		1889	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
		1890	echo "${prefix}usr/include/python${PYTHON_ABI}"
		1891	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
		1892	echo "${prefix}usr/share/jython-${PYTHON_ABI%-jython}/Include"
		1893	fi
		1894	}
		1895
		1896	# @FUNCTION: python_get_libdir
		1897	# @USAGE: [-b\|--base-path] [-f\|--final-ABI]
		1898	# @DESCRIPTION:
		1899	# Print path to Python library directory.
		1900	# If --base-path option is specified, then path not prefixed with "/" is printed.
		1901	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		1902	python_get_libdir() {
		1903	_python_check_python_pkg_setup_execution
		1904
		1905	local base_path="0" final_ABI="0" prefix PYTHON_ABI="${PYTHON_ABI}"
		1906
		1907	while (($#)); do
		1908	case "$1" in
		1909	-b\|--base-path)
		1910	base_path="1"
		1911	;;
		1912	-f\|--final-ABI)
		1913	final_ABI="1"
		1914	;;
		1915	-*)
		1916	die "${FUNCNAME}(): Unrecognized option '$1'"
		1917	;;
		1918	*)
		1919	die "${FUNCNAME}(): Invalid usage"
		1920	;;
		1921	esac
		1922	shift
		1923	done
		1924
		1925	if [[ "${base_path}" == "0" ]]; then
		1926	prefix="/"
		1927	fi
		1928
		1929	if [[ "${final_ABI}" == "1" ]]; then
		1930	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		1931	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		1932	fi
		1933	PYTHON_ABI="$(PYTHON -f --ABI)"
		1934	else
		1935	if _python_package_supporting_installation_for_multiple_python_abis; then
		1936	if ! _python_abi-specific_local_scope; then
		1937	die "${FUNCNAME}() should be used in ABI-specific local scope"
		1938	fi
		1939	else
		1940	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		1941	fi
		1942	fi
		1943
		1944	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
		1945	echo "${prefix}usr/$(get_libdir)/python${PYTHON_ABI}"
		1946	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
		1947	echo "${prefix}usr/share/jython-${PYTHON_ABI%-jython}/Lib"
		1948	fi
		1949	}
		1950
		1951	# @FUNCTION: python_get_sitedir
		1952	# @USAGE: [-b\|--base-path] [-f\|--final-ABI]
		1953	# @DESCRIPTION:
		1954	# Print path to Python site-packages directory.
		1955	# If --base-path option is specified, then path not prefixed with "/" is printed.
		1956	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		1957	python_get_sitedir() {
		1958	_python_check_python_pkg_setup_execution
		1959
		1960	local final_ABI="0" options=()
		1961
		1962	while (($#)); do
		1963	case "$1" in
		1964	-b\|--base-path)
		1965	options+=("$1")
		1966	;;
		1967	-f\|--final-ABI)
		1968	final_ABI="1"
		1969	options+=("$1")
		1970	;;
		1971	-*)
		1972	die "${FUNCNAME}(): Unrecognized option '$1'"
		1973	;;
		1974	*)
		1975	die "${FUNCNAME}(): Invalid usage"
		1976	;;
		1977	esac
		1978	shift
		1979	done
		1980
		1981	if [[ "${final_ABI}" == "1" ]]; then
		1982	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		1983	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		1984	fi
		1985	else
		1986	if _python_package_supporting_installation_for_multiple_python_abis && ! _python_abi-specific_local_scope; then
		1987	die "${FUNCNAME}() should be used in ABI-specific local scope"
		1988	fi
		1989	fi
		1990
		1991	echo "$(python_get_libdir "${options[@]}")/site-packages"
		1992	}
		1993
		1994	# @FUNCTION: python_get_library
		1995	# @USAGE: [-b\|--base-path] [-f\|--final-ABI] [-l\|--linker-option]
		1996	# @DESCRIPTION:
		1997	# Print path to Python library.
		1998	# If --base-path option is specified, then path not prefixed with "/" is printed.
		1999	# If --linker-option is specified, then "-l${library}" linker option is printed.
		2000	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		2001	python_get_library() {
		2002	_python_check_python_pkg_setup_execution
		2003
		2004	local base_path="0" final_ABI="0" linker_option="0" prefix PYTHON_ABI="${PYTHON_ABI}"
		2005
		2006	while (($#)); do
		2007	case "$1" in
		2008	-b\|--base-path)
		2009	base_path="1"
		2010	;;
		2011	-f\|--final-ABI)
		2012	final_ABI="1"
		2013	;;
		2014	-l\|--linker-option)
		2015	linker_option="1"
		2016	;;
		2017	-*)
		2018	die "${FUNCNAME}(): Unrecognized option '$1'"
		2019	;;
		2020	*)
		2021	die "${FUNCNAME}(): Invalid usage"
		2022	;;
		2023	esac
		2024	shift
		2025	done
		2026
		2027	if [[ "${base_path}" == "0" ]]; then
		2028	prefix="/"
		2029	fi
		2030
		2031	if [[ "${base_path}" == "1" && "${linker_option}" == "1" ]]; then
		2032	die "${FUNCNAME}(): '--base-path' and '--linker-option' options cannot be specified simultaneously"
		2033	fi
		2034
		2035	if [[ "${final_ABI}" == "1" ]]; then
		2036	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		2037	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		2038	fi
		2039	PYTHON_ABI="$(PYTHON -f --ABI)"
		2040	else
		2041	if _python_package_supporting_installation_for_multiple_python_abis; then
		2042	if ! _python_abi-specific_local_scope; then
		2043	die "${FUNCNAME}() should be used in ABI-specific local scope"
		2044	fi
		2045	else
		2046	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		2047	fi
		2048	fi
		2049
		2050	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
		2051	if [[ "${linker_option}" == "1" ]]; then
		2052	echo "-lpython${PYTHON_ABI}"
		2053	else
		2054	echo "${prefix}usr/$(get_libdir)/libpython${PYTHON_ABI}$(get_libname)"
		2055	fi
		2056	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
		2057	die "${FUNCNAME}(): Jython does not have shared library"
		2058	fi
		2059	}
		2060
		2061	# @FUNCTION: python_get_version
		2062	# @USAGE: [-f\|--final-ABI] [--full] [--major] [--minor] [--micro]
		2063	# @DESCRIPTION:
		2064	# Print Python version.
		2065	# --full, --major, --minor and --micro options cannot be specified simultaneously.
		2066	# If --full, --major, --minor and --micro options are not specified, then "${major_version}.${minor_version}" is printed.
		2067	# If --final-ABI option is specified, then final ABI from the list of enabled ABIs is used.
		2068	python_get_version() {
		2069	_python_check_python_pkg_setup_execution
		2070
		2071	local final_ABI="0" full="0" major="0" minor="0" micro="0" python_command
		2072
		2073	while (($#)); do
		2074	case "$1" in
		2075	-f\|--final-ABI)
		2076	final_ABI="1"
		2077	;;
		2078	--full)
		2079	full="1"
		2080	;;
		2081	--major)
		2082	major="1"
		2083	;;
		2084	--minor)
		2085	minor="1"
		2086	;;
		2087	--micro)
		2088	micro="1"
		2089	;;
		2090	-*)
		2091	die "${FUNCNAME}(): Unrecognized option '$1'"
		2092	;;
		2093	*)
		2094	die "${FUNCNAME}(): Invalid usage"
		2095	;;
		2096	esac
		2097	shift
		2098	done
		2099
		2100	if [[ "$((${full} + ${major} + ${minor} + ${micro}))" -gt 1 ]]; then
		2101	die "${FUNCNAME}(): '--full', '--major', '--minor' or '--micro' options cannot be specified simultaneously"
		2102	fi
		2103
		2104	if [[ "${full}" == "1" ]]; then
		2105	python_command="from sys import version_info; print('.'.join(str(x) for x in version_info[:3]))"
		2106	elif [[ "${major}" == "1" ]]; then
		2107	python_command="from sys import version_info; print(version_info[0])"
		2108	elif [[ "${minor}" == "1" ]]; then
		2109	python_command="from sys import version_info; print(version_info[1])"
		2110	elif [[ "${micro}" == "1" ]]; then
		2111	python_command="from sys import version_info; print(version_info[2])"
		2112	else
		2113	if [[ -n "${PYTHON_ABI}" && "${final_ABI}" == "0" ]]; then
		2114	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "CPython" ]]; then
		2115	echo "${PYTHON_ABI}"
		2116	elif [[ "$(_python_get_implementation "${PYTHON_ABI}")" == "Jython" ]]; then
		2117	echo "${PYTHON_ABI%-jython}"
		2118	fi
		2119	return
		2120	fi
		2121	python_command="from sys import version_info; print('.'.join(str(x) for x in version_info[:2]))"
		2122	fi
		2123
		2124	if [[ "${final_ABI}" == "1" ]]; then
		2125	if ! _python_package_supporting_installation_for_multiple_python_abis; then
		2126	die "${FUNCNAME}(): '--final-ABI' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		2127	fi
		2128	"$(PYTHON -f)" -c "${python_command}"
		2129	else
		2130	if _python_package_supporting_installation_for_multiple_python_abis && ! _python_abi-specific_local_scope; then
		2131	die "${FUNCNAME}() should be used in ABI-specific local scope"
		2132	fi
		2133	"$(PYTHON ${PYTHON_ABI})" -c "${python_command}"
		2134	fi
		2135	}
		2136
		2137	# ================================================================================================
		2138	# ================================ FUNCTIONS FOR RUNNING OF TESTS ================================
		2139	# ================================================================================================
		2140
444	# @ECLASS-VARIABLE: PYTHON_USE_WITH	2141	# @ECLASS-VARIABLE: PYTHON_TEST_VERBOSITY
445	# @DESCRIPTION:	2142	# @DESCRIPTION:
446	# Set this to a space separated list of use flags	2143	# User-configurable verbosity of tests of Python modules.
447	# the python slot in use must be built with.	2144	# Supported values: 0, 1, 2, 3, 4.
		2145	PYTHON_TEST_VERBOSITY="${PYTHON_TEST_VERBOSITY:-1}"
448		2146
449	# @ECLASS-VARIABLE: PYTHON_USE_WITH_OR	2147	_python_test_hook() {
450	# @DESCRIPTION:	2148	if [[ "$#" -ne 1 ]]; then
451	# Set this to a space separated list of use flags	2149	die "${FUNCNAME}() requires 1 argument"
452	# of which one must be turned on for the slot of	2150	fi
453	# in use.
454		2151
455	# @ECLASS-VARIABLE: PYTHON_USE_WITH_OPT	2152	if _python_package_supporting_installation_for_multiple_python_abis && [[ "$(type -t "${FUNCNAME[3]}_$1_hook")" == "function" ]]; then
456	# @DESCRIPTION:	2153	"${FUNCNAME[3]}_$1_hook"
457	# Set this if you need to make either PYTHON_USE_WITH or	2154	fi
458	# PYTHON_USE_WITH_OR atoms conditional under a use flag.	2155	}
459		2156
460	# @FUNCTION: python_pkg_setup	2157	# @FUNCTION: python_execute_nosetests
		2158	# @USAGE: [-P\|--PYTHONPATH PYTHONPATH] [-s\|--separate-build-dirs] [--] [arguments]
461	# @DESCRIPTION:	2159	# @DESCRIPTION:
462	# Makes sure PYTHON_USE_WITH or PYTHON_USE_WITH_OR listed use flags	2160	# Execute nosetests for all enabled Python ABIs.
463	# are respected. Only exported if one of those variables is set.	2161	# In ebuilds of packages supporting installation for multiple Python ABIs, this function calls
464	if ! has "${EAPI:-0}" 0 1 && [[ -n ${PYTHON_USE_WITH} \|\| -n ${PYTHON_USE_WITH_OR} ]]; then	2162	# python_execute_nosetests_pre_hook() and python_execute_nosetests_post_hook(), if they are defined.
465	python_pkg_setup_fail() {	2163	python_execute_nosetests() {
466	eerror "${1}"	2164	_python_check_python_pkg_setup_execution
467	die "${1}"	2165	_python_set_color_variables
		2166
		2167	local PYTHONPATH_template= separate_build_dirs=
		2168
		2169	while (($#)); do
		2170	case "$1" in
		2171	-P\|--PYTHONPATH)
		2172	PYTHONPATH_template="$2"
		2173	shift
		2174	;;
		2175	-s\|--separate-build-dirs)
		2176	separate_build_dirs="1"
		2177	;;
		2178	--)
		2179	shift
		2180	break
		2181	;;
		2182	-*)
		2183	die "${FUNCNAME}(): Unrecognized option '$1'"
		2184	;;
		2185	*)
		2186	break
		2187	;;
		2188	esac
		2189	shift
		2190	done
		2191
		2192	python_test_function() {
		2193	local evaluated_PYTHONPATH
		2194
		2195	eval "evaluated_PYTHONPATH=\"${PYTHONPATH_template}\""
		2196
		2197	_python_test_hook pre
		2198
		2199	if [[ -n "${evaluated_PYTHONPATH}" ]]; then
		2200	echo ${_BOLD}PYTHONPATH="${evaluated_PYTHONPATH}" nosetests --verbosity="${PYTHON_TEST_VERBOSITY}" "$@"${_NORMAL}
		2201	PYTHONPATH="${evaluated_PYTHONPATH}" nosetests --verbosity="${PYTHON_TEST_VERBOSITY}" "$@" \|\| return "$?"
		2202	else
		2203	echo ${_BOLD}nosetests --verbosity="${PYTHON_TEST_VERBOSITY}" "$@"${_NORMAL}
		2204	nosetests --verbosity="${PYTHON_TEST_VERBOSITY}" "$@" \|\| return "$?"
		2205	fi
		2206
		2207	_python_test_hook post
468	}	2208	}
469		2209	if _python_package_supporting_installation_for_multiple_python_abis; then
470	python_pkg_setup() {	2210	python_execute_function ${separate_build_dirs:+-s} python_test_function "$@"
471	[[ ${PYTHON_USE_WITH_OPT} ]] && use !${PYTHON_USE_WITH_OPT} && return	2211	else
472		2212	if [[ -n "${separate_build_dirs}" ]]; then
473	python_version	2213	die "${FUNCNAME}(): Invalid usage"
474	local failed
475	local pyatom="dev-lang/python:${PYVER}"
476
477	for use in ${PYTHON_USE_WITH}; do
478	if ! has_version "${pyatom}[${use}]"; then
479	python_pkg_setup_fail \
480	"Please rebuild ${pyatom} with use flags: ${PYTHON_USE_WITH}"
481	fi	2214	fi
		2215	python_test_function "$@" \|\| die "Testing failed"
		2216	fi
		2217
		2218	unset -f python_test_function
		2219	}
		2220
		2221	# @FUNCTION: python_execute_py.test
		2222	# @USAGE: [-P\|--PYTHONPATH PYTHONPATH] [-s\|--separate-build-dirs] [--] [arguments]
		2223	# @DESCRIPTION:
		2224	# Execute py.test for all enabled Python ABIs.
		2225	# In ebuilds of packages supporting installation for multiple Python ABIs, this function calls
		2226	# python_execute_py.test_pre_hook() and python_execute_py.test_post_hook(), if they are defined.
		2227	python_execute_py.test() {
		2228	_python_check_python_pkg_setup_execution
		2229	_python_set_color_variables
		2230
		2231	local PYTHONPATH_template= separate_build_dirs=
		2232
		2233	while (($#)); do
		2234	case "$1" in
		2235	-P\|--PYTHONPATH)
		2236	PYTHONPATH_template="$2"
		2237	shift
		2238	;;
		2239	-s\|--separate-build-dirs)
		2240	separate_build_dirs="1"
		2241	;;
		2242	--)
		2243	shift
		2244	break
		2245	;;
		2246	-*)
		2247	die "${FUNCNAME}(): Unrecognized option '$1'"
		2248	;;
		2249	*)
		2250	break
		2251	;;
		2252	esac
		2253	shift
482	done	2254	done
483		2255
484	for use in ${PYTHON_USE_WITH_OR}; do	2256	python_test_function() {
485	if has_version "${pyatom}[${use}]"; then	2257	local evaluated_PYTHONPATH
486	return	2258
		2259	eval "evaluated_PYTHONPATH=\"${PYTHONPATH_template}\""
		2260
		2261	_python_test_hook pre
		2262
		2263	if [[ -n "${evaluated_PYTHONPATH}" ]]; then
		2264	echo ${_BOLD}PYTHONPATH="${evaluated_PYTHONPATH}" py.test $([[ "${PYTHON_TEST_VERBOSITY}" -ge 2 ]] && echo -v) "$@"${_NORMAL}
		2265	PYTHONPATH="${evaluated_PYTHONPATH}" py.test $([[ "${PYTHON_TEST_VERBOSITY}" -ge 2 ]] && echo -v) "$@" \|\| return "$?"
		2266	else
		2267	echo ${_BOLD}py.test $([[ "${PYTHON_TEST_VERBOSITY}" -gt 1 ]] && echo -v) "$@"${_NORMAL}
		2268	py.test $([[ "${PYTHON_TEST_VERBOSITY}" -gt 1 ]] && echo -v) "$@" \|\| return "$?"
487	fi	2269	fi
488	done
489		2270
490	if [[ ${PYTHON_USE_WITH_OR} ]]; then	2271	_python_test_hook post
491	python_pkg_setup_fail \
492	"Please rebuild ${pyatom} with one of: ${PYTHON_USE_WITH_OR}"
493	fi
494	}	2272	}
		2273	if _python_package_supporting_installation_for_multiple_python_abis; then
		2274	python_execute_function ${separate_build_dirs:+-s} python_test_function "$@"
		2275	else
		2276	if [[ -n "${separate_build_dirs}" ]]; then
		2277	die "${FUNCNAME}(): Invalid usage"
		2278	fi
		2279	python_test_function "$@" \|\| die "Testing failed"
		2280	fi
495		2281
496	EXPORT_FUNCTIONS pkg_setup	2282	unset -f python_test_function
		2283	}
497		2284
498	if [[ ${PYTHON_USE_WITH} ]]; then	2285	# @FUNCTION: python_execute_trial
499	PYTHON_USE_WITH_ATOM="${PYTHON_ATOM}[${PYTHON_USE_WITH/ /,}]"	2286	# @USAGE: [-P\|--PYTHONPATH PYTHONPATH] [-s\|--separate-build-dirs] [--] [arguments]
500	elif [[ ${PYTHON_USE_WITH_OR} ]]; then	2287	# @DESCRIPTION:
501	PYTHON_USE_WITH_ATOM="\|\| ( "	2288	# Execute trial for all enabled Python ABIs.
502	for use in ${PYTHON_USE_WITH_OR}; do	2289	# In ebuilds of packages supporting installation for multiple Python ABIs, this function
503	PYTHON_USE_WITH_ATOM="	2290	# calls python_execute_trial_pre_hook() and python_execute_trial_post_hook(), if they are defined.
504	${PYTHON_USE_WITH_ATOM}	2291	python_execute_trial() {
505	${PYTHON_ATOM}[${use}]"	2292	_python_check_python_pkg_setup_execution
		2293	_python_set_color_variables
		2294
		2295	local PYTHONPATH_template= separate_build_dirs=
		2296
		2297	while (($#)); do
		2298	case "$1" in
		2299	-P\|--PYTHONPATH)
		2300	PYTHONPATH_template="$2"
		2301	shift
		2302	;;
		2303	-s\|--separate-build-dirs)
		2304	separate_build_dirs="1"
		2305	;;
		2306	--)
		2307	shift
		2308	break
		2309	;;
		2310	-*)
		2311	die "${FUNCNAME}(): Unrecognized option '$1'"
		2312	;;
		2313	*)
		2314	break
		2315	;;
		2316	esac
		2317	shift
506	done	2318	done
507	PYTHON_USE_WITH_ATOM="${PYTHON_USE_WITH_ATOM} )"	2319
		2320	python_test_function() {
		2321	local evaluated_PYTHONPATH
		2322
		2323	eval "evaluated_PYTHONPATH=\"${PYTHONPATH_template}\""
		2324
		2325	_python_test_hook pre
		2326
		2327	if [[ -n "${evaluated_PYTHONPATH}" ]]; then
		2328	echo ${_BOLD}PYTHONPATH="${evaluated_PYTHONPATH}" trial $([[ "${PYTHON_TEST_VERBOSITY}" -ge 4 ]] && echo --spew) "$@"${_NORMAL}
		2329	PYTHONPATH="${evaluated_PYTHONPATH}" trial $([[ "${PYTHON_TEST_VERBOSITY}" -ge 4 ]] && echo --spew) "$@" \|\| return "$?"
		2330	else
		2331	echo ${_BOLD}trial $([[ "${PYTHON_TEST_VERBOSITY}" -ge 4 ]] && echo --spew) "$@"${_NORMAL}
		2332	trial $([[ "${PYTHON_TEST_VERBOSITY}" -ge 4 ]] && echo --spew) "$@" \|\| return "$?"
508	fi	2333	fi
509	if [[ ${PYTHON_USE_WITH_OPT} ]]; then
510	PYTHON_USE_WITH_ATOM="${PYTHON_USE_WITH_OPT}? ( ${PYTHON_USE_WITH_ATOM} )"
511	fi
512	DEPEND="${PYTHON_USE_WITH_ATOM}"
513	RDEPEND="${PYTHON_USE_WITH_ATOM}"
514	fi
515		2334
516	# @ECLASS-VARIABLE: PYTHON_DEFINE_DEFAULT_FUNCTIONS	2335	_python_test_hook post
517	# @DESCRIPTION:
518	# Set this to define default functions for the following ebuild phases:
519	# src_prepare, src_configure, src_compile, src_test, src_install.
520	if ! has "${EAPI:-0}" 0 1 && [[ -n "${PYTHON_DEFINE_DEFAULT_FUNCTIONS}" ]]; then
521	python_src_prepare() {
522	python_copy_sources
523	}	2336	}
		2337	if _python_package_supporting_installation_for_multiple_python_abis; then
		2338	python_execute_function ${separate_build_dirs:+-s} python_test_function "$@"
		2339	else
		2340	if [[ -n "${separate_build_dirs}" ]]; then
		2341	die "${FUNCNAME}(): Invalid usage"
		2342	fi
		2343	python_test_function "$@" \|\| die "Testing failed"
		2344	fi
524		2345
525	for python_default_function in src_configure src_compile src_test src_install; do
526	eval "python_${python_default_function}() { python_execute_function -d -s; }"
527	done
528	unset python_default_function	2346	unset -f python_test_function
529
530	EXPORT_FUNCTIONS src_prepare src_configure src_compile src_test src_install
531	fi
532
533	# @FUNCTION: python_disable_pyc
534	# @DESCRIPTION:
535	# Tell Python not to automatically recompile modules to .pyc/.pyo
536	# even if the timestamps/version stamps don't match. This is done
537	# to protect sandbox.
538	python_disable_pyc() {
539	export PYTHONDONTWRITEBYTECODE="1"
540	}	2347	}
		2348
		2349	# ================================================================================================
		2350	# ======================= FUNCTIONS FOR HANDLING OF BYTE-COMPILED MODULES ========================
		2351	# ================================================================================================
541		2352
542	# @FUNCTION: python_enable_pyc	2353	# @FUNCTION: python_enable_pyc
543	# @DESCRIPTION:	2354	# @DESCRIPTION:
544	# Tell Python to automatically recompile modules to .pyc/.pyo if the	2355	# Tell Python to automatically recompile modules to .pyc/.pyo if the
545	# timestamps/version stamps have changed.	2356	# timestamps/version stamps have changed.
546	python_enable_pyc() {	2357	python_enable_pyc() {
		2358	_python_check_python_pkg_setup_execution
		2359
		2360	if [[ "$#" -ne 0 ]]; then
		2361	die "${FUNCNAME}() does not accept arguments"
		2362	fi
		2363
547	unset PYTHONDONTWRITEBYTECODE	2364	unset PYTHONDONTWRITEBYTECODE
548	}	2365	}
549		2366
		2367	# @FUNCTION: python_disable_pyc
		2368	# @DESCRIPTION:
		2369	# Tell Python not to automatically recompile modules to .pyc/.pyo
		2370	# even if the timestamps/version stamps do not match. This is done
		2371	# to protect sandbox.
550	python_disable_pyc	2372	python_disable_pyc() {
		2373	_python_check_python_pkg_setup_execution
551		2374
552	# @FUNCTION: python_need_rebuild	2375	if [[ "$#" -ne 0 ]]; then
553	# @DESCRIPTION: Run without arguments, specifies that the package should be	2376	die "${FUNCNAME}() does not accept arguments"
554	# rebuilt after a python upgrade.	2377	fi
555	python_need_rebuild() {
556	python_version
557	export PYTHON_NEED_REBUILD=${PYVER}
558	}
559		2378
560	# @FUNCTION: python_get_includedir	2379	export PYTHONDONTWRITEBYTECODE="1"
561	# @DESCRIPTION:	2380	}
562	# Run without arguments, returns the Python include directory.	2381
563	python_get_includedir() {	2382	_python_clean_compiled_modules() {
564	if [[ -n "${PYTHON_ABI}" ]]; then	2383	_python_initialize_prefix_variables
565	echo "/usr/include/python${PYTHON_ABI}"	2384	_python_set_color_variables
566	else	2385
567	python_version	2386	[[ "${FUNCNAME[1]}" =~ ^(python_mod_optimize\|python_mod_cleanup)$ ]] \|\| die "${FUNCNAME}(): Invalid usage"
568	echo "/usr/include/python${PYVER}"	2387
		2388	local base_module_name compiled_file compiled_files=() dir path py_file root
		2389
		2390	# Strip trailing slash from EROOT.
		2391	root="${EROOT%/}"
		2392
		2393	for path in "$@"; do
		2394	compiled_files=()
		2395	if [[ -d "${path}" ]]; then
		2396	while read -d $'\0' -r compiled_file; do
		2397	compiled_files+=("${compiled_file}")
		2398	done < <(find "${path}" "(" -name ".py[co]" -o -name "\$py.class" ")" -print0)
		2399
		2400	if [[ "${EBUILD_PHASE}" == "postrm" ]]; then
		2401	# Delete empty child directories.
		2402	find "${path}" -type d \| sort -r \| while read -r dir; do
		2403	if rmdir "${dir}" 2> /dev/null; then
		2404	echo "${_CYAN}<<< ${dir}${_NORMAL}"
		2405	fi
		2406	done
		2407	fi
		2408	elif [[ "${path}" == *.py ]]; then
		2409	base_module_name="${path##*/}"
		2410	base_module_name="${base_module_name%.py}"
		2411	if [[ -d "${path%/*}/__pycache__" ]]; then
		2412	while read -d $'\0' -r compiled_file; do
		2413	compiled_files+=("${compiled_file}")
		2414	done < <(find "${path%/}/__pycache__" "(" -name "${base_module_name}..py[co]" -o -name "${base_module_name}\$py.class" ")" -print0)
		2415	fi
		2416	compiled_files+=("${path}c" "${path}o" "${path%.py}\$py.class")
569	fi	2417	fi
570	}
571		2418
572	# @FUNCTION: python_get_libdir	2419	for compiled_file in "${compiled_files[@]}"; do
573	# @DESCRIPTION:	2420	[[ ! -f "${compiled_file}" ]] && continue
574	# Run without arguments, returns the Python library directory.	2421	dir="${compiled_file%/*}"
575	python_get_libdir() {	2422	dir="${dir##*/}"
576	if [[ -n "${PYTHON_ABI}" ]]; then	2423	if [[ "${compiled_file}" == *.py[co] ]]; then
577	echo "/usr/$(get_libdir)/python${PYTHON_ABI}"	2424	if [[ "${dir}" == "__pycache__" ]]; then
		2425	base_module_name="${compiled_file##*/}"
		2426	base_module_name="${base_module_name%.*py[co]}"
		2427	base_module_name="${base_module_name%.*}"
		2428	py_file="${compiled_file%__pycache__/*}${base_module_name}.py"
		2429	else
		2430	py_file="${compiled_file%[co]}"
		2431	fi
		2432	if [[ "${EBUILD_PHASE}" == "postinst" ]]; then
		2433	[[ -f "${py_file}" && "${compiled_file}" -nt "${py_file}" ]] && continue
		2434	else
		2435	[[ -f "${py_file}" ]] && continue
		2436	fi
		2437	echo "${_BLUE}<<< ${compiled_file%[co]}[co]${_NORMAL}"
		2438	rm -f "${compiled_file%[co]}"[co]
		2439	elif [[ "${compiled_file}" == *\$py.class ]]; then
		2440	if [[ "${dir}" == "__pycache__" ]]; then
		2441	base_module_name="${compiled_file##*/}"
		2442	base_module_name="${base_module_name%\$py.class}"
		2443	py_file="${compiled_file%__pycache__/*}${base_module_name}.py"
		2444	else
		2445	py_file="${compiled_file%\$py.class}.py"
		2446	fi
		2447	if [[ "${EBUILD_PHASE}" == "postinst" ]]; then
		2448	[[ -f "${py_file}" && "${compiled_file}" -nt "${py_file}" ]] && continue
		2449	else
		2450	[[ -f "${py_file}" ]] && continue
		2451	fi
		2452	echo "${_BLUE}<<< ${compiled_file}${_NORMAL}"
		2453	rm -f "${compiled_file}"
578	else	2454	else
579	python_version	2455	die "${FUNCNAME}(): Unrecognized file type: '${compiled_file}'"
580	echo "/usr/$(get_libdir)/python${PYVER}"
581	fi	2456	fi
582	}
583		2457
584	# @FUNCTION: python_get_sitedir	2458	# Delete empty parent directories.
585	# @DESCRIPTION:	2459	dir="${compiled_file%/*}"
586	# Run without arguments, returns the Python site-packages directory.	2460	while [[ "${dir}" != "${root}" ]]; do
587	python_get_sitedir() {	2461	if rmdir "${dir}" 2> /dev/null; then
588	echo "$(python_get_libdir)/site-packages"	2462	echo "${_CYAN}<<< ${dir}${_NORMAL}"
		2463	else
		2464	break
		2465	fi
		2466	dir="${dir%/*}"
		2467	done
		2468	done
		2469	done
589	}	2470	}
590		2471
591	# @FUNCTION: python_tkinter_exists
592	# @DESCRIPTION:
593	# Run without arguments, checks if python was compiled with Tkinter
594	# support. If not, prints an error message and dies.
595	python_tkinter_exists() {
596	if ! python -c "import Tkinter" >/dev/null 2>&1; then
597	eerror "You need to recompile python with Tkinter support."
598	eerror "Try adding: 'dev-lang/python tk'"
599	eerror "in to /etc/portage/package.use"
600	echo
601	die "missing tkinter support with installed python"
602	fi
603	}
604
605	# @FUNCTION: python_mod_exists	2472	# @FUNCTION: python_mod_optimize
606	# @USAGE: <module>	2473	# @USAGE: [--allow-evaluated-non-sitedir-paths] [-d directory] [-f] [-l] [-q] [-x regular_expression] [--] <file\|directory> [files\|directories]
607	# @DESCRIPTION:	2474	# @DESCRIPTION:
608	# Run with the module name as an argument. it will check if a	2475	# Byte-compile specified Python modules.
609	# python module is installed and loadable. it will return	2476	# -d, -f, -l, -q and -x options passed to this function are passed to compileall.py.
610	# TRUE(0) if the module exists, and FALSE(1) if the module does
611	# not exist.
612	#	2477	#
613	# Example:
614	# if python_mod_exists gtk; then
615	# echo "gtk support enabled"
616	# fi
617	python_mod_exists() {
618	[[ "$1" ]] \|\| die "${FUNCNAME} requires an argument!"
619	python -c "import $1" &>/dev/null
620	}
621
622	# @FUNCTION: python_mod_compile
623	# @USAGE: <file> [more files ...]
624	# @DESCRIPTION:
625	# Given filenames, it will pre-compile the module's .pyc and .pyo.
626	# This function should only be run in pkg_postinst()
627	#
628	# Example:
629	# python_mod_compile /usr/lib/python2.3/site-packages/pygoogle.py
630	#
631	python_mod_compile() {
632	if ! has "${EAPI:-0}" 0 1 2 \|\| [[ -n "${SUPPORT_PYTHON_ABIS}" ]]; then
633	die "${FUNCNAME}() cannot be used in this EAPI"
634	fi
635
636	local f myroot myfiles=()
637
638	# Check if phase is pkg_postinst()
639	[[ ${EBUILD_PHASE} != postinst ]] &&\
640	die "${FUNCNAME} should only be run in pkg_postinst()"
641
642	# allow compiling for older python versions
643	if [[ "${PYTHON_OVERRIDE_PYVER}" ]]; then
644	PYVER=${PYTHON_OVERRIDE_PYVER}
645	else
646	python_version
647	fi
648
649	# strip trailing slash
650	myroot="${ROOT%/}"
651
652	# respect ROOT
653	for f in "$@"; do
654	[[ -f "${myroot}/${f}" ]] && myfiles+=("${myroot}/${f}")
655	done
656
657	if ((${#myfiles[@]})); then
658	python${PYVER} ${myroot}/usr/$(get_libdir)/python${PYVER}/py_compile.py "${myfiles[@]}"
659	python${PYVER} -O ${myroot}/usr/$(get_libdir)/python${PYVER}/py_compile.py "${myfiles[@]}" &> /dev/null
660	else
661	ewarn "No files to compile!"
662	fi
663	}
664
665	# @FUNCTION: python_mod_optimize
666	# @USAGE: [options] [directory\|file]
667	# @DESCRIPTION:
668	# If no arguments supplied, it will recompile not recursively all modules
669	# under sys.path (eg. /usr/lib/python2.6, /usr/lib/python2.6/site-packages).
670	#
671	# If supplied with arguments, it will recompile all modules recursively
672	# in the supplied directory.
673	# This function should only be run in pkg_postinst().	2478	# This function can be used only in pkg_postinst() phase.
674	#
675	# Options passed to this function are passed to compileall.py.
676	#
677	# Example:
678	# python_mod_optimize ctypesgencore
679	python_mod_optimize() {	2479	python_mod_optimize() {
		2480	_python_check_python_pkg_setup_execution
		2481	_python_initialize_prefix_variables
		2482
680	# Check if phase is pkg_postinst().	2483	# Check if phase is pkg_postinst().
681	[[ ${EBUILD_PHASE} != "postinst" ]] && die "${FUNCNAME} should only be run in pkg_postinst()"	2484	[[ "${EBUILD_PHASE}" != "postinst" ]] && die "${FUNCNAME}() can be used only in pkg_postinst() phase"
682		2485
		2486	if ! has "${EAPI:-0}" 0 1 2 \|\| _python_package_supporting_installation_for_multiple_python_abis \|\| _python_implementation \|\| [[ "${CATEGORY}/${PN}" == "sys-apps/portage" ]]; then
		2487	# PYTHON_ABI variable cannot be local in packages not supporting installation for multiple Python ABIs.
		2488	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=()
		2489
		2490	if _python_package_supporting_installation_for_multiple_python_abis; then
683	if ! has "${EAPI:-0}" 0 1 2 \|\| [[ -n "${SUPPORT_PYTHON_ABIS}" ]]; then	2491	if has "${EAPI:-0}" 0 1 2 3 && [[ -z "${PYTHON_ABIS}" ]]; then
684	local dir file options=() other_dirs=() other_files=() PYTHON_ABI return_code root site_packages_absolute_dirs=() site_packages_dirs=() site_packages_absolute_files=() site_packages_files=()	2492	die "${FUNCNAME}(): python_pkg_setup() or python_execute_function() not called"
		2493	fi
		2494	iterated_PYTHON_ABIS="${PYTHON_ABIS}"
		2495	else
		2496	if has "${EAPI:-0}" 0 1 2 3; then
		2497	iterated_PYTHON_ABIS="${PYTHON_ABI:=$(PYTHON --ABI)}"
		2498	else
		2499	iterated_PYTHON_ABIS="${PYTHON_ABI}"
		2500	fi
		2501	fi
685		2502
686	# Strip trailing slash from ROOT.	2503	# Strip trailing slash from EROOT.
687	root="${ROOT%/}"	2504	root="${EROOT%/}"
688		2505
689	# Respect ROOT and options passed to compileall.py.
690	while (($#)); do	2506	while (($#)); do
691	case "$1" in	2507	case "$1" in
		2508	--allow-evaluated-non-sitedir-paths)
		2509	allow_evaluated_non_sitedir_paths="1"
		2510	;;
692	-l\|-f\|-q)	2511	-l\|-f\|-q)
693	options+=("$1")	2512	options+=("$1")
694	;;	2513	;;
695	-d\|-x)	2514	-d\|-x)
696	options+=("$1" "$2")	2515	options+=("$1" "$2")
697	shift	2516	shift
698	;;	2517	;;
		2518	--)
		2519	shift
		2520	break
		2521	;;
699	-*)	2522	-*)
700	ewarn "${FUNCNAME}: Ignoring compile option $1"	2523	die "${FUNCNAME}(): Unrecognized option '$1'"
701	;;	2524	;;
702	*)	2525	*)
703	if [[ "$1" =~ ^/usr/lib(32\|64)?/python[[:digit:]]+\.[[:digit:]]+ ]]; then
704	die "${FUNCNAME} doesn't support absolute paths of directories/files in site-packages directories"
705	elif [[ "$1" =~ ^/ ]]; then
706	if [[ -d "${root}/$1" ]]; then
707	other_dirs+=("${root}/$1")
708	elif [[ -f "${root}/$1" ]]; then
709	other_files+=("${root}/$1")
710	elif [[ -e "${root}/$1" ]]; then
711	ewarn "'${root}/$1' is not a file or a directory!"
712	else
713	ewarn "'${root}/$1' doesn't exist!"
714	fi
715	else
716	for PYTHON_ABI in ${PYTHON_ABIS}; do
717	if [[ -d "${root}$(python_get_sitedir)/$1" ]]; then
718	site_packages_dirs+=("$1")
719	break	2526	break
720	elif [[ -f "${root}$(python_get_sitedir)/$1" ]]; then
721	site_packages_files+=("$1")
722	break
723	elif [[ -e "${root}$(python_get_sitedir)/$1" ]]; then
724	ewarn "'$1' is not a file or a directory!"
725	else
726	ewarn "'$1' doesn't exist!"
727	fi
728	done
729	fi
730	;;	2527	;;
731	esac	2528	esac
732	shift	2529	shift
733	done	2530	done
734		2531
		2532	if [[ "${allow_evaluated_non_sitedir_paths}" == "1" ]] && ! _python_package_supporting_installation_for_multiple_python_abis; then
		2533	die "${FUNCNAME}(): '--allow-evaluated-non-sitedir-paths' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		2534	fi
		2535
		2536	if [[ "$#" -eq 0 ]]; then
		2537	die "${FUNCNAME}(): Missing files or directories"
		2538	fi
		2539
		2540	while (($#)); do
		2541	if [[ "$1" =~ ^($\|(\.\|\.\.\|/)($\|/)) ]]; then
		2542	die "${FUNCNAME}(): Invalid argument '$1'"
		2543	elif ! _python_implementation && [[ "$1" =~ ^/usr/lib(32\|64)?/python[[:digit:]]+\.[[:digit:]]+ ]]; then
		2544	die "${FUNCNAME}(): Paths of directories / files in site-packages directories must be relative to site-packages directories"
		2545	elif [[ "$1" =~ ^/ ]]; then
		2546	if _python_package_supporting_installation_for_multiple_python_abis; then
		2547	if [[ "${allow_evaluated_non_sitedir_paths}" != "1" ]]; then
		2548	die "${FUNCNAME}(): Absolute paths cannot be used in ebuilds of packages supporting installation for multiple Python ABIs"
		2549	fi
		2550	if [[ "$1" != \$ ]]; then
		2551	die "${FUNCNAME}(): '$1' has invalid syntax"
		2552	fi
		2553	if [[ "$1" == *.py ]]; then
		2554	evaluated_files+=("$1")
		2555	else
		2556	evaluated_dirs+=("$1")
		2557	fi
		2558	else
		2559	if [[ -d "${root}$1" ]]; then
		2560	other_dirs+=("${root}$1")
		2561	elif [[ -f "${root}$1" ]]; then
		2562	other_files+=("${root}$1")
		2563	elif [[ -e "${root}$1" ]]; then
		2564	eerror "${FUNCNAME}(): '${root}$1' is not a regular file or a directory"
		2565	else
		2566	eerror "${FUNCNAME}(): '${root}$1' does not exist"
		2567	fi
		2568	fi
		2569	else
		2570	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do
		2571	if [[ -d "${root}$(python_get_sitedir)/$1" ]]; then
		2572	site_packages_dirs+=("$1")
		2573	break
		2574	elif [[ -f "${root}$(python_get_sitedir)/$1" ]]; then
		2575	site_packages_files+=("$1")
		2576	break
		2577	elif [[ -e "${root}$(python_get_sitedir)/$1" ]]; then
		2578	eerror "${FUNCNAME}(): '$1' is not a regular file or a directory"
		2579	else
		2580	eerror "${FUNCNAME}(): '$1' does not exist"
		2581	fi
		2582	done
		2583	fi
		2584	shift
		2585	done
		2586
735	# Set additional options.	2587	# Set additional options.
736	options+=("-q")	2588	options+=("-q")
737		2589
738	for PYTHON_ABI in ${PYTHON_ABIS}; do	2590	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do
739	if ((${#site_packages_dirs[@]})) \|\| ((${#site_packages_files[@]})); then	2591	if ((${#site_packages_dirs[@]})) \|\| ((${#site_packages_files[@]})) \|\| ((${#evaluated_dirs[@]})) \|\| ((${#evaluated_files[@]})); then
740	return_code="0"	2592	return_code="0"
741	ebegin "Compilation and optimization of Python modules for Python ${PYTHON_ABI}"	2593	ebegin "Compilation and optimization of Python modules for $(python_get_implementation) $(python_get_version)"
742	if ((${#site_packages_dirs[@]})); then	2594	if ((${#site_packages_dirs[@]})) \|\| ((${#evaluated_dirs[@]})); then
743	for dir in "${site_packages_dirs[@]}"; do	2595	for dir in "${site_packages_dirs[@]}"; do
744	site_packages_absolute_dirs+=("${root}$(python_get_sitedir)/${dir}")	2596	dirs+=("${root}$(python_get_sitedir)/${dir}")
745	done	2597	done
		2598	for dir in "${evaluated_dirs[@]}"; do
		2599	eval "dirs+=(\"\${root}${dir}\")"
		2600	done
746	"$(PYTHON)" "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${site_packages_absolute_dirs[@]}" \|\| return_code="1"	2601	"$(PYTHON)" "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${dirs[@]}" \|\| return_code="1"
		2602	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" != "Jython" ]]; then
747	"$(PYTHON)" -O "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${site_packages_absolute_dirs[@]}" &> /dev/null \|\| return_code="1"	2603	"$(PYTHON)" -O "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${dirs[@]}" &> /dev/null \|\| return_code="1"
748	fi	2604	fi
749	if ((${#site_packages_files[@]})); then	2605	_python_clean_compiled_modules "${dirs[@]}"
		2606	fi
		2607	if ((${#site_packages_files[@]})) \|\| ((${#evaluated_files[@]})); then
750	for file in "${site_packages_files[@]}"; do	2608	for file in "${site_packages_files[@]}"; do
751	site_packages_absolute_files+=("${root}$(python_get_sitedir)/${file}")	2609	files+=("${root}$(python_get_sitedir)/${file}")
752	done	2610	done
		2611	for file in "${evaluated_files[@]}"; do
		2612	eval "files+=(\"\${root}${file}\")"
		2613	done
753	"$(PYTHON)" "${root}$(python_get_libdir)/py_compile.py" "${site_packages_absolute_files[@]}" \|\| return_code="1"	2614	"$(PYTHON)" "${root}$(python_get_libdir)/py_compile.py" "${files[@]}" \|\| return_code="1"
		2615	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" != "Jython" ]]; then
754	"$(PYTHON)" -O "${root}$(python_get_libdir)/py_compile.py" "${site_packages_absolute_files[@]}" &> /dev/null \|\| return_code="1"	2616	"$(PYTHON)" -O "${root}$(python_get_libdir)/py_compile.py" "${files[@]}" &> /dev/null \|\| return_code="1"
		2617	fi
		2618	_python_clean_compiled_modules "${files[@]}"
755	fi	2619	fi
756	eend "${return_code}"	2620	eend "${return_code}"
757	fi	2621	fi
758	unset site_packages_absolute_dirs site_packages_absolute_files	2622	unset dirs files
759	done	2623	done
760		2624
761	# Don't use PYTHON_ABI in next calls to python_get_libdir().	2625	if _python_package_supporting_installation_for_multiple_python_abis; then
		2626	# Restore previous value of PYTHON_ABI.
		2627	if [[ -n "${previous_PYTHON_ABI}" ]]; then
		2628	PYTHON_ABI="${previous_PYTHON_ABI}"
		2629	else
762	unset PYTHON_ABI	2630	unset PYTHON_ABI
		2631	fi
		2632	fi
763		2633
764	if ((${#other_dirs[@]})) \|\| ((${#other_files[@]})); then	2634	if ((${#other_dirs[@]})) \|\| ((${#other_files[@]})); then
765	return_code="0"	2635	return_code="0"
766	ebegin "Compilation and optimization of Python modules placed outside of site-packages directories for Python ${PYVER}..."	2636	ebegin "Compilation and optimization of Python modules placed outside of site-packages directories for $(python_get_implementation) $(python_get_version)"
767	if ((${#other_dirs[@]})); then	2637	if ((${#other_dirs[@]})); then
768	python${PYVER} "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${other_dirs[@]}" \|\| return_code="1"	2638	"$(PYTHON ${PYTHON_ABI})" "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${other_dirs[@]}" \|\| return_code="1"
		2639	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" != "Jython" ]]; then
769	python${PYVER} -O "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${other_dirs[@]}" &> /dev/null \|\| return_code="1"	2640	"$(PYTHON ${PYTHON_ABI})" -O "${root}$(python_get_libdir)/compileall.py" "${options[@]}" "${other_dirs[@]}" &> /dev/null \|\| return_code="1"
		2641	fi
		2642	_python_clean_compiled_modules "${other_dirs[@]}"
770	fi	2643	fi
771	if ((${#other_files[@]})); then	2644	if ((${#other_files[@]})); then
772	python${PYVER} "${root}$(python_get_libdir)/py_compile.py" "${other_files[@]}" \|\| return_code="1"	2645	"$(PYTHON ${PYTHON_ABI})" "${root}$(python_get_libdir)/py_compile.py" "${other_files[@]}" \|\| return_code="1"
		2646	if [[ "$(_python_get_implementation "${PYTHON_ABI}")" != "Jython" ]]; then
773	python${PYVER} -O "${root}$(python_get_libdir)/py_compile.py" "${other_files[@]}" &> /dev/null \|\| return_code="1"	2647	"$(PYTHON ${PYTHON_ABI})" -O "${root}$(python_get_libdir)/py_compile.py" "${other_files[@]}" &> /dev/null \|\| return_code="1"
		2648	fi
		2649	_python_clean_compiled_modules "${other_files[@]}"
774	fi	2650	fi
775	eend "${return_code}"	2651	eend "${return_code}"
776	fi	2652	fi
777	else	2653	else
		2654	# Deprecated part of python_mod_optimize()
		2655	# ewarn
		2656	# ewarn "Deprecation Warning: Usage of ${FUNCNAME}() in packages not supporting installation"
		2657	# ewarn "for multiple Python ABIs in EAPI <=2 is deprecated and will be disallowed on 2011-06-01."
		2658	# ewarn "Use EAPI >=3 and call ${FUNCNAME}() with paths having appropriate syntax."
		2659	# ewarn "The ebuild needs to be fixed. Please report a bug, if it has not been already reported."
		2660	# ewarn
		2661
778	local myroot mydirs=() myfiles=() myopts=() return_code="0"	2662	local myroot mydirs=() myfiles=() myopts=() return_code="0"
779		2663
780	# strip trailing slash	2664	# strip trailing slash
781	myroot="${ROOT%/}"	2665	myroot="${EROOT%/}"
782		2666
783	# respect ROOT and options passed to compileall.py	2667	# respect EROOT and options passed to compileall.py
784	while (($#)); do	2668	while (($#)); do
785	case "$1" in	2669	case "$1" in
786	-l\|-f\|-q)	2670	-l\|-f\|-q)
787	myopts+=("$1")	2671	myopts+=("$1")
788	;;	2672	;;
789	-d\|-x)	2673	-d\|-x)
790	myopts+=("$1" "$2")	2674	myopts+=("$1" "$2")
791	shift	2675	shift
792	;;	2676	;;
		2677	--)
		2678	shift
		2679	break
		2680	;;
793	-*)	2681	-*)
794	ewarn "${FUNCNAME}: Ignoring compile option $1"	2682	die "${FUNCNAME}(): Unrecognized option '$1'"
795	;;	2683	;;
796	*)	2684	*)
797	if [[ -d "${myroot}"/$1 ]]; then	2685	break
798	mydirs+=("${myroot}/$1")
799	elif [[ -f "${myroot}"/$1 ]]; then
800	# Files are passed to python_mod_compile which is ROOT-aware
801	myfiles+=("$1")
802	elif [[ -e "${myroot}/$1" ]]; then
803	ewarn "${myroot}/$1 is not a file or directory!"
804	else
805	ewarn "${myroot}/$1 doesn't exist!"
806	fi
807	;;	2686	;;
808	esac	2687	esac
809	shift	2688	shift
810	done	2689	done
811		2690
812	# allow compiling for older python versions	2691	if [[ "$#" -eq 0 ]]; then
813	if [ -n "${PYTHON_OVERRIDE_PYVER}" ]; then	2692	die "${FUNCNAME}(): Missing files or directories"
814	PYVER=${PYTHON_OVERRIDE_PYVER}	2693	fi
		2694
		2695	while (($#)); do
		2696	if [[ "$1" =~ ^($\|(\.\|\.\.\|/)($\|/)) ]]; then
		2697	die "${FUNCNAME}(): Invalid argument '$1'"
		2698	elif [[ -d "${myroot}/${1#/}" ]]; then
		2699	mydirs+=("${myroot}/${1#/}")
		2700	elif [[ -f "${myroot}/${1#/}" ]]; then
		2701	myfiles+=("${myroot}/${1#/}")
		2702	elif [[ -e "${myroot}/${1#/}" ]]; then
		2703	eerror "${FUNCNAME}(): ${myroot}/${1#/} is not a regular file or directory"
815	else	2704	else
816	python_version	2705	eerror "${FUNCNAME}(): ${myroot}/${1#/} does not exist"
817	fi	2706	fi
		2707	shift
		2708	done
818		2709
819	# set additional opts	2710	# set additional opts
820	myopts+=(-q)	2711	myopts+=(-q)
821		2712
822	ebegin "Byte compiling python modules for python-${PYVER} .."	2713	PYTHON_ABI="${PYTHON_ABI:-$(PYTHON --ABI)}"
		2714
		2715	ebegin "Compilation and optimization of Python modules for $(python_get_implementation) $(python_get_version)"
823	if ((${#mydirs[@]})); then	2716	if ((${#mydirs[@]})); then
824	python${PYVER} \	2717	"$(PYTHON ${PYTHON_ABI})" "${myroot}$(python_get_libdir)/compileall.py" "${myopts[@]}" "${mydirs[@]}" \|\| return_code="1"
825	"${myroot}"/usr/$(get_libdir)/python${PYVER}/compileall.py \	2718	"$(PYTHON ${PYTHON_ABI})" -O "${myroot}$(python_get_libdir)/compileall.py" "${myopts[@]}" "${mydirs[@]}" &> /dev/null \|\| return_code="1"
826	"${myopts[@]}" "${mydirs[@]}" \|\| return_code="1"	2719	_python_clean_compiled_modules "${mydirs[@]}"
827	python${PYVER} -O \
828	"${myroot}"/usr/$(get_libdir)/python${PYVER}/compileall.py \
829	"${myopts[@]}" "${mydirs[@]}" &> /dev/null \|\| return_code="1"
830	fi	2720	fi
831		2721
832	if ((${#myfiles[@]})); then	2722	if ((${#myfiles[@]})); then
		2723	"$(PYTHON ${PYTHON_ABI})" "${myroot}$(python_get_libdir)/py_compile.py" "${myfiles[@]}" \|\| return_code="1"
		2724	"$(PYTHON ${PYTHON_ABI})" -O "${myroot}$(python_get_libdir)/py_compile.py" "${myfiles[@]}" &> /dev/null \|\| return_code="1"
833	python_mod_compile "${myfiles[@]}"	2725	_python_clean_compiled_modules "${myfiles[@]}"
834	fi	2726	fi
835		2727
836	eend "${return_code}"	2728	eend "${return_code}"
837	fi	2729	fi
838	}	2730	}
839		2731
840	# @FUNCTION: python_mod_cleanup	2732	# @FUNCTION: python_mod_cleanup
841	# @USAGE: [directory]	2733	# @USAGE: [--allow-evaluated-non-sitedir-paths] [--] <file\|directory> [files\|directories]
842	# @DESCRIPTION:	2734	# @DESCRIPTION:
843	# Run with optional arguments, where arguments are directories of	2735	# Delete orphaned byte-compiled Python modules corresponding to specified Python modules.
844	# python modules. If none given, it will look in /usr/lib/python[0-9].[0-9].
845	#	2736	#
846	# It will recursively scan all compiled Python modules in the directories and
847	# determine if they are orphaned (i.e. their corresponding .py files are missing.)
848	# If they are, then it will remove their corresponding .pyc and .pyo files.
849	#
850	# This function should only be run in pkg_postrm().	2737	# This function can be used only in pkg_postrm() phase.
851	python_mod_cleanup() {	2738	python_mod_cleanup() {
852	local PYTHON_ABI SEARCH_PATH=() root src_py	2739	_python_check_python_pkg_setup_execution
		2740	_python_initialize_prefix_variables
		2741
		2742	local allow_evaluated_non_sitedir_paths="0" dir iterated_PYTHON_ABIS PYTHON_ABI="${PYTHON_ABI}" root search_paths=() sitedir
853		2743
854	# Check if phase is pkg_postrm().	2744	# Check if phase is pkg_postrm().
855	[[ ${EBUILD_PHASE} != "postrm" ]] && die "${FUNCNAME} should only be run in pkg_postrm()"	2745	[[ "${EBUILD_PHASE}" != "postrm" ]] && die "${FUNCNAME}() can be used only in pkg_postrm() phase"
856		2746
		2747	if _python_package_supporting_installation_for_multiple_python_abis; then
		2748	if has "${EAPI:-0}" 0 1 2 3 && [[ -z "${PYTHON_ABIS}" ]]; then
		2749	die "${FUNCNAME}(): python_pkg_setup() or python_execute_function() not called"
		2750	fi
		2751	iterated_PYTHON_ABIS="${PYTHON_ABIS}"
		2752	else
		2753	if has "${EAPI:-0}" 0 1 2 3; then
		2754	iterated_PYTHON_ABIS="${PYTHON_ABI:-$(PYTHON --ABI)}"
		2755	else
		2756	iterated_PYTHON_ABIS="${PYTHON_ABI}"
		2757	fi
		2758	fi
		2759
857	# Strip trailing slash from ROOT.	2760	# Strip trailing slash from EROOT.
858	root="${ROOT%/}"	2761	root="${EROOT%/}"
859		2762
860	if (($#)); then	2763	while (($#)); do
861	if ! has "${EAPI:-0}" 0 1 2 \|\| [[ -n "${SUPPORT_PYTHON_ABIS}" ]]; then	2764	case "$1" in
		2765	--allow-evaluated-non-sitedir-paths)
		2766	allow_evaluated_non_sitedir_paths="1"
		2767	;;
		2768	--)
		2769	shift
		2770	break
		2771	;;
		2772	-*)
		2773	die "${FUNCNAME}(): Unrecognized option '$1'"
		2774	;;
		2775	*)
		2776	break
		2777	;;
		2778	esac
		2779	shift
		2780	done
		2781
		2782	if [[ "${allow_evaluated_non_sitedir_paths}" == "1" ]] && ! _python_package_supporting_installation_for_multiple_python_abis; then
		2783	die "${FUNCNAME}(): '--allow-evaluated-non-sitedir-paths' option cannot be used in ebuilds of packages not supporting installation for multiple Python ABIs"
		2784	fi
		2785
		2786	if [[ "$#" -eq 0 ]]; then
		2787	die "${FUNCNAME}(): Missing files or directories"
		2788	fi
		2789
		2790	if ! has "${EAPI:-0}" 0 1 2 \|\| _python_package_supporting_installation_for_multiple_python_abis \|\| _python_implementation \|\| [[ "${CATEGORY}/${PN}" == "sys-apps/portage" ]]; then
862	while (($#)); do	2791	while (($#)); do
		2792	if [[ "$1" =~ ^($\|(\.\|\.\.\|/)($\|/)) ]]; then
		2793	die "${FUNCNAME}(): Invalid argument '$1'"
863	if [[ "$1" =~ ^/usr/lib(32\|64)?/python[[:digit:]]+\.[[:digit:]]+ ]]; then	2794	elif ! _python_implementation && [[ "$1" =~ ^/usr/lib(32\|64)?/python[[:digit:]]+\.[[:digit:]]+ ]]; then
864	die "${FUNCNAME} doesn't support absolute paths of directories/files in site-packages directories"	2795	die "${FUNCNAME}(): Paths of directories / files in site-packages directories must be relative to site-packages directories"
865	elif [[ "$1" =~ ^/ ]]; then	2796	elif [[ "$1" =~ ^/ ]]; then
866	SEARCH_PATH+=("${root}/${1#/}")	2797	if _python_package_supporting_installation_for_multiple_python_abis; then
		2798	if [[ "${allow_evaluated_non_sitedir_paths}" != "1" ]]; then
		2799	die "${FUNCNAME}(): Absolute paths cannot be used in ebuilds of packages supporting installation for multiple Python ABIs"
		2800	fi
		2801	if [[ "$1" != \$ ]]; then
		2802	die "${FUNCNAME}(): '$1' has invalid syntax"
		2803	fi
		2804	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do
		2805	eval "search_paths+=(\"\${root}$1\")"
		2806	done
867	else	2807	else
		2808	search_paths+=("${root}$1")
		2809	fi
		2810	else
868	for PYTHON_ABI in ${PYTHON_ABIS}; do	2811	for PYTHON_ABI in ${iterated_PYTHON_ABIS}; do
869	SEARCH_PATH+=("${root}$(python_get_sitedir)/$1")	2812	search_paths+=("${root}$(python_get_sitedir)/$1")
870	done	2813	done
871	fi	2814	fi
872	shift	2815	shift
873	done
874	else
875	SEARCH_PATH=("${@#/}")
876	SEARCH_PATH=("${SEARCH_PATH[@]/#/${root}/}")
877	fi
878	else
879	SEARCH_PATH=("${root}"/usr/lib/python/site-packages)
880	fi
881
882	for path in "${SEARCH_PATH[@]}"; do
883	[[ ! -d "${path}" ]] && continue
884	einfo "Cleaning orphaned Python bytecode from ${path} .."
885	find "${path}" -name '*.py[co]' -print0 \| while read -rd ''; do
886	src_py="${REPLY%[co]}"
887	[[ -f "${src_py}" \|\| (! -f "${src_py}c" && ! -f "${src_py}o") ]] && continue
888	einfo "Purging ${src_py}[co]"
889	rm -f "${src_py}"[co]
890	done	2816	done
		2817	else
		2818	# Deprecated part of python_mod_cleanup()
		2819	# ewarn
		2820	# ewarn "Deprecation Warning: Usage of ${FUNCNAME}() in packages not supporting installation"
		2821	# ewarn "for multiple Python ABIs in EAPI <=2 is deprecated and will be disallowed on 2011-06-01."
		2822	# ewarn "Use EAPI >=3 and call ${FUNCNAME}() with paths having appropriate syntax."
		2823	# ewarn "The ebuild needs to be fixed. Please report a bug, if it has not been already reported."
		2824	# ewarn
891		2825
892	# Attempt to remove directories that may be empty.	2826	search_paths=("${@#/}")
893	find "${path}" -type d \| sort -r \| while read -r dir; do	2827	search_paths=("${search_paths[@]/#/${root}/}")
894	rmdir "${dir}" 2>/dev/null && einfo "Removing empty directory ${dir}"	2828	fi
895	done	2829
896	done	2830	_python_clean_compiled_modules "${search_paths[@]}"
897	}	2831	}
		2832
		2833	# ================================================================================================
		2834	# ===================================== DEPRECATED FUNCTIONS =====================================
		2835	# ================================================================================================
		2836
		2837	# Scheduled for deletion on 2011-01-01.
		2838	python_version() {
		2839	eerror "Use PYTHON() instead of python variable. Use python_get_() instead of PYVER variables."
		2840	die "${FUNCNAME}() is banned"
		2841	}
		2842
		2843	# Scheduled for deletion on 2011-01-01.
		2844	python_mod_exists() {
		2845	eerror "Use USE dependencies and/or has_version() instead of ${FUNCNAME}()."
		2846	die "${FUNCNAME}() is banned"
		2847	}
		2848
		2849	# Scheduled for deletion on 2011-01-01.
		2850	python_tkinter_exists() {
		2851	eerror "Use PYTHON_USE_WITH=\"xml\" and python_pkg_setup() instead of ${FUNCNAME}()."
		2852	die "${FUNCNAME}() is banned"
		2853	}
		2854
		2855	# Scheduled for deletion on 2011-04-01.
		2856	python_mod_compile() {
		2857	eerror "Use python_mod_optimize() instead of ${FUNCNAME}()."
		2858	die "${FUNCNAME}() is banned"
		2859	}

 Legend:



Removed from v.1.72
 


changed lines


 
Added in v.1.110
 Legend:



Removed from v.1.72
 


changed lines


 
Added in v.1.110
-Removed from v.1.72
+Added in v.1.110

	ViewVC Help
Powered by ViewVC 1.1.13