Attachment #204572 for bug #276813

View | Details | Raw Unified | Return to bug 276813 | Differences between

and this patch




import re
from itertools import chain
import portage
from portage.cache.mappings import slot_dict_class
from portage.dep import paren_reduce, use_reduce, \
	paren_normalize, paren_enclose
from _emerge.Task import Task

	if not x.startswith("UNUSED_"))
_all_metadata_keys.discard("CDEPEND")
_all_metadata_keys.update(Package.metadata_keys)
_all_metadata_keys = frozenset(_all_metadata_keys)

class _PackageMetadataWrapper(dict):

class _PackageMetadataWrapper(_PackageMetadataWrapperBase):
	"""
	Detect metadata updates and synchronize Package attributes.
	"""

	__slots__ = ("_pkg",)
	_wrapped_keys = frozenset(
		["COUNTER", "INHERITED", "IUSE", "SLOT", "_mtime_"])
	_use_conditional_keys = frozenset(
		['LICENSE', 'PROPERTIES', 'PROVIDE', 'RESTRICT',])

	def __init__(self, pkg, metadata):
		_PackageMetadataWrapperBase.__init__(self)
		self._pkg = pkg
		"""LICENSE with USE conditionals evaluated."""

		if not pkg.built:
			# USE is lazy, but we want it to show up in self.keys().
			self['USE'] = ''

		self.update(metadata)
		assert _all_metadata_keys.issuperset(self.keys())
		for k, v in self.iteritems():
			if k == 'INHERITED':
				if isinstance(v, basestring):
					v = frozenset(v.split())
				self._pkg.inherited = v
			elif k == 'SLOT':
				self._pkg.slot = v
			elif k == 'IUSE':
				self._pkg.iuse = self._pkg._iuse(
					v.split(), self._pkg.root_config.iuse_implicit)
			elif k == 'COUNTER':
				if isinstance(v, basestring):
					try:
						v = long(v.strip())
					except ValueError:
						v = 0
				self._pkg.counter = v
			elif k == '_mtime_':
				if isinstance(v, basestring):
					try:
						v = long(v.strip())
					except ValueError:
						v = 0
				self._pkg.mtime = v
			elif k in self._use_conditional_keys:
				try:
					use_reduce(paren_reduce(v), matchall=1)
				except portage.exception.InvalidDependString, e:
					self._pkg._invalid_metadata(k + ".syntax", "%s: %s" % (k, e))

	def __getitem__(self, k):
		v = dict.__getitem__(self, k)
		if k in self._use_conditional_keys:
			if self._pkg.root_config.settings.local_config and '?' in v:
				try:


		return v

	def __setitem__(self, k, v):
		_PackageMetadataWrapperBase.__setitem__(self, k, v)
		if k in self._wrapped_keys:
			getattr(self, "_set_" + k.lower())(k, v)
		elif k in self._use_conditional_keys:
			try:
				use_reduce(paren_reduce(v), matchall=1)
			except portage.exception.InvalidDependString, e:
				self._pkg._invalid_metadata(k + ".syntax", "%s: %s" % (k, e))

	def _set_inherited(self, k, v):
		if isinstance(v, basestring):
			v = frozenset(v.split())
		self._pkg.inherited = v

	def _set_iuse(self, k, v):
		self._pkg.iuse = self._pkg._iuse(
			v.split(), self._pkg.root_config.iuse_implicit)

	def _set_slot(self, k, v):
		self._pkg.slot = v

	def _set_counter(self, k, v):
		if isinstance(v, basestring):
			try:
				v = long(v.strip())
			except ValueError:
				v = 0
		self._pkg.counter = v

	def _set__mtime_(self, k, v):
		if isinstance(v, basestring):
			try:
				v = long(v.strip())
			except ValueError:
				v = 0
		self._pkg.mtime = v

	@property
	def properties(self):
		return self['PROPERTIES'].split()

Return to bug 276813

Lines 5-11 Link Here

(-)a/pym/_emerge/Package.py (-49 / +33 lines)
5	import re	5	import re
6	from itertools import chain	6	from itertools import chain
7	import portage	7	import portage
8	from portage.cache.mappings import slot_dict_class
9	from portage.dep import paren_reduce, use_reduce, \	8	from portage.dep import paren_reduce, use_reduce, \
10	paren_normalize, paren_enclose	9	paren_normalize, paren_enclose
11	from _emerge.Task import Task	10	from _emerge.Task import Task
Lines 151-183 _all_metadata_keys = set(x for x in portage.auxdbkeys \ Link Here
151	if not x.startswith("UNUSED_"))	150	if not x.startswith("UNUSED_"))
152	_all_metadata_keys.discard("CDEPEND")	151	_all_metadata_keys.discard("CDEPEND")
153	_all_metadata_keys.update(Package.metadata_keys)	152	_all_metadata_keys.update(Package.metadata_keys)
		153	_all_metadata_keys = frozenset(_all_metadata_keys)
