[gentoo-commits] proj/gentoopm:master commit in: gentoopm/portagepm/, gentoopm/pkgcorepm/, gentoopm/paludispm/, gentoopm/basepm/

[Michał Górny]

commit:     195ba334eec316454996d4e8552afaeb0de1dd4d
Author:     Michał Górny <mgorny <AT> gentoo <DOT> org>
AuthorDate: Wed Jul  6 15:29:51 2011 +0000
Commit:     Michał Górny <mgorny <AT> gentoo <DOT> org>
CommitDate: Wed Jul  6 15:29:51 2011 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=proj/gentoopm.git;a=commit;h=195ba334

Get rid of structured tree, just use flat interface.

---
 gentoopm/basepm/pkg.py         |  154 +++-------------------------------------
 gentoopm/basepm/repo.py        |   19 +----
 gentoopm/basepm/stack.py       |   76 ++------------------
 gentoopm/paludispm/pkg.py      |   42 +----------
 gentoopm/paludispm/repo.py     |   31 +++-----
 gentoopm/pkgcorepm/pkg.py      |   50 +------------
 gentoopm/pkgcorepm/repo.py     |   16 +----
 gentoopm/portagepm/__init__.py |    2 +-
 gentoopm/portagepm/db.py       |   64 +++++++----------
 gentoopm/portagepm/pkg.py      |   57 ++-------------
 gentoopm/portagepm/repo.py     |   13 ++--
 11 files changed, 81 insertions(+), 443 deletions(-)

diff --git a/gentoopm/basepm/pkg.py b/gentoopm/basepm/pkg.py
index 9b2a796..39514cd 100644
--- a/gentoopm/basepm/pkg.py
+++ b/gentoopm/basepm/pkg.py
@@ -3,58 +3,10 @@
 # (c) 2011 Michał Górny <mgorny@g.o>
 # Released under the terms of the 2-clause BSD license.
 
-import collections
 from abc import abstractmethod, abstractproperty
 
 from gentoopm.util import ABCObject
 
-class PMKeyedPackageBase(ABCObject):
-	"""
-	Base class for key-identified package sets.
-	"""
-
-	def __init__(self, key, parent):
-		self._key_ = key
-		self._parent_ = parent
-
-	@property
-	def _parent(self):
-		"""
-		A parent (higher level) PMKeyedPackageDict or None if top-level.
-		"""
-		return self._parent_
-
-	@property
-	def _key(self):
-		"""
-		The key for this level of PMKeyedPackageDict.
-		"""
-		return self._key_
-
-	@abstractproperty
-	def _key_name(self):
-		"""
-		The metadata key name for this key.
-		"""
-		pass
-
-	@property
-	def key(self):
-		"""
-		The set of keys uniquely identifying the package set (i.e. the parent
-		keys and this one).
-		"""
-		key_names = []
-		keys = []
-		o = self
-		while o and o._key is not None:
-			keys.insert(0, o._key)
-			key_names.insert(0, o._key_name)
-			o = o._parent
-		t = collections.namedtuple('%sKeyTuple' % self.__class__.__name__,
-				' '.join(key_names))
-		return t(*keys)
-
 class PMPackageSet(ABCObject):
 	@abstractmethod
 	def __iter__(self):
@@ -63,13 +15,6 @@ class PMPackageSet(ABCObject):
 		"""
 		pass
 
-	@property
-	def flattened(self):
-		"""
-		Flatten the package set and iterate over it. Yield PMPackages.
-		"""
-		return PMFlattenedPackageSet(iter(self))
-
 	def filter(self, *args, **kwargs):
 		"""
 		Filter the packages based on keys passed as arguments. Positional
