Support negative indexes

Author: moomoohk

dpath/segments.py

@@ -4,7 +4,7 @@
 
 from dpath import options
 from dpath.exceptions import InvalidGlob, InvalidKeyName, PathNotFound
-from dpath.types import PathSegment, Creator, Hints
+from dpath.types import PathSegment, Creator, Hints, Glob, Path, CyclicInt
 
 
 def make_walkable(node) -> Iterator[Tuple[PathSegment, Any]]:
@@ -21,7 +21,10 @@ def make_walkable(node) -> Iterator[Tuple[PathSegment, Any]]:
         return iter(node.items())
     except AttributeError:
         try:
-            return zip(range(len(node)), node)
+            indices = range(len(node))
+            # Make all list indices cyclic so negative (wraparound) indexes are supported
+            indices = map(lambda i: CyclicInt(i, len(node)), indices)
+            return zip(indices, node)
         except TypeError:
             # This can happen in cases where the node isn't leaf(node) == True,
             # but also isn't actually iterable. Instead of this being an error
@@ -163,7 +166,7 @@ class Star(object):
 STAR = Star()
 
 
-def match(segments: Sequence[PathSegment], glob: Sequence[str]):
+def match(segments: Path, glob: Glob):
     """
     Return True if the segments match the given glob, otherwise False.
 
@@ -214,7 +217,9 @@ def match(segments: Sequence[PathSegment], glob: Sequence[str]):
     # If we were successful in matching up the lengths, then we can
     # compare them using fnmatch.
     if path_len == len(ss_glob):
-        for s, g in zip(map(int_str, segments), map(int_str, ss_glob)):
+        # TODO: Delete if not needed (previous code) - i = zip(map(int_str, segments), map(int_str, ss_glob))
+        i = zip(segments, ss_glob)
+        for s, g in i:
             # Match the stars we added to the glob to the type of the
             # segment itself.
             if g is STAR:
@@ -223,10 +228,15 @@ def match(segments: Sequence[PathSegment], glob: Sequence[str]):
                 else:
                     g = '*'
 
-            # Let's see if the glob matches. We will turn any kind of
-            # exception while attempting to match into a False for the
-            # match.
             try:
+                # If search path segment (s) is an int and the current evaluated index (g) is int-like,
+                #   then g is surely a sequence index. Convert it to int and compare.
+                if isinstance(s, int) and isinstance(g, str) and (g.count("-") == 0 or g.lstrip("-").isdigit()):
+                    return s == int(g)
+
+                # Let's see if the glob matches. We will turn any kind of
+                # exception while attempting to match into a False for the
+                # match.
                 if not fnmatchcase(s, g):
                     return False
             except:

dpath/types.py

@@ -2,6 +2,28 @@
 from typing import Union, Any, Callable, Sequence, Tuple, List, Optional, MutableMapping
 
 
+class CyclicInt(int):
+    """Same as a normal int but mimicks the behavior of list indexes (can be compared to a negative number)"""
+
+    def __new__(cls, value, max_value, *args, **kwargs):
+        if value >= max_value:
+            raise TypeError(
+                f"Tried to initiate a CyclicInt with a value ({value}) "
+                f"greater than the provided max value ({max_value})"
+            )
+
+        obj = super().__new__(cls, value)
+        obj.max_value = max_value
+
+        return obj
+
+    def __eq__(self, other):
+        return int(self) == (self.max_value + other) % self.max_value
+
+    def __repr__(self):
+        return f"<CyclicInt {int(self)}/{self.max_value}>"
+
+
 class MergeType(IntFlag):
     ADDITIVE = auto()
     """List objects are combined onto one long list (NOT a set). This is the default flag."""

tests/test_search.py

@@ -236,3 +236,20 @@ def test_search_multiple_stars():
     assert res['a'][0]['b'][0]['c'] == 1
     assert res['a'][0]['b'][1]['c'] == 2
     assert res['a'][0]['b'][2]['c'] == 3
+
+
+def test_search_glob_list():
+    d = {'a': {'b': []}}
+    res = dpath.search(d, 'a/b/*')
+    assert res == {'a': {'b': []}}
+
+    d = {'a': {'b': [1, 2, 3]}}
+    dpath.search(d, 'a/b/*', afilter=lambda x: x > 3 if isinstance(x, int) else True)
+    assert res == {'a': {'b': []}}
+
+
+def test_search_negative_index():
+    d = {'a': {'b': [1, 2, 3]}}
+    res = dpath.search(d, 'a/b/-1')
+
+    assert res == dpath.search(d, "a/b/2")