feat: add output mode: PATH

Author: sean2077

README.md

@@ -3,7 +3,6 @@
 
 - [jsonpath-python](#jsonpath-python)
   - [Features](#features)
-  - [Issues](#issues)
   - [Examples](#examples)
     - [Filter](#filter)
     - [Sort](#sort)

jsonpath/__init__.py

@@ -2,16 +2,16 @@
 Author       : zhangxianbing1
 Date         : 2020-12-27 09:22:14
 LastEditors  : zhangxianbing1
-LastEditTime : 2021-01-04 11:01:24
+LastEditTime : 2021-01-04 12:40:59
 Description  : JSONPath
 """
 __version__ = "0.0.3"
 __author__ = "zhangxianbing"
 
 import json
 import re
-from typing import Union
 from collections import defaultdict
+from typing import Union
 
 RESULT_TYPE = {
     "VALUE": "A list of specific values.",
@@ -39,10 +39,6 @@
 # pylint: disable=invalid-name,missing-function-docstring,missing-class-docstring,eval-used
 
 
-def concat(x, y, con=SEP):
-    return f"{x}{con}{y}"
-
-
 def _getattr(obj: dict, path: str):
     r = obj
     for k in path.split("."):
@@ -61,18 +57,13 @@ class ExprSyntaxError(Exception):
 
 class JSONPath:
     # annotations
-    result: Union[list, dict]
-    result_type: str
-    subx = defaultdict(list)
     steps: list
     lpath: int
+    subx = defaultdict(list)
+    result: Union[list, dict]
+    result_type: str
 
-    def __init__(self, expr: str, *, result_type="VALUE"):
-        if result_type not in RESULT_TYPE:
-            raise ValueError(f"result_type must be one of {tuple(RESULT_TYPE.keys())}")
-        self.result_type = result_type
-
-        # parse expression
+    def __init__(self, expr: str):
         expr = self._parse_expr(expr)
         self.steps = expr.split(SEP)
         self.lpath = len(self.steps)
@@ -118,38 +109,40 @@ def _f_brackets(m):
             ret += '["%s"]' % e
         return ret
 
-    def parse(self, obj):
+    def parse(self, obj, result_type="VALUE"):
         if not isinstance(obj, (list, dict)):
             raise TypeError("obj must be a list or a dict.")
-
+        if result_type not in RESULT_TYPE:
+            raise ValueError(f"result_type must be one of {tuple(RESULT_TYPE.keys())}")
+        self.result_type = result_type
         if self.result_type == "FIELD":
             self.result = {}
         else:
             self.result = []
 
-        self._trace(obj, 0)
+        self._trace(obj, 0, "$")
 
         return self.result
 
     @staticmethod
-    def _traverse(f, obj, i: int, *args):
+    def _traverse(f, obj, i: int, path: str, *args):
         if isinstance(obj, list):
-            for v in obj:
-                f(v, i, *args)
+            for idx, v in enumerate(obj):
+                f(v, i, f"{path}{SEP}{idx}", *args)
         elif isinstance(obj, dict):
-            for v in obj.values():
-                f(v, i, *args)
+            for k, v in obj.items():
+                f(v, i, f"{path}{SEP}{k}", *args)
 
-    def _filter(self, obj, i: int, step: str):
+    def _filter(self, obj, i: int, path: str, step: str):
         r = False
         try:
             r = eval(step, None, {"__obj": obj})
         except Exception as err:
             print(err)
         if r:
-            self._trace(obj, i)
+            self._trace(obj, i, path)
 
-    def _trace(self, obj, i: int):
+    def _trace(self, obj, i: int, path):
         """Perform operation on object.
 
         Args:
@@ -159,54 +152,59 @@ def _trace(self, obj, i: int):
 
         # store
         if i >= self.lpath:
-            self.result.append(obj)
+            if self.result_type == "VALUE":
+                self.result.append(obj)
+            elif self.result_type == "PATH":
+                self.result.append(path)
+            elif self.result_type == "FIELD":
+                pass
             print(obj)
             return
 
         step = self.steps[i]
 
         # wildcard
         if step == "*":
-            self._traverse(self._trace, obj, i + 1)
+            self._traverse(self._trace, obj, i + 1, path)
             return
 
         # recursive descent
         if step == "..":
-            self._trace(obj, i + 1)
-            self._traverse(self._trace, obj, i)
+            self._trace(obj, i + 1, path)
+            self._traverse(self._trace, obj, i, path)
             return
 
         # get value from list
         if isinstance(obj, list) and step.isdigit():
             ikey = int(step)
             if ikey < len(obj):
-                self._trace(obj[ikey], i + 1)
+                self._trace(obj[ikey], i + 1, f"{path}{SEP}{step}")
             return
 
         # get value from dict
         if isinstance(obj, dict) and step in obj:
-            self._trace(obj[step], i + 1)
+            self._trace(obj[step], i + 1, f"{path}{SEP}{step}")
             return
 
         # slice
         if isinstance(obj, list) and REP_SLICE_CONTENT.fullmatch(step):
             vals = eval(f"obj[{step}]")
-            for v in vals:
-                self._trace(v, i + 1)
+            for idx, v in enumerate(vals):
+                self._trace(v, i + 1, f"{path}{SEP}{idx}")
             return
 
         # select
         if isinstance(obj, dict) and REP_SELECT_CONTENT.fullmatch(step):
             for k in step.split(","):
                 if k in obj:
-                    self._trace(obj[k], i + 1)
+                    self._trace(obj[k], i + 1, f"{path}{SEP}{k}")
             return
 
         # filter
         if step.startswith("?(") and step.endswith(")"):
             step = step[2:-1]
             step = REP_FILTER_CONTENT.sub(self._f_brackets, step)
-            self._traverse(self._filter, obj, i + 1, step)
+            self._traverse(self._filter, obj, i + 1, path, step)
             return
 
         # sort
@@ -229,11 +227,12 @@ def _trace(self, obj, i: int):
                     else:
                         obj.sort(key=lambda t, k=sortby: _getattr(t[1], k))
                 obj = {k: v for k, v in obj}
-            self._traverse(self._trace, obj, i + 1)
+            self._traverse(self._trace, obj, i + 1, path)
             return
 
 
 if __name__ == "__main__":
     with open("test/data/2.json", "rb") as f:
         d = json.load(f)
-    JSONPath("$.scores[/(score)].score").parse(d)
+    D = JSONPath("$.scores[/(score)].score").parse(d, "PATH")
+    print(D)

test/conftest.py

@@ -50,5 +50,50 @@
         TestCase("$.scores[/(score)].score", data, [60, 85, 90, 95, 100]),
     ]
 )
-def cases(request):
+def value_cases(request):
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        TestCase("$.*", data, list(data.values())),
+        TestCase("$.book", data, [data["book"]]),
+        TestCase("$[book]", data, [data["book"]]),
+        TestCase("$.'a.b c'", data, [data["a.b c"]]),
+        TestCase("$['a.b c']", data, [data["a.b c"]]),
+        # recursive descent
+        TestCase("$..price", data, [8.95, 12.99, 8.99, 22.99, 19.95]),
+        # slice
+        TestCase("$.book[1:3]", data, data["book"][1:3]),
+        TestCase("$.book[1:-1]", data, data["book"][1:-1]),
+        TestCase("$.book[0:-1:2]", data, data["book"][0:-1:2]),
+        TestCase("$.book[-1:1]", data, data["book"][-1:1]),
+        TestCase("$.book[-1:-11:3]", data, data["book"][-1:-11:3]),
+        TestCase("$.book[:]", data, data["book"][:]),
+        # filter
+        TestCase("$.book[?(@.price>8 and @.price<9)].price", data, [8.95, 8.99]),
+        TestCase('$.book[?(@.category=="reference")].category', data, ["reference"]),
+        TestCase(
+            '$.book[?(@.category!="reference" and @.price<9)].title',
+            data,
+            ["Moby Dick"],
+        ),
+        TestCase(
+            '$.book[?(@.author=="Herman Melville" or @.author=="Evelyn Waugh")].author',
+            data,
+            ["Evelyn Waugh", "Herman Melville"],
+        ),
+        # sort
+        TestCase("$.book[/(price)].price", data, [8.95, 8.99, 12.99, 22.99]),
+        TestCase("$.book[/(~price)].price", data, [22.99, 12.99, 8.99, 8.95]),
+        TestCase("$.book[/(category,price)].price", data, [8.99, 12.99, 22.99, 8.95]),
+        TestCase(
+            "$.book[/(brand.version)].brand.version",
+            data,
+            ["v0.0.1", "v1.0.0", "v1.0.2", "v1.0.3"],
+        ),
+        TestCase("$.scores[/(score)].score", data, [60, 85, 90, 95, 100]),
+    ]
+)
+def path_cases(request):
     return request.param

test/test_jsonpath.py

@@ -1,5 +1,10 @@
 from jsonpath import JSONPath
 
 
-def test_cases(cases):
-    assert cases.result == JSONPath(cases.expr).parse(cases.data)
+def test_value_cases(value_cases):
+    assert value_cases.result == JSONPath(value_cases.expr).parse(value_cases.data)
+
+
+def test_path_cases(path_cases):
+    print(JSONPath(path_cases.expr).parse(path_cases.data, "PATH"))
+    # assert path_cases.result == JSONPath(path_cases.expr).parse(path_cases.data, "PATH")