154		154
155	_PackageMetadataWrapperBase = slot_dict_class(_all_metadata_keys)	155	class _PackageMetadataWrapper(dict):
156
157	class _PackageMetadataWrapper(_PackageMetadataWrapperBase):
158	"""	156	"""
159	Detect metadata updates and synchronize Package attributes.	157	Detect metadata updates and synchronize Package attributes.
160	"""	158	"""
161		159
162	__slots__ = ("_pkg",)	160	__slots__ = ("_pkg",)
163	_wrapped_keys = frozenset(
164	["COUNTER", "INHERITED", "IUSE", "SLOT", "_mtime_"])
165	_use_conditional_keys = frozenset(	161	_use_conditional_keys = frozenset(
166	['LICENSE', 'PROPERTIES', 'PROVIDE', 'RESTRICT',])	162	['LICENSE', 'PROPERTIES', 'PROVIDE', 'RESTRICT',])
167		163
168	def __init__(self, pkg, metadata):	164	def __init__(self, pkg, metadata):
169	_PackageMetadataWrapperBase.__init__(self)
170	self._pkg = pkg	165	self._pkg = pkg
171	"""LICENSE with USE conditionals evaluated."""
172
173	if not pkg.built:	166	if not pkg.built:
174	# USE is lazy, but we want it to show up in self.keys().	167	# USE is lazy, but we want it to show up in self.keys().
175	self['USE'] = ''	168	self['USE'] = ''
176
177	self.update(metadata)	169	self.update(metadata)
		170	assert _all_metadata_keys.issuperset(self.keys())
		171	for k, v in self.iteritems():
		172	if k == 'INHERITED':
		173	if isinstance(v, basestring):
		174	v = frozenset(v.split())
		175	self._pkg.inherited = v
		176	elif k == 'SLOT':
		177	self._pkg.slot = v
		178	elif k == 'IUSE':
		179	self._pkg.iuse = self._pkg._iuse(
		180	v.split(), self._pkg.root_config.iuse_implicit)
		181	elif k == 'COUNTER':
		182	if isinstance(v, basestring):
		183	try:
		184	v = long(v.strip())
		185	except ValueError:
		186	v = 0
		187	self._pkg.counter = v
		188	elif k == '_mtime_':
		189	if isinstance(v, basestring):
		190	try:
		191	v = long(v.strip())
		192	except ValueError:
		193	v = 0
		194	self._pkg.mtime = v
		195	elif k in self._use_conditional_keys:
		196	try:
		197	use_reduce(paren_reduce(v), matchall=1)
		198	except portage.exception.InvalidDependString, e:
		199	self._pkg._invalid_metadata(k + ".syntax", "%s: %s" % (k, e))
178		200
179	def __getitem__(self, k):	201	def __getitem__(self, k):
180	v = _PackageMetadataWrapperBase.__getitem__(self, k)	202	v = dict.__getitem__(self, k)
181	if k in self._use_conditional_keys:	203	if k in self._use_conditional_keys:
182	if self._pkg.root_config.settings.local_config and '?' in v:	204	if self._pkg.root_config.settings.local_config and '?' in v:
183	try:	205	try:
Lines 201-244 class _PackageMetadataWrapper(_PackageMetadataWrapperBase): Link Here
201		223
202	return v	224	return v
203		225
204	def __setitem__(self, k, v):
205	_PackageMetadataWrapperBase.__setitem__(self, k, v)
206	if k in self._wrapped_keys:
207	getattr(self, "_set_" + k.lower())(k, v)
208	elif k in self._use_conditional_keys:
209	try:
210	use_reduce(paren_reduce(v), matchall=1)
211	except portage.exception.InvalidDependString, e:
212	self._pkg._invalid_metadata(k + ".syntax", "%s: %s" % (k, e))
213
214	def _set_inherited(self, k, v):
215	if isinstance(v, basestring):
216	v = frozenset(v.split())
217	self._pkg.inherited = v
218
219	def _set_iuse(self, k, v):
220	self._pkg.iuse = self._pkg._iuse(
221	v.split(), self._pkg.root_config.iuse_implicit)
222
223	def _set_slot(self, k, v):
224	self._pkg.slot = v
225
226	def _set_counter(self, k, v):
227	if isinstance(v, basestring):
228	try:
229	v = long(v.strip())
230	except ValueError:
231	v = 0
232	self._pkg.counter = v
233
234	def _set__mtime_(self, k, v):
235	if isinstance(v, basestring):
236	try:
237	v = long(v.strip())
238	except ValueError:
239	v = 0
240	self._pkg.mtime = v
241
242	@property	226	@property
243	def properties(self):	227	def properties(self):
244	return self['PROPERTIES'].split()	228	return self['PROPERTIES'].split()