@@ -89,32 +34,7 @@ class PMPackageSet(ABCObject):
 		can provide a class with __eq__() redefined as an argument.
 		"""
 
-		myargs = collections.defaultdict(lambda: None, enumerate(args))
-		mykwargs = collections.defaultdict(lambda: None, **kwargs)
-
-		i = 0
-		try:
-			el = next(iter(self))
-		except StopIteration:
-			return PMFilteredPackageSet((), None, None, None)
-		else:
-			k = el._key_name
-			if myargs[i] is not None:
-				if mykwargs[k] is not None:
-					raise TypeError('args[%d] and kwargs[%s] refer to the same key.' % \
-							(i, k))
-				m = myargs[i]
-			else:
-				m = mykwargs[k]
-
-			newargs = args[1:]
-			newkwargs = kwargs.copy()
-			try:
-				del newkwargs[k]
-			except KeyError:
-				pass
-
-			return PMFilteredPackageSet(iter(self), m, newargs, newkwargs)
+		return PMFilteredPackageSet(iter(self), args, kwargs)
 
 	@property
 	def best(self):
@@ -123,7 +43,7 @@ class PMPackageSet(ABCObject):
 		the results and return the first one).
 		"""
 		try:
-			return sorted(self.flattened, reverse = True)[0]
+			return sorted(self, reverse = True)[0]
 		except IndexError:
 			raise TypeError('.best called on an empty set')
 		except TypeError:
@@ -143,76 +63,23 @@ class PMPackageSet(ABCObject):
 			raise ValueError('Ambiguous filter (matches more than a single package name).')
 
 class PMFilteredPackageSet(PMPackageSet):
-	def __init__(self, it, key, newargs, newkwargs):
+	def __init__(self, it, args, kwargs):
 		self._iter = it
-		self._key = key
-		self._newargs = newargs
-		self._newkwargs = newkwargs
+		self._args = args
+		self._kwargs = kwargs
 
 	def __iter__(self):
 		for el in self._iter:
-			if self._key is None or self._key == el._key:
-				if self._newargs or self._newkwargs:
-					for i in el.filter(*self._newargs, **self._newkwargs):
-						yield i
-				else:
-					yield el
-
-class PMFlattenedPackageSet(PMPackageSet):
-	def __init__(self, it):
-		self._iter = it
-	
-	def __iter__(self):
-		for i in self._iter:
-			if isinstance(i, PMKeyedPackageDict):
-				for hi in i.flattened:
-					yield hi
-			else:
-				yield i
-
-class PMKeyedPackageDict(PMKeyedPackageBase, PMPackageSet):
-	"""
-	A dict-like object representing a set of packages matched by a N-level key.
-	If it's a last-level key, the dict evaluates to PMPackage subclass
-	instances. Otherwise, it evaluates to lower-level PMKeyedPackageDicts.
+			for x in el.filter(*self._args, **self._kwargs):
+				yield x
 
-	Usually, the highest level PMKeyedPackageDict is PMRepository. Then dicts
-	refer to the category, package name and finally version (where they
-	transform into PMPackages).
-	"""
-
-	@abstractmethod
-	def __iter__(self):
-		"""
-		Iterate over child PMKeyedPackageDicts or PMPackages when bottom-level.
-		"""
-		pass
-
-	def __getitem__(self, key):
-		"""
-		Get a sub-item matching the key.
-		"""
-		for i in self:
-			if i._key == key:
-				return i
-		else:
-			raise KeyError('No packages match keyset: (%s)' % \
-					', '.join(self.key + [key]))
-
-class PMPackage(PMKeyedPackageBase):
+class PMPackage(ABCObject):
 	"""
 	An abstract class representing a single, uniquely-keyed package
 	in the package tree.
 	"""
 
-	@property
-	def flattened(self):
-		"""
-		A convenience property. Returns the package itself, as an iterator.
-		"""
-		yield self
-
-	def filter(self, *args, **kwargs):
+	def filter(self, **kwargs):
 		"""
 		Filter packages on metadata. This is mostly to extend superclass
 		.filter() method.
@@ -222,9 +89,6 @@ class PMPackage(PMKeyedPackageBase):
 		returns an iterator -- either over the package itself or an empty one.
 		"""
 
-		if args:
-			raise IndexError('Unused positional arguments: %s' % args)
-
 		for k, m in kwargs.items():
 			try:
 				v = self.metadata[k]

diff --git a/gentoopm/basepm/repo.py b/gentoopm/basepm/repo.py
index 80ea4b7..5b1bac0 100644
--- a/gentoopm/basepm/repo.py
+++ b/gentoopm/basepm/repo.py
@@ -6,9 +6,10 @@
 import os.path
 from abc import abstractmethod, abstractproperty
 
