Merge pull request #4 from zhangxianbing/zxb/dev

feat: support child operator in field-selector

Author: sean2077

README.md

@@ -18,13 +18,23 @@ A more powerful JSONPath implementation in modern python.
 
 ## Features
 
-- [x] Light. (No need to install third-party dependencies.)
+- [x] **Light. (No need to install third-party dependencies.)**
+- [x] **Support filter operator, including multi-selection, inverse-selection filtering.**
+- [x] **Support sorter operator, including sorting by multiple fields, ascending and descending order.**
 - [x] Support basic semantics of JSONPath.
 - [x] Support output modes: VALUE, PATH.
-- [x] Support filter operator, including multi-selection, inverse-selection filtering.
-- [x] Support sorter operator, including sorting by multiple fields, ascending and descending order.
-- [ ] Support parent operator.
+- [ ] Support embedded syntax.
 - [ ] Support user-defined function.
+- [ ] Support parent operator.
+
+## Installation
+
+```bash
+pip install jsonpath-python
+
+# import
+>>> from jsonpath import JSONPath
+```
 
 ## JSONPath Syntax
 

jsonpath/__init__.py

@@ -2,7 +2,7 @@
 Author       : zhangxianbing
 Date         : 2020-12-27 09:22:14
 LastEditors  : zhangxianbing
