aridity 91__tar.gz → 93__tar.gz

{aridity-91 → aridity-93}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aridity
-Version: 91
+Version: 93
 Summary: DRY config and template system, easily extensible with Python
 Home-page: https://pypi.org/project/aridity/
 Author: foyono
@@ -191,6 +191,17 @@ def plusequals(prefix, suffix, scope)
 
 Assign expression to prefix plus an opaque key, i.e. add to list.
 
+<a id="aridity.directives.commaequals"></a>
+
+###### commaequals
+
+```python
+@prime
+def commaequals(prefix, suffix, scope)
+```
+
+Split expression on whitespace and make a list out of the parts.
+
 <a id="aridity.functions"></a>
 
 ### aridity.functions
@@ -474,7 +485,7 @@ class AbstractScope(Resolvable)
 ###### resolved
 
 ```python
-def resolved(*path, **kwargs)
+def resolved(*path)
 ```
 
 Follow the given path to get an expression, evaluate it (resolving any paths it requires, recursively), and return the resulting model object.

{aridity-91 → aridity-93}/README.md

@@ -181,6 +181,17 @@ def plusequals(prefix, suffix, scope)
 
 Assign expression to prefix plus an opaque key, i.e. add to list.
 
+<a id="aridity.directives.commaequals"></a>
+
+###### commaequals
+
+```python
+@prime
+def commaequals(prefix, suffix, scope)
+```
+
+Split expression on whitespace and make a list out of the parts.
+
 <a id="aridity.functions"></a>
 
 ### aridity.functions
@@ -464,7 +475,7 @@ class AbstractScope(Resolvable)
 ###### resolved
 
 ```python
-def resolved(*path, **kwargs)
+def resolved(*path)
 ```
 
 Follow the given path to get an expression, evaluate it (resolving any paths it requires, recursively), and return the resulting model object.

{aridity-91 → aridity-93}/aridity/arid_config.py

@@ -1,7 +1,8 @@
 'Print given config (with optional path in config) as shell snippet.'
+from .functions import OpaqueKey
 from .model import Boolean, Entry, Locator, Number, Text
 from .scope import Scope
-import os, sys
+import os, shlex, sys
 
 def _configpath(configname):
     if os.sep in configname:
@@ -12,17 +13,21 @@ def _configpath(configname):
             return path
     raise Exception(f"Not found: {configname}")
 
+def _bashforeval(scope):
+    return ''.join(f"{name}={obj.tobash()}\n" for name, obj in scope.resolveditems())
+
 def _scopetobash(self, toplevel = False):
     if toplevel:
-        return ''.join(f"{name}={obj.resolve(self).tobash()}\n" for name, obj in self.resolvables.items())
-    if self.islist:
-        return f"({' '.join(x.resolve(self).tobash() for _, x in self.resolvables.items())})"
-    return Text(self.tobash(True)).tobash()
+        return _bashforeval(self)
+    d = dict(self.resolveditems())
+    if all(map(OpaqueKey.isopaque, d)):
+        return f"({' '.join(x.tobash() for x in d.values())})"
+    return shlex.quote(_bashforeval(self))
 
 Scope.tobash = _scopetobash
 Boolean.tobash = lambda self, toplevel: 'true' if self.booleanvalue else 'false'
 Number.tobash = lambda self: str(self.numbervalue)
-Text.tobash = lambda self: "'{}'".format(self.textvalue.replace("'", r"'\''"))
+Text.tobash = lambda self: shlex.quote(self.textvalue)
 
 def main():
     scope = Scope()

{aridity-91 → aridity-93}/aridity/directives.py

@@ -74,8 +74,16 @@ def colonequals(prefix, suffix, scope):
 def plusequals(prefix, suffix, scope):
     'Assign expression to prefix plus an opaque key, i.e. add to list.'
     from .functions import OpaqueKey
-    phrase = suffix.tophrase()
-    scope[prefix.topath(scope) + (OpaqueKey(),)] = phrase
+    scope[prefix.topath(scope) + (OpaqueKey(),)] = suffix.tophrase()
+
+@prime
+def commaequals(prefix, suffix, scope):
+    'Split expression on whitespace and make a list out of the parts.'
+    from .functions import OpaqueKey
+    basepath = prefix.topath(scope)
+    scope.getorcreatesubscope(basepath)
+    for r in suffix.words():
+        scope[basepath + (OpaqueKey(),)] = r
 
 @prime
 def _cat(prefix, suffix, scope):