-from gentoopm.basepm.pkg import PMKeyedPackageDict
+from gentoopm.basepm.pkg import PMPackageSet
+from gentoopm.util import ABCObject
 
-class PMRepositoryDict(PMKeyedPackageDict):
+class PMRepositoryDict(ABCObject):
 	"""
 	A dict-like object providing access to a set of repositories.
 
@@ -17,10 +18,6 @@ class PMRepositoryDict(PMKeyedPackageDict):
 	subclass.
 	"""
 
-	_key = None
-	_key_name = None
-	_parent = None
-
 	def __getitem__(self, key):
 		"""
 		Get the repository by its name or path. If using a path as a key,
@@ -48,23 +45,15 @@ class PMRepositoryDict(PMKeyedPackageDict):
 		"""
 		pass
 
-class PMRepository(PMKeyedPackageDict):
+class PMRepository(PMPackageSet):
 	"""
 	Base abstract class for a single repository.
 	"""
-	_key_name = None
-	_parent = None
-	_key = None
 
 class PMEbuildRepository(PMRepository):
 	"""
 	Base abstract class for an ebuild repository (on livefs).
 	"""
-	_key_name = 'REPOSITORY'
-
-	@property
-	def _key(self):
-		return self.name
 
 	@abstractproperty
 	def name(self):

diff --git a/gentoopm/basepm/stack.py b/gentoopm/basepm/stack.py
index 4febc07..ab13dd3 100644
--- a/gentoopm/basepm/stack.py
+++ b/gentoopm/basepm/stack.py
@@ -3,77 +3,13 @@
 # (c) 2011 Michał Górny <mgorny@g.o>
 # Released under the terms of the 2-clause BSD license.
 
-import collections
-
-from gentoopm.basepm.pkg import PMKeyedPackageDict, PMPackage
 from gentoopm.basepm.repo import PMRepository
 
-class PMPackageWrapper(PMPackage):
-	_key_name = 'REPOSITORY'
-
-	def __init__(self, wrapped, parent):
-		self._wrapped = wrapped
-		self._parent_ = parent
-
-	@property
-	def metadata(self):
-		return self._wrapped.metadata
-
-	@property
-	def _key(self):
-		return self._repo._key
-
-	@property
-	def _repo(self):
-		p = self._wrapped._parent
-		while p._key_name != 'REPOSITORY':
-			p = p._parent
-		return p
-
-	@property
-	def path(self):
-		return self._wrapped.path
-
-	def __cmp__(self, other):
-		r = cmp(self._wrapped, other._wrapped)
-		if r == 0:
-			return cmp(self._repo, other._repo)
-		return r
-
-class PMStackWrapper(PMKeyedPackageDict):
-	def __init__(self, wrapped, parent):
-		self._wrapped = wrapped
-		self._parent_ = parent
+class PMRepoStackWrapper(PMRepository):
+	def __init__(self, repos):
+		self._repos = repos
 
 	def __iter__(self):
-		keys = collections.defaultdict(list)
-		for r in self._wrapped:
-			if isinstance(r, PMPackage):
-				yield PMPackageWrapper(r, self)
-			else:
-				for wr in r:
-					keys[wr._key].append(wr)
-		for k, l in keys.items():
-			yield PMStackWrapper(l, self)
-
-	@property
-	def _key(self):
-		try:
-			return self._wrapped[0]._key
-		except IndexError:
-			return None
-
-	@property
-	def _key_name(self):
-		try:
-			return self._wrapped[0]._key_name
-		except IndexError:
-			return None
-
-class PMRepoStackWrapper(PMStackWrapper, PMRepository):
-	_key_name = None
-	_key = None
-	_parent = None
-
-	def __init__(self, repos):
-		self._wrapped = repos
+		for r in self._repos:
+			for p in r:
+				yield p

diff --git a/gentoopm/paludispm/pkg.py b/gentoopm/paludispm/pkg.py
index e83816f..c816f96 100644
--- a/gentoopm/paludispm/pkg.py
+++ b/gentoopm/paludispm/pkg.py
@@ -6,49 +6,11 @@
 import paludis
 
 from gentoopm.basepm.metadata import PMPackageMetadata