-LastEditTime : 2021-02-07 10:10:55
+LastEditTime : 2021-03-02 15:18:06
 Description  : JSONPath
 """
 __version__ = "1.0.3"
@@ -36,7 +36,7 @@ def create_logger(name: str = None, level: Union[int, str] = logging.INFO):
     return logger
 
 
-LOG = create_logger("jsonpath", os.getenv("PYLOGLEVEL", "INFO"))
+logger = create_logger("jsonpath", os.getenv("PYLOGLEVEL", "INFO"))
 
 
 class ExprSyntaxError(Exception):
@@ -49,15 +49,19 @@ class JSONPath:
         "PATH": "All path of specific values.",
     }
 
+    # common patterns
     SEP = ";"
-    # regex patterns
-    REP_PICKUP_QUOTE = re.compile(r"['](.*?)[']")
-    REP_PICKUP_BRACKET = re.compile(r"[\[](.*?)[\]]")
-    REP_PUTBACK_QUOTE = re.compile(r"#Q(\d+)")
-    REP_PUTBACK_BRACKET = re.compile(r"#B(\d+)")
     REP_DOUBLEDOT = re.compile(r"\.\.")
     REP_DOT = re.compile(r"(?<!\.)\.(?!\.)")
 
+    # save special patterns
+    REP_GET_QUOTE = re.compile(r"['](.*?)[']")
+    REP_PUT_QUOTE = re.compile(r"#Q(\d+)")
+    REP_GET_BRACKET = re.compile(r"[\[](.*?)[\]]")
+    REP_PUT_BRACKET = re.compile(r"#B(\d+)")
+    REP_GET_PAREN = re.compile(r"[\(](.*?)[\)]")
+    REP_PUT_PAREN = re.compile(r"#P(\d+)")
+
     # operators
     REP_SLICE_CONTENT = re.compile(r"^(-?\d*)?:(-?\d*)?(:-?\d*)?$")
     REP_SELECT_CONTENT = re.compile(r"^([\w.']+)(, ?[\w.']+)+$")
@@ -76,7 +80,7 @@ def __init__(self, expr: str):
         expr = self._parse_expr(expr)
         self.segments = expr.split(JSONPath.SEP)
         self.lpath = len(self.segments)
-        LOG.debug(f"segments  : {self.segments}")
+        logger.debug(f"segments  : {self.segments}")
 
     def parse(self, obj, result_type="VALUE"):
         if not isinstance(obj, (list, dict)):
@@ -94,36 +98,46 @@ def parse(self, obj, result_type="VALUE"):
         return self.result
 
     def _parse_expr(self, expr):
-        LOG.debug(f"before expr : {expr}")
+        logger.debug(f"before expr : {expr}")
 
-        expr = JSONPath.REP_PICKUP_QUOTE.sub(self._f_pickup_quote, expr)
-        expr = JSONPath.REP_PICKUP_BRACKET.sub(self._f_pickup_bracket, expr)
+        expr = JSONPath.REP_GET_QUOTE.sub(self._get_quote, expr)
+        expr = JSONPath.REP_GET_BRACKET.sub(self._get_bracket, expr)
+        expr = JSONPath.REP_GET_PAREN.sub(self._get_paren, expr)
         expr = JSONPath.REP_DOUBLEDOT.sub(f"{JSONPath.SEP}..{JSONPath.SEP}", expr)
         expr = JSONPath.REP_DOT.sub(JSONPath.SEP, expr)
-        expr = JSONPath.REP_PUTBACK_BRACKET.sub(self._f_putback_bracket, expr)
-        expr = JSONPath.REP_PUTBACK_QUOTE.sub(self._f_putback_quote, expr)
+        expr = JSONPath.REP_PUT_PAREN.sub(self._put_paren, expr)
+        expr = JSONPath.REP_PUT_BRACKET.sub(self._put_bracket, expr)
+        expr = JSONPath.REP_PUT_QUOTE.sub(self._put_quote, expr)
         if expr.startswith("$;"):
             expr = expr[2:]
 
-        LOG.debug(f"after expr  : {expr}")
+        logger.debug(f"after expr  : {expr}")
         return expr
 
-    def _f_pickup_quote(self, m):
+    def _get_quote(self, m):
         n = len(self.subx["#Q"])
         self.subx["#Q"].append(m.group(1))
         return f"#Q{n}"
 
-    def _f_pickup_bracket(self, m):
+    def _put_quote(self, m):
+        return self.subx["#Q"][int(m.group(1))]
+
+    def _get_bracket(self, m):
         n = len(self.subx["#B"])
         self.subx["#B"].append(m.group(1))
         return f".#B{n}"
 
-    def _f_putback_quote(self, m):
-        return self.subx["#Q"][int(m.group(1))]
-
-    def _f_putback_bracket(self, m):
+    def _put_bracket(self, m):
         return self.subx["#B"][int(m.group(1))]
 
+    def _get_paren(self, m):
+        n = len(self.subx["#P"])
+        self.subx["#P"].append(m.group(1))
+        return f"(#P{n})"
+
+    def _put_paren(self, m):
+        return self.subx["#P"][int(m.group(1))]
+
     @staticmethod
     def _f_brackets(m):
         ret = "__obj"
@@ -147,7 +161,7 @@ def _getattr(obj: dict, path: str):
             try:
                 r = r.get(k)
             except (AttributeError, KeyError) as err:
-                LOG.error(err)
+                logger.error(err)
                 return None
 
         return r
@@ -167,7 +181,7 @@ def _filter(self, obj, i: int, path: str, step: str):
         try:
             r = eval(step, None, {"__obj": obj})
         except Exception as err:
-            LOG.error(err)
+            logger.error(err)
         if r:
             self._trace(obj, i, path)
 
@@ -185,7 +199,7 @@ def _trace(self, obj, i: int, path):
                 self.result.append(obj)
             elif self.result_type == "PATH":
                 self.result.append(path)
-            LOG.debug(f"path: {path} | value: {obj}")
+            logger.debug(f"path: {path} | value: {obj}")
             return
 
         step = self.segments[i]
@@ -256,18 +270,18 @@ def _trace(self, obj, i: int, path):
             if isinstance(obj, dict):
                 obj_ = {}
                 for k in step[1:-1].split(","):
-                    obj_[k] = obj.get(k)
+                    obj_[k] = self._getattr(obj, k)
                 self._trace(obj_, i + 1, path)
             else:
-                raise ExprSyntaxError("field-extractor must acting on list or dict")
+                raise ExprSyntaxError("field-extractor must acting on dict")
 
             return
 
 
 if __name__ == "__main__":
     with open("test/data/2.json", "rb") as f:
         d = json.load(f)
-    D = JSONPath("$[bicycle, scores]").parse(d, "VALUE")
+    D = JSONPath("$.scores[/(score)].(score)").parse(d, "VALUE")
     print(D)
     for v in D:
         print(v)

test/conftest.py

@@ -79,6 +79,16 @@
                 {"title": "Sayings of the Century", "price": 8.95},
             ],
         ),
+        TestCase(
+            "$.book[*].(title,brand.version)",
+            data,
+            [
+                {"title": "Sayings of the Century", "brand.version": "v1.0.0"},
+                {"title": "Sword of Honour", "brand.version": "v0.0.1"},
+                {"title": "Moby Dick", "brand.version": "v1.0.2"},
+                {"title": "The Lord of the Rings", "brand.version": "v1.0.3"},
+            ],
+        ),
     ]
 )
 def value_cases(request):