@@ -92,4 +100,5 @@ def coredirectives():
     yield '=', equals
     yield ':=', colonequals
     yield '+=', plusequals
+    yield ',=', commaequals
     yield '<', _cat

{aridity-91 → aridity-93}/aridity/functions.py

@@ -103,7 +103,7 @@ def map_(scope, objsresolvable, *args):
         kname, vname, resolvable = args
         kname = kname.resolve(scope).textvalue
         vname = vname.resolve(scope).textvalue
-    result = Scope(islist = True) # XXX: Really no parent?
+    result = Scope() # XXX: Really no parent?
     for k, v in objs.resolveditems():
         result.resolvables.put(k, resolvable.resolve(context(k, v)))
     return result
@@ -116,7 +116,7 @@ def map1(scope, contextresolvable, resultresolvable):
 
 def _flat(scope, listsresolvable):
     from .scope import Scope
-    s = Scope(islist = True) # XXX: Really no parent?
+    s = Scope() # XXX: Really no parent?
     for lk, l in listsresolvable.resolve(scope).resolvables.items():
         for ok, obj in l.resolvables.items():
             s.resolvables.put((lk, ok), obj)
@@ -129,16 +129,13 @@ def join(scope, partsresolvable, sepresolvable = None):
     'Concatenate the given list, using optional separator. Frequently used with `map`.'
     return Join(scope, partsresolvable).execute(sepresolvable)
 
-def _aslist(scope, *resolvables):
-    return scope.resolved(*(r.resolve(scope).textvalue for r in resolvables), **{'aslist': True})
-
 def str_(scope, resolvable):
     'Coerce to string.'
     return resolvable.resolve(scope).totext()
 
 def list_(scope, *resolvables):
     'Create a list.'
-    v = scope.createchild(islist = True)
+    v = scope.createchild()
     for r in resolvables:
         v[OpaqueKey(),] = r
     return v
@@ -250,8 +247,8 @@ class Join:
                         break
         return resobj
 
-def getimpl(scope, *resolvables, **kwargs):
-    return scope.resolved(*(r.resolve(scope).textvalue for r in resolvables), **kwargs)
+def getimpl(scope, *resolvables):
+    return scope.resolved(*(r.resolve(scope).textvalue for r in resolvables))
 
 def corefunctions():
     yield 'gpg', gpg
@@ -272,7 +269,6 @@ def corefunctions():
     yield 'flat', _flat
     yield 'label', _label
     yield 'join', join
-    yield ',', _aslist # XXX: Really comma?
     yield 'str', str_
     yield 'list', list_
     yield 'fork', _fork

{aridity-91 → aridity-93}/aridity/model.py

@@ -37,8 +37,8 @@ class Resolvable(Struct):
 
 class Resolved(Resolvable):
 
-    def resolve(self, scope, aslist = False):
-        return List([self]) if aslist else self
+    def resolve(self, scope):
+        return self
 
 nullmonitor = lambda text: None
 
@@ -80,9 +80,7 @@ class Concat(Resolvable): # TODO: Ban in path components.
         self.parts = parts
         self.monitor = monitor
 
-    def resolve(self, scope, aslist = False):
-        if aslist:
-            return List([part.resolve(scope) for part in self.parts if not part.ignorable])
+    def resolve(self, scope):
         result = Indeterminate
         negbuffer = NegBuffer()
         for part in self.parts:
@@ -111,7 +109,7 @@ class BaseSimpleValue(Resolved):
         value, = t
         return cls(value)
 
-    def unravel(self):
+    def unravel(self, listmode = None):
         return self.scalar
 
 class Blank(BaseSimpleValue):
@@ -375,9 +373,8 @@ class Call(Resolvable):
             if not a.ignorable:
                 yield a
 
-    def resolve(self, scope, aslist = False):
-        result = self._functionvalue(scope)(scope.getresolvecontext(), *self._resolvables())
-        return List([result]) if aslist else result
+    def resolve(self, scope):
+        return self._functionvalue(scope)(scope.getresolvecontext(), *self._resolvables())
 
     def resolvemulti(self, j, scope):
         f = self._functionvalue(scope.getresolvecontext())