-from gentoopm.basepm.pkg import PMKeyedPackageDict, PMPackage
-from gentoopm.util import IterDictWrapper
-
-class PaludisCategory(PMKeyedPackageDict):
-	_key_name = 'CATEGORY'
-	def __init__(self, category, parent):
-		PMKeyedPackageDict.__init__(self, str(category), parent)
-
-	def __iter__(self):
-		repo = self._parent
-		for p in repo._repo.package_names(self._key, []):
-			yield PaludisPackage(p, self)
-
-	@property
-	def packages(self):
-		"""
-		A convenience wrapper for the package list.
-		"""
-		return IterDictWrapper(self)
-
-class PaludisPackage(PMKeyedPackageDict):
-	_key_name = 'PN'
-	def __init__(self, qpn, parent):
-		PMKeyedPackageDict.__init__(self, str(qpn.package), parent)
-		self._qpn = qpn
-
-	def __iter__(self):
-		repo = self._parent._parent
-		for p in repo._repo.package_ids(self._qpn, []):
-			yield PaludisID(p, self)
-
-	@property
-	def versions(self):
-		"""
-		A convenience wrapper for the version list.
-		"""
-		return IterDictWrapper(self)
+from gentoopm.basepm.pkg import PMPackage
 
 class PaludisID(PMPackage):
-	_key_name = 'PVR'
-	def __init__(self, pkg, parent):
+	def __init__(self, pkg):
 		self._pkg = pkg
-		PMPackage.__init__(self, str(pkg.version), parent)
 
 	@property
 	def metadata(self):

diff --git a/gentoopm/paludispm/repo.py b/gentoopm/paludispm/repo.py
index d29e2ac..71214de 100644
--- a/gentoopm/paludispm/repo.py
+++ b/gentoopm/paludispm/repo.py
@@ -3,42 +3,32 @@
 # (c) 2011 Michał Górny <mgorny@g.o>
 # Released under the terms of the 2-clause BSD license.
 
-import collections, os.path
+import paludis
 
 from gentoopm.basepm.repo import PMRepository, PMRepositoryDict, \
 		PMEbuildRepository
-from gentoopm.paludispm.pkg import PaludisCategory
-from gentoopm.util import IterDictWrapper
+from gentoopm.paludispm.pkg import PaludisID
 
 class PaludisRepoDict(PMRepositoryDict):
 	def __iter__(self):
 		for r in self._env.repositories:
 			if r.format_key().parse_value() == 'e':
-				yield PaludisLivefsRepository(r)
+				yield PaludisLivefsRepository(r, self._env)
 
 	def __init__(self, env):
 		self._env = env
 
 class PaludisRepository(PMRepository):
 	def __iter__(self):
-		for c in self._repo.category_names([]):
-			pc = PaludisCategory(c, self)
-			try:
-				next(iter(pc))
-			except StopIteration: # omit empty categories
-				pass
-			else:
-				yield pc
-
-	@property
-	def categories(self):
-		"""
-		A convenience wrapper for the category list.
-		"""
-		return IterDictWrapper(self)
+		for p in self._env[paludis.Selection.AllVersionsSorted(
+				paludis.FilteredGenerator(
+					paludis.Generator.InRepository(self._repo.name),
+					paludis.Filter.All()))]:
+			yield PaludisID(p)
 
 class PaludisLivefsRepository(PaludisRepository, PMEbuildRepository):
-	def __init__(self, repo_obj):
+	def __init__(self, repo_obj, env):
+		self._env = env
 		self._repo = repo_obj
 
 	@property
@@ -51,6 +41,7 @@ class PaludisLivefsRepository(PaludisRepository, PMEbuildRepository):
 
 class PaludisInstalledRepo(PaludisRepository):
 	def __init__(self, env):
+		self._env = env
 		for r in env.repositories:
 			if str(r.name) == 'installed': # XXX
 				self._repo = r

