def test_iter(self):
repo, vrepo = self.setup_repos(
packages.PackageRestriction(
"package",
values.OrRestriction(
*[values.StrExactMatch(x) for x in ("diffball", "fake")])))
assert sorted(vrepo) == sorted(repo.itermatch(atom("dev-util/bsdiff")))
def test_filtering(self):
repo, vrepo = self.setup_repos()
a = atom("dev-lib/fake")
a2 = atom("dev-util/diffball")
self.assertEqual(
sorted(vrepo.itermatch(a)), sorted(repo.itermatch(a)))
self.assertEqual(sorted(vrepo.itermatch(a2)), sorted([]))
repo, vrepo = self.setup_repos(atom("=dev-util/diffball-1.0"))
self.assertEqual(
sorted(vrepo.itermatch(a)), sorted(repo.itermatch(a)))
self.assertEqual(
sorted(vrepo.itermatch(a2)),
sorted([versioned_CPV("dev-util/diffball-0.7")]))
repo, vrepo = self.setup_repos(packages.PackageRestriction(
"package", values.OrRestriction(
*[values.StrExactMatch(x) for x in ("diffball", "fake")])))
self.assertEqual(
sorted(vrepo.itermatch(packages.AlwaysTrue)),
sorted(repo.itermatch(atom("dev-util/bsdiff"))))
# check sentinel value handling.
vrepo = filtered.tree(repo, a2, sentinel_val=True)
self.assertEqual(
sorted(x.cpvstr for x in vrepo),
sorted(['dev-util/diffball-0.7', 'dev-util/diffball-1.0']))
def _caching_grab_virtuals(repo, cache_basedir):
virtuals = {}
update = False
cache = _read_mtime_cache(pjoin(cache_basedir, 'virtuals.cache'))
existing = _get_mtimes(repo.location)
for cat, mtime in existing.iteritems():
d = cache.pop(cat, None)
if d is not None and long(d[0]) == long(mtime):
d = _convert_cached_virtuals(d)
if d is not None:
_merge_virtuals(virtuals, d)
continue
update = True
_collect_virtuals(virtuals, repo.itermatch(
packages.PackageRestriction("category",
values.StrExactMatch(cat))))
if update or cache:
_write_mtime_cache(existing, virtuals,
pjoin(cache_basedir, 'virtuals.cache'))
defaults = _collect_default_providers(virtuals)
# _finalize_virtuals(virtuals)
return defaults, virtuals
def __init__(self, slot, **kwds):
v = values.StrExactMatch(slot)
return packages.PackageRestriction.__init__(self,
"subslot",
v,
negate=kwds.get(
"negate", False))
def test_itermatch(self):
imatch = self.ctree.itermatch
assert sorted(x.cpvstr for x in imatch(packages.AlwaysTrue)) == \
sorted(self.tree1_list + self.tree2_list)
p = packages.PackageRestriction("package", values.StrExactMatch("diffball"))
assert sorted(x.cpvstr for x in imatch(p)) == \
[y for y in sorted(self.tree1_list + self.tree2_list) if "/diffball" in y]
def convert_glob(token):
if token in ('*', ''):
return None
elif '*' not in token:
return values.StrExactMatch(token)
elif not valid_globbing(token):
raise ParseError("globs must be composed of [\w-.+], with optional "
"'*'- '%s' is disallowed however" % token)
pattern = "^%s$" % (re.escape(token).replace("\*", ".*"), )
return values.StrRegex(pattern, match=True)
def convert_glob(token):
if token in ('*', ''):
return None
elif '*' not in token:
return values.StrExactMatch(token)
elif not valid_globbing(token):
raise ParseError("globs must be composed of [\\w-.+], with optional "
f"'*'- {token!r} is disallowed however")
pattern = re.escape(token).replace('\\*', '.*')
pattern = f"^{pattern}$"
return values.StrRegex(pattern, match=True)
def generate_mangled_blocker(self, choices, blocker):
"""converts a blocker into a "cannot block ourself" block"""
# note the second Or clause is a bit loose; allows any version to
# slip through instead of blocking everything that isn't the
# parent pkg
if blocker.category != 'virtual':
return blocker
return packages.AndRestriction(
blocker,
packages.PackageRestriction("provider.key",
values.StrExactMatch(
choices.current_pkg.key),
negate=True,
ignore_missing=True))
def __init__(self, repo_id, negate=False):
packages.PackageRestriction.__init__(self,
"repo.repo_id",
values.StrExactMatch(repo_id),
negate=negate)
def test_identify_candidates(self):
with pytest.raises(TypeError):
self.repo.match("asdf")
rc = packages.PackageRestriction("category",
values.StrExactMatch("dev-util"))
assert \
sorted(set(x.package for x in self.repo.itermatch(rc))) == \
sorted(["diffball", "bsdiff"])
rp = packages.PackageRestriction("package",
values.StrExactMatch("diffball"))
assert list(
x.version
for x in self.repo.itermatch(rp, sorter=sorted)) == ["0.7", "1.0"]
assert \
self.repo.match(packages.OrRestriction(rc, rp), sorter=sorted) == \
sorted(VersionedCPV(x) for x in (
"dev-util/diffball-0.7", "dev-util/diffball-1.0",
"dev-util/bsdiff-0.4.1", "dev-util/bsdiff-0.4.2"))
assert \
sorted(self.repo.itermatch(packages.AndRestriction(rc, rp))) == \
sorted(VersionedCPV(x) for x in (
"dev-util/diffball-0.7", "dev-util/diffball-1.0"))
assert sorted(self.repo) == self.repo.match(packages.AlwaysTrue,
sorter=sorted)
# mix/match cat/pkg to check that it handles that corner case
# properly for sorting.
assert \
sorted(self.repo, reverse=True) == \
self.repo.match(packages.OrRestriction(
rc, rp, packages.AlwaysTrue),
sorter=partial(sorted, reverse=True))
rc2 = packages.PackageRestriction("category",
values.StrExactMatch("dev-lib"))
assert sorted(self.repo.itermatch(packages.AndRestriction(rp,
rc2))) == []
# note this mixes a category level match, and a pkg level
# match. they *must* be treated as an or.
assert \
sorted(self.repo.itermatch(packages.OrRestriction(rp, rc2))) == \
sorted(VersionedCPV(x) for x in (
"dev-util/diffball-0.7", "dev-util/diffball-1.0",
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
# this is similar to the test above, but mixes a cat/pkg
# candidate with a pkg candidate
rp2 = packages.PackageRestriction("package",
values.StrExactMatch("fake"))
r = packages.OrRestriction(atom("dev-util/diffball"), rp2)
assert \
sorted(self.repo.itermatch(r)) == \
sorted(VersionedCPV(x) for x in (
"dev-util/diffball-0.7", "dev-util/diffball-1.0",
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
assert \
sorted(self.repo.itermatch(
packages.OrRestriction(packages.AlwaysTrue, rp2))) == \
sorted(VersionedCPV(x) for x in (
"dev-util/diffball-0.7", "dev-util/diffball-1.0",
"dev-util/bsdiff-0.4.1", "dev-util/bsdiff-0.4.2",
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
assert \
sorted(self.repo.itermatch(packages.PackageRestriction(
'category', values.StrExactMatch('dev-util', negate=True)))) == \
sorted(VersionedCPV(x) for x in ("dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
obj = malleable_obj(livefs=False)
pkg_cls = post_curry(MutatedPkg, {'repo': obj})
assert \
sorted(self.repo.itermatch(boolean.AndRestriction(boolean.OrRestriction(
packages.PackageRestriction(
"repo.livefs", values.EqualityMatch(False)),
packages.PackageRestriction(
"category", values.StrExactMatch("virtual"))),
atom("dev-lib/fake")),
pkg_cls=pkg_cls)) == \
sorted(VersionedCPV(x) for x in (
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
assert \
sorted(self.repo.itermatch(packages.PackageRestriction(
'category', values.StrExactMatch('dev-lib', negate=True),
negate=True))) == \
sorted(VersionedCPV(x) for x in (
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
assert \
sorted(self.repo.itermatch(packages.PackageRestriction(
'category', values.StrExactMatch('dev-lib', negate=True), negate=True))) == \
sorted(VersionedCPV(x) for x in (
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
def __init__(self, category, negate=False):
packages.PackageRestriction.__init__(
self, "category", values.StrExactMatch(category, negate=negate))
def __init__(self, package, negate=False):
packages.PackageRestriction.__init__(
self, "package", values.StrExactMatch(package, negate=negate))
def __init__(self, package, negate=False):
super().__init__('package', values.StrExactMatch(package, negate=negate))
def __init__(self, category, negate=False):
super().__init__('category', values.StrExactMatch(category, negate=negate))
def __init__(self, repo_id, negate=False):
super().__init__('repo.repo_id', values.StrExactMatch(repo_id), negate=negate)
def parse_owns(value):
return packages.PackageRestriction(
'contents',
values.AnyMatch(
values.GetAttrRestriction('location',
values.StrExactMatch(value))))
def __init__(self, slot, **kwds):
v = values.StrExactMatch(slot)
super().__init__('subslot', v, negate=kwds.get('negate', False))
dbs = list(map(misc.nodeps_repo, dbs))
elif not verify_vdb:
vdbs = list(map(misc.nodeps_repo, vdbs))
dbs = list(dbs)
if force_replace:
resolver_cls = generate_replace_resolver_kls(resolver_cls)
return resolver_cls(vdbs + dbs, plan.pkg_sort_highest,
plan.merge_plan.prefer_reuse_strategy, **kwds)
_vdb_restrict = packages.OrRestriction(
packages.PackageRestriction("repo.livefs", values.EqualityMatch(False)),
packages.AndRestriction(
packages.PackageRestriction("category",
values.StrExactMatch("virtual")),
packages.PackageRestriction("package_is_real",
values.EqualityMatch(False)),
),
)
class empty_tree_merge_plan(plan.merge_plan):
_vdb_restriction = _vdb_restrict
def __init__(self, dbs, *args, **kwds):
"""
:param args: see :obj:`pkgcore.resolver.plan.merge_plan.__init__`
for valid args
:param kwds: see :obj:`pkgcore.resolver.plan.merge_plan.__init__`
def parse_eapi(value):
"""Value is matched against package EAPI versions."""
return packages.PackageRestriction('eapi', values.StrExactMatch(value))