@@ -390,7 +387,7 @@ class Call(Resolvable):
 
 def List(objs):
     from .scope import Scope
-    s = Scope(islist = True)
+    s = Scope()
     for obj in objs:
         s.resolvables.put(object(), obj) # XXX: Not OpaqueKey?
     return s

aridity-93/aridity/resolve.py

@@ -0,0 +1,68 @@
+from .search import Query
+from .util import CycleException, NoSuchPathException, TreeNoSuchPathException
+from itertools import chain
+
+class BaseResolveContext:
+
+    @property
+    def label(self):
+        return self.leafscope().label
+
+    @property
+    def parents(self):
+        return self.leafscope().parents
+
+    @property
+    def resolvables(self):
+        return self.leafscope().resolvables
+
+    def createchild(self):
+        return self.leafscope().createchild()
+
+    def getresolvecontext(self):
+        return self
+
+    def resolvableornone(self, key):
+        return self.leafscope().resolvableornone(key)
+
+    def resolved(self, *path):
+        return self.resolvedimpl(path) if path else self.leafscope()
+
+    def staticscope(self):
+        return self.leafscope().staticscope()
+
+class AnchorResolveContext(BaseResolveContext):
+
+    def __init__(self, anchorscope):
+        self.anchorscope = anchorscope
+
+    def leafscope(self):
+        return self.anchorscope
+
+    def resolvedimpl(self, path):
+        hit = Query([], path).search(self.anchorscope)
+        return hit.resolvable.resolve(ResolveContext(self.anchorscope, path, [hit.address]))
+
+class ResolveContext(BaseResolveContext):
+
+    @classmethod
+    def _of(cls, *args):
+        return cls(*args)
+
+    def __init__(self, anchorscope, exprpath, addresses):
+        self.anchorscope = anchorscope
+        self.scopepath = exprpath[:-1]
+        self.exprpath = exprpath
+        self.addresses = addresses
+
+    def leafscope(self):
+        return Query([], self.scopepath).search(self.anchorscope).naiveresolve() if self.scopepath else self.anchorscope # XXX: Is naiveresolve correct here?
+
+    def resolvedimpl(self, path):
+        try:
+            hit = Query(self.scopepath, path).search(self.anchorscope)
+            if hit.address in self.addresses: # XXX: Could it be valid to resolve the same address recursively with 2 different contexts?
+                raise CycleException(path)
+            return hit.resolvable.resolve(self._of(self.anchorscope, list(chain(self.scopepath, path)), self.addresses + [hit.address]))
+        except NoSuchPathException as e:
+            raise TreeNoSuchPathException(self.exprpath, [e])

{aridity-91 → aridity-93}/aridity/scope.py

@@ -4,9 +4,9 @@ from .model import Directive, Function, Hole, Resolvable, Scalar, star, Stream,
 from .resolve import AnchorResolveContext
 from .search import Query
 from .stacks import IndentStack, SimpleStack, ThreadLocalResolvable
-from .util import NoSuchPathException, OrderedDict, solo, UnsupportedEntryException
+from .util import NoSuchPathException, solo, UnsupportedEntryException
 from itertools import chain
-import collections, os, sys, threading
+import os, sys, threading
 
 class NotAPathException(Exception): pass
 
@@ -45,7 +45,7 @@ class Resolvables:
         return {}
 
     def __init__(self, scope):
-        self.d = collections.OrderedDict()
+        self.d = {}
         self.scope = scope
 
     def put(self, key, resolvable):
@@ -72,10 +72,6 @@ class Resolvables:
 class AbstractScope(Resolvable): # TODO LATER: Some methods should probably be moved to Scope.
 
     nametypes = {str, type(None), OpaqueKey} # XXX: Is None still used by anything?
-    try:
-        nametypes.add(unicode)
-    except NameError:
-        pass
 
     def __init__(self, parents):
         self.resolvables = Resolvables(self)
@@ -121,7 +117,7 @@ class AbstractScope(Resolvable): # TODO LATER: Some methods should probably be m
     def getresolvecontext(self):
         return AnchorResolveContext(self)
 
-    def resolved(self, *path, **kwargs):
+    def resolved(self, *path):
         'Follow the given path to get an expression, evaluate it (resolving any paths it requires, recursively), and return the resulting model object.'
         # TODO LATER: API to filter out results unsuitable for context.
         for s in chain.from_iterable(self.scopedepths()):