diff --git a/gentoopm/pkgcorepm/pkg.py b/gentoopm/pkgcorepm/pkg.py
index 30e6bae..559a229 100644
--- a/gentoopm/pkgcorepm/pkg.py
+++ b/gentoopm/pkgcorepm/pkg.py
@@ -3,54 +3,12 @@
 # (c) 2011 Michał Górny <mgorny@g.o>
 # Released under the terms of the 2-clause BSD license.
 
-from pkgcore.restrictions.packages import PackageRestriction, AndRestriction
-from pkgcore.restrictions.values import StrExactMatch
-
 from gentoopm.basepm.metadata import PMPackageMetadata
-from gentoopm.basepm.pkg import PMKeyedPackageDict, PMPackage
-from gentoopm.util import IterDictWrapper
-
-class PkgCoreCategory(PMKeyedPackageDict):
-	_key_name = 'CATEGORY'
-	def __iter__(self):
-		repo = self._parent
-		try:
-			for p in repo._repo.packages[self._key]:
-				yield PkgCorePackage(p, self)
-		except KeyError:
-			pass
+from gentoopm.basepm.pkg import PMPackage
 
-	@property
-	def packages(self):
-		"""
-		A convenience wrapper for the package list.
-		"""
-		return IterDictWrapper(self)
-
-class PkgCorePackage(PMKeyedPackageDict):
-	_key_name = 'PN'
-	def __iter__(self):
-		r = AndRestriction(
-			PackageRestriction("category", StrExactMatch(self._parent._key)),
-			PackageRestriction("package", StrExactMatch(self._key))
-		)
-
-		repo = self._parent._parent
-		for p in repo._repo.itermatch(r):
-			yield PkgCoreEbuild(p, self)
-
-	@property
-	def versions(self):
-		"""
-		A convenience wrapper for the version list.
-		"""
-		return IterDictWrapper(self)
-
-class PkgCoreEbuild(PMPackage):
-	_key_name = 'PVR'
-	def __init__(self, pkg, parent):
+class PkgCorePackage(PMPackage):
+	def __init__(self, pkg):
 		self._pkg = pkg
-		PMPackage.__init__(self, pkg.fullver, parent)
 
 	@property
 	def metadata(self):
@@ -61,7 +19,7 @@ class PkgCoreEbuild(PMPackage):
 		return self._pkg.path
 
 	def __cmp__(self, other):
-		if not isinstance(other, PkgCoreEbuild):
+		if not isinstance(other, PkgCorePackage):
 			raise TypeError('Unable to compare %s against %s' % \
 					self, other)
 		if self._pkg.key != other._pkg.key:

diff --git a/gentoopm/pkgcorepm/repo.py b/gentoopm/pkgcorepm/repo.py
index 7a432a7..b0f0593 100644
--- a/gentoopm/pkgcorepm/repo.py
+++ b/gentoopm/pkgcorepm/repo.py
@@ -3,12 +3,9 @@
 # (c) 2011 Michał Górny <mgorny@g.o>
 # Released under the terms of the 2-clause BSD license.
 
-import os.path
-
 from gentoopm.basepm.repo import PMRepository, PMRepositoryDict, \
 		PMEbuildRepository
-from gentoopm.pkgcorepm.pkg import PkgCoreCategory
-from gentoopm.util import IterDictWrapper
+from gentoopm.pkgcorepm.pkg import PkgCorePackage
 
 class PkgCoreRepoDict(PMRepositoryDict):
 	def __iter__(self):
@@ -23,15 +20,8 @@ class PkgCoreRepository(PMRepository):
 		self._repo = repo_obj
 
 	def __iter__(self):
-		for c in self._repo.categories:
-			yield PkgCoreCategory(c, self)
-
-	@property
-	def categories(self):
-		"""
-		A convenience wrapper for the category list.
-		"""
-		return IterDictWrapper(self)
+		for pkg in self._repo:
+			yield PkgCorePackage(pkg)
 
 class PkgCoreEbuildRepo(PkgCoreRepository, PMEbuildRepository):
 	def __init__(self, repo_obj, index):

