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

Diff of /eclass/python.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.84
 


changed lines


 
Added in v.1.154
 Legend:



Removed from v.1.84
 


changed lines


 
Added in v.1.154
-Removed from v.1.84
+Added in v.1.154

	ViewVC Help
Powered by ViewVC 1.1.13