@@ -131,7 +127,7 @@ class AbstractScope(Resolvable): # TODO LATER: Some methods should probably be m
                 break
             except AttributeError:
                 pass
-        return g(self.getresolvecontext(), *map(Text, path), **kwargs)
+        return g(self.getresolvecontext(), *map(Text, path))
 
     def resolvableornone(self, key):
         return self.resolvables.getornone(key)
@@ -145,9 +141,12 @@ class AbstractScope(Resolvable): # TODO LATER: Some methods should probably be m
             yield scopes
             scopes = nextscopes
 
-    def unravel(self):
-        d = OrderedDict([k, o.unravel()] for k, o in self.resolveditems())
-        return list(d) if self.islist or (d and all(OpaqueKey.isopaque(k) for k in d.keys())) else d
+    def unravel(self, listmode = 0):
+        def g():
+            args = [2] if 2 == listmode else []
+            for k, o in self.resolveditems():
+                yield k, o.unravel(*args)
+        return [v for _, v in g()] if listmode else dict(g())
 
     def staticscope(self):
         for s in chain.from_iterable(self.scopedepths()):
@@ -164,7 +163,7 @@ class AbstractScope(Resolvable): # TODO LATER: Some methods should probably be m
             if not acceptdirectivename(word):
                 continue
             try:
-                resolvable = Query([word]).search(self).resolvable
+                resolvable = Query([], [word]).search(self).resolvable
             except NoSuchPathException:
                 continue
             try:
@@ -201,8 +200,8 @@ class AbstractScope(Resolvable): # TODO LATER: Some methods should probably be m
             for t in r.resolvemulti(k, self):
                 yield t
 
-    def createchild(self, **kwargs):
-        return Scope([self], **kwargs)
+    def createchild(self):
+        return Scope([self])
 
 class StaticScope(AbstractScope):
 
@@ -269,9 +268,8 @@ StaticScope = StaticScope()
 
 class Scope(AbstractScope):
 
-    def __init__(self, parents = None, islist = False):
+    def __init__(self, parents = None):
         super().__init__([StaticScope] if parents is None else parents)
-        self.islist = islist
 
     def resolve(self, scope):
         return self

{aridity-91 → aridity-93}/aridity/search.py

@@ -1,4 +1,4 @@
-from .util import popattr, UnparseNoSuchPathException
+from .util import inf, popattr, UnparseNoSuchPathException
 from collections import namedtuple
 from itertools import islice
 import heapq
@@ -18,12 +18,12 @@ class Address(namedtuple('BaseAddress', 'scope key')): pass
 class Hit(namedtuple('BaseHit', 'depths address resolvable')):
 
     def naiveresolve(self):
-        return self.resolvable.resolve(self.address.scope) # XXX: Wise?
+        return self.resolvable if self.address is None else self.resolvable.resolve(self.address.scope) # XXX: Wise?
 
-    def iterornone(self, word):
+    def iterornone(self, word, inprefix):
         contextscope = self.naiveresolve()
         if hasattr(contextscope, 'resolvableornone'):
-            return Iterator(self.depths, contextscope, word)
+            return Iterator(self.depths, contextscope, word, inprefix)
 
     def shortcut(self, zerocount):
         return all(not d for d in islice(self.depths, len(self.depths) - zerocount, None))
@@ -35,13 +35,15 @@ class Iterable:
 
 class Iterator(Iterable):
 
-    def __init__(self, depths, contextscope, word):
+    def __init__(self, depths, contextscope, word, inprefix):
         def g():
             for depth, scopes in enumerate(contextscope.scopedepths()):
                 for scope in scopes:
                     resolvable = scope.resolvableornone(word)
                     if resolvable is not None:
                         yield Hit(depths + [depth], Address(scope, word), resolvable)
+            if inprefix:
+                yield Hit(depths + [inf], None, contextscope)
         self.iterator = g()
 
     def next(self):
@@ -68,56 +70,48 @@ def _lt(*depthspair):
         if d1 > d2:
             break
 
-class Sump:
-
-    besthit = None
-
-    def add(self, iterable):
-        pass
-
-    def offer(self, hit):
-        if self.besthit is None or _lt(hit.depths, self.besthit.depths):
-            self.besthit = hit
-
-    def __iter__(self):
-        if self.besthit is not None:
-            yield self.besthit
-
 class Query:
 