diff --git a/gentoopm/portagepm/__init__.py b/gentoopm/portagepm/__init__.py
index 60ffa1c..15a9bec 100644
--- a/gentoopm/portagepm/__init__.py
+++ b/gentoopm/portagepm/__init__.py
@@ -8,7 +8,7 @@ from portage import create_trees
 
 from gentoopm.basepm import PackageManager
 from gentoopm.portagepm.repo import PortageRepoDict
-from gentoopm.portagepm.db import VDBRepository, PortDBRepository
+from gentoopm.portagepm.db import VDBRepository
 
 class PortagePM(PackageManager):
 	name = 'portage'

diff --git a/gentoopm/portagepm/db.py b/gentoopm/portagepm/db.py
index ce7188f..3eae39a 100644
--- a/gentoopm/portagepm/db.py
+++ b/gentoopm/portagepm/db.py
@@ -3,32 +3,16 @@
 # (c) 2011 Michał Górny <mgorny@g.o>
 # Released under the terms of the 2-clause BSD license.
 
-import os.path
 import portage.versions
 
 from gentoopm.basepm.metadata import PMPackageMetadata
-from gentoopm.basepm.pkg import PMKeyedPackageDict, PMPackage
 from gentoopm.basepm.repo import PMRepository
-from gentoopm.portagepm.pkg import PortageCategory, PortagePackage, PortageCPV
-from gentoopm.util import IterDictWrapper
+from gentoopm.portagepm.pkg import PortageCPV
 
-class PortageDBCategory(PortageCategory):
-	def __iter__(self):
-		for p in self._dbapi.cp_all():
-			cat = portage.versions.catsplit(p)[0]
-			if cat == self._key:
-				yield PortageDBPackage(p, self, self._dbapi)
-
-class PortageDBPackage(PortagePackage):
-	def __iter__(self):
-		for p in self._dbapi.cp_list(self._qpn):
-			yield PortageDBCPV(p, self, self._dbapi)
+# XXX: cleanup all this mess!
 
 class PortageDBCPV(PortageCPV):
-	_key_name = 'PVR'
-	def __init__(self, cpv, parent, dbapi):
-		version = portage.versions.cpv_getversion(cpv)
-		PMPackage.__init__(self, version, parent)
+	def __init__(self, cpv, dbapi):
 		self._cpv = cpv
 		self._dbapi = dbapi
 
@@ -46,30 +30,36 @@ class PortageDBMetadata(PMPackageMetadata):
 		self._cpv = cpv
 		self._dbapi = dbapi
 
-	def __getitem__(self, key):
+	def __getattr__(self, key):
 		return self._dbapi.aux_get(self._cpv, [key])[0]
-	
+
+	@property
+	def CATEGORY(self):
+		return portage.versions.catsplit(self._cpv)[0]
+
+	@property
+	def PN(self):
+		return portage.versions.catpkgsplit(self._cpv)[1]
+
+	@property
+	def PV(self):
+		return portage.versions.pkgsplit(self._cpv)[1]
+
+	@property
+	def PR(self):
+		return portage.versions.pkgsplit(self._cpv)[2]
+
+	@property
+	def PVR(self):
+		return portage.versions.cpv_getversion(self._cpv)
+
 class PortDBRepository(PMRepository):
 	def __init__(self, dbapi):
 		self._dbapi = dbapi
 
-	_category_class = PortageDBCategory
 	def __iter__(self):
-		for c in self._dbapi.categories:
-			pc = self._category_class(c, self, self._dbapi)
-			try:
-				next(iter(pc))
-			except StopIteration: # omit empty categories
-				pass
-			else:
-				yield pc
-
-	@property
-	def categories(self):
-		"""
-		A convenience wrapper for the category list.
-		"""
-		return IterDictWrapper(self)
+		for p in self._dbapi.cpv_all(): # XXX
+			yield PortageDBCPV(p, self._dbapi)
 
 class VDBRepository(PortDBRepository):
 	pass

diff --git a/gentoopm/portagepm/pkg.py b/gentoopm/portagepm/pkg.py
index 8588208..8696706 100644
--- a/gentoopm/portagepm/pkg.py
+++ b/gentoopm/portagepm/pkg.py
@@ -6,68 +6,23 @@
 import portage.versions
 
 from gentoopm.basepm.metadata import PMPackageMetadata
-from gentoopm.basepm.pkg import PMKeyedPackageDict, PMPackage
-from gentoopm.util import IterDictWrapper
+from gentoopm.basepm.pkg import PMPackage
 
-class PortageCategory(PMKeyedPackageDict):
-	_key_name = 'CATEGORY'
-	def __init__(self, category, parent, dbapi):
-		PMKeyedPackageDict.__init__(self, category, parent)
-		self._dbapi = dbapi
-
-	def __iter__(self):
-		repo = self._parent.path
-
-		for p in self._dbapi.cp_all(categories=(self._key,), trees=(repo,)):
-			yield PortagePackage(p, self, self._dbapi)
-
-	@property
-	def packages(self):
-		"""
-		A convenience wrapper for the package list.
-		"""
-		return IterDictWrapper(self)
-
-class PortagePackage(PMKeyedPackageDict):
-	_key_name = 'PN'
-	def __init__(self, qpn, parent, dbapi):
-		pn = portage.versions.catsplit(qpn)[1]
-		PMKeyedPackageDict.__init__(self, pn, parent)
-		self._qpn = qpn
-		self._dbapi = dbapi
-
-	def __iter__(self):
-		repo = self._parent._parent.path
-
-		for p in self._dbapi.cp_list(self._qpn, mytree=repo):
-			yield PortageCPV(p, self, self._dbapi)
-
-	@property
-	def versions(self):
-		"""
-		A convenience wrapper for the version list.
-		"""
-		return IterDictWrapper(self)
+# XXX: cleanup all this mess!
 
 class PortageCPV(PMPackage):
-	_key_name = 'PVR'
-	def __init__(self, cpv, parent, dbapi):
-		version = portage.versions.cpv_getversion(cpv)
-		PMPackage.__init__(self, version, parent)
+	def __init__(self, cpv, dbapi, tree):
 		self._cpv = cpv
 		self._dbapi = dbapi
-
-	@property
-	def _repo_path(self):
-		return self._parent._parent._parent.path
+		self._tree = tree
 
 	@property
 	def metadata(self):
-		return PortageMetadata(self._cpv, self._dbapi, self._repo_path)
+		return PortageMetadata(self._cpv, self._dbapi, self._tree)
 
 	@property
 	def path(self):
-		return self._dbapi.findname(self._cpv, self._repo_path)
+		return self._dbapi.findname(self._cpv, self._tree)
 
 	def __cmp__(self, other):
 		if not isinstance(other, PortageCPV):

diff --git a/gentoopm/portagepm/repo.py b/gentoopm/portagepm/repo.py
index 3041db0..8203f92 100644
--- a/gentoopm/portagepm/repo.py
+++ b/gentoopm/portagepm/repo.py
@@ -5,10 +5,9 @@
 
 import os.path
 
-from gentoopm.basepm.repo import PMRepository, PMRepositoryDict, PMEbuildRepository
+from gentoopm.basepm.repo import PMRepositoryDict, PMEbuildRepository
 from gentoopm.portagepm.db import PortDBRepository
-from gentoopm.portagepm.pkg import PortageCategory
-from gentoopm.util import IterDictWrapper
+from gentoopm.portagepm.pkg import PortageCPV
 
 class PortageRepoDict(PMRepositoryDict):
 	def __iter__(self):
@@ -35,6 +34,12 @@ class PortageRepository(PortDBRepository, PMEbuildRepository):
 		self._repo = repo_obj
 		PortDBRepository.__init__(self, portdbapi)
 
+	def __iter__(self):
+		path = self.path
+		for cp in self._dbapi.cp_all(trees = (path,)):
+			for p in self._dbapi.cp_list(cp, mytree = path):
+				yield PortageCPV(p, self._dbapi, path)
+
 	@property
 	def name(self):
 		return self._repo.name
@@ -45,5 +50,3 @@ class PortageRepository(PortDBRepository, PMEbuildRepository):
 
 	def __cmp__(self, other):
 		return cmp(self._repo.priority, other._repo.priority)
-
-	_category_class = PortageCategory