-    def __init__(self, path):
+    def __init__(self, prefix, path):
         assert path
-        self.path = path
+        self.prefixlen = len(prefix)
+        self.path = [*prefix, *path]
 
-    def search(self, scope):
-        root = Iterator([], scope, self.path[0])
+    def _search(self, scope):
+        merges = [Iterator([], scope, self.path[0], self.prefixlen)]
         size = len(self.path)
-        if 1 == size:
-            for hit in root:
-                return hit
-        else:
-            merges = [root]
-            for _ in range(size - 2):
-                merges.append(Merge())
-            sump = Sump()
-            merges.append(sump)
-            for cursor, merge in enumerate(merges):
-                xs = range(cursor + 1, size)
-                for hit in sump:
-                    if hit.shortcut(len(xs)):
-                        return hit
-                for hit in merge:
-                    for x in xs:
-                        i = hit.iterornone(self.path[x])
-                        if i is None:
-                            break
-                        try:
-                            hit = i.next()
-                        except StopIteration:
-                            break
-                        merges[x].add(i)
-                    else:
-                        if hit.shortcut(len(xs)):
-                            return hit
-                        sump.offer(hit)
+        for _ in range(1, size):
+            merges.append(Merge())
+        for cursor, merge in enumerate(merges):
+            zerocount = size - cursor - 1
+            yield None, zerocount
+            for hit in merge:
+                for x in range(cursor + 1, size):
+                    i = hit.iterornone(self.path[x], x < self.prefixlen)
+                    if i is None:
+                        break
+                    try:
+                        hit = i.next()
+                    except StopIteration:
+                        break
+                    merges[x].add(i)
+                else:
+                    yield hit, zerocount
+
+    def findall(self, scope):
+        for hit, _ in self._search(scope):
+            if hit is not None:
+                yield hit
+
+    def search(self, scope):
+        besthit = None
+        for hit, zc in self._search(scope):
+            if hit is None:
+                if besthit is not None and besthit.shortcut(zc):
+                    return besthit
+            else:
+                if hit.shortcut(zc):
+                    return hit
+                if besthit is None or _lt(hit.depths, besthit.depths):
+                    besthit = hit
         raise UnparseNoSuchPathException(self.path)

{aridity-91 → aridity-93}/aridity/util.py

@@ -1,7 +1,8 @@
 from importlib.metadata import entry_points
-import collections, sys
+import sys
 
 dotpy = '.py'
+inf = float('inf')
 null_exc_info = None, None, None
 
 class NoSuchPathException(Exception): pass
@@ -16,7 +17,7 @@ class TreeNoSuchPathException(NoSuchPathException):
 
     def __str__(self):
         path, causes = self.args # XXX: Also collect (and show) where in the tree the causes happened?
-        causestrtocount = collections.OrderedDict()
+        causestrtocount = {}
         for causestr in map(str, causes):
             try:
                 causestrtocount[causestr] += 1
@@ -34,52 +35,6 @@ class CycleException(UnparseNoSuchPathException): pass
 
 class UnsupportedEntryException(Exception): pass
 
-class OrderedDictWrapper:
-
-    def __init__(self, *args):
-        self.d = collections.OrderedDict(*args)
-
-    def __bool__(self):
-        return bool(self.d)
-
-    def __nonzero__(self):
-        return self.__bool__()
-
-class OrderedDict(OrderedDictWrapper):
-
-    def __setitem__(self, k, v):
-        self.d[k] = v
-
-    def __getitem__(self, k):
-        return self.d[k]
-
-    def __delitem__(self, k):
-        del self.d[k]
-
-    def get(self, k, default = None):
-        return self.d.get(k, default)
-
-    def keys(self):
-        return self.d.keys()
-
-    def values(self):
-        return self.d.values()
-
-    def items(self):
-        return self.d.items()
-
-    def __iter__(self):
-        return iter(self.d.values())
-
-    def __eq__(self, that):
-        return self.d == that
-
-    def __repr__(self):
-        return repr(self.d)
-
-    def update(self, other):
-        return self.d.update(other)
-
 def openresource(package_or_name, resource_name, encoding = 'ascii'):
     'Like `pkg_resources.resource_stream` but text mode.'
     from .model import Resource

{aridity-91 → aridity-93}/aridity.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aridity
-Version: 91
+Version: 93
 Summary: DRY config and template system, easily extensible with Python
 Home-page: https://pypi.org/project/aridity/
 Author: foyono
@@ -191,6 +191,17 @@ def plusequals(prefix, suffix, scope)
 
 Assign expression to prefix plus an opaque key, i.e. add to list.
 
+<a id="aridity.directives.commaequals"></a>
+
+###### commaequals
+
+```python
+@prime
+def commaequals(prefix, suffix, scope)
+```
+
+Split expression on whitespace and make a list out of the parts.
+
 <a id="aridity.functions"></a>
 
 ### aridity.functions
@@ -474,7 +485,7 @@ class AbstractScope(Resolvable)
 ###### resolved
 
 ```python
-def resolved(*path, **kwargs)
+def resolved(*path)
 ```
 
 Follow the given path to get an expression, evaluate it (resolving any paths it requires, recursively), and return the resulting model object.

{aridity-91 → aridity-93}/setup.py

@@ -49,7 +49,7 @@ class SourceInfo:
 sourceinfo = SourceInfo('.')
 setup(
     name = 'aridity',
-    version = '91',
+    version = '93',
     description = 'DRY config and template system, easily extensible with Python',
     url = 'https://pypi.org/project/aridity/',
     author = 'foyono',

aridity-91/aridity/resolve.py

@@ -1,83 +0,0 @@
-from .search import Query
-from .util import CycleException, NoSuchPathException, TreeNoSuchPathException
-from itertools import chain
-
-def _slices(path):
-    yield path
-    limit = len(path) + 1
-    for k in range(1, limit):
-        for i in range(limit - k):
-            yield path[:i] + path[i + k:]
-
-class BaseResolveContext:
-
-    @property
-    def label(self):
-        return self.leafscope().label
-
-    @property
-    def parents(self):
-        return self.leafscope().parents
-
-    @property
-    def resolvables(self):
-        return self.leafscope().resolvables
-
-    def createchild(self, **kwargs):
-        return self.leafscope().createchild(**kwargs)
-
-    def getresolvecontext(self):
-        return self
-
-    def resolvableornone(self, key):
-        return self.leafscope().resolvableornone(key)
-
-    def resolved(self, *path, **kwargs):
-        return self.resolvedimpl(path, kwargs) if path else self.leafscope()
-
-    def staticscope(self):
-        return self.leafscope().staticscope()
-
-class AnchorResolveContext(BaseResolveContext):
-
-    def __init__(self, anchorscope):
-        self.anchorscope = anchorscope
-
-    def leafscope(self):
-        return self.anchorscope
-
-    def resolvedimpl(self, path, kwargs):
-        hit = Query(path).search(self.anchorscope)
-        return hit.resolvable.resolve(ResolveContext(self.anchorscope, path, [hit.address]), **kwargs)
-
-class ResolveContext(BaseResolveContext):
-
-    @classmethod
-    def _of(cls, *args):
-        return cls(*args)
-
-    def __init__(self, anchorscope, exprpath, addresses):
-        self.anchorscope = anchorscope
-        self.scopepath = exprpath[:-1]
-        self.exprpath = exprpath
-        self.addresses = addresses
-
-    def leafscope(self):
-        return Query(self.scopepath).search(self.anchorscope).naiveresolve() if self.scopepath else self.anchorscope # XXX: Is naiveresolve correct here?
-
-    def resolvedimpl(self, path, kwargs):
-        errors = []
-        for prefix in _slices(self.scopepath):
-            try:
-                hit = Query(list(chain(prefix, path))).search(self.anchorscope)
-                if hit.address in self.addresses: # XXX: Could it be valid to resolve the same address recursively with 2 different contexts?
-                    raise CycleException(path)
-            except NoSuchPathException as e:
-                errors.append(e)
-                continue
-            try:
-                return hit.resolvable.resolve(self._of(self.anchorscope, list(chain(self.scopepath, path)), self.addresses + [hit.address]), **kwargs)
-            except NoSuchPathException as e:
-                errors.append(e)
-                break # XXX: Or continue?
-        raise TreeNoSuchPathException(self.exprpath, errors)