python-jsonpath 1.2.1__tar.gz → 1.3.0__tar.gz

{python_jsonpath-1.2.1 → python_jsonpath-1.3.0}/PKG-INFO

@@ -1,17 +1,17 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: python-jsonpath
-Version: 1.2.1
+Version: 1.3.0
 Summary: JSONPath, JSON Pointer and JSON Patch for Python.
 Project-URL: Documentation, https://jg-rp.github.io/python-jsonpath/
 Project-URL: Issues, https://github.com/jg-rp/python-jsonpath/issues
 Project-URL: Source, https://github.com/jg-rp/python-jsonpath
 Author-email: James Prior <jamesgr.prior@gmail.com>
-License: MIT
+License-Expression: MIT
+License-File: LICENSE.txt
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 
 <h1 align="center">Python JSONPath</h1>

{python_jsonpath-1.2.1 → python_jsonpath-1.3.0}/jsonpath/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2023-present James Prior <jamesgr.prior@gmail.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "1.2.1"
+__version__ = "1.3.0"

{python_jsonpath-1.2.1 → python_jsonpath-1.3.0}/jsonpath/__init__.py

@@ -24,6 +24,7 @@ from .fluent_api import Projection
 from .fluent_api import Query
 from .lex import Lexer
 from .match import JSONPathMatch
+from .match import NodeList
 from .parse import Parser
 from .patch import JSONPatch
 from .path import CompoundJSONPath
@@ -58,6 +59,7 @@ __all__ = (
     "JSONPointerResolutionError",
     "JSONPointerTypeError",
     "Lexer",
+    "NodeList",
     "match",
     "Parser",
     "Projection",

{python_jsonpath-1.2.1 → python_jsonpath-1.3.0}/jsonpath/filter.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import copy
-import json
 import re
 from abc import ABC
 from abc import abstractmethod
@@ -25,6 +24,7 @@ from .function_extensions import FilterFunction
 from .match import NodeList
 from .selectors import Filter as FilterSelector
 from .selectors import ListSelector
+from .serialize import canonical_string
 
 if TYPE_CHECKING:
     from .path import JSONPath
@@ -208,7 +208,7 @@ class StringLiteral(Literal[str]):
     __slots__ = ()
 
     def __str__(self) -> str:
-        return json.dumps(self.value)
+        return canonical_string(self.value)
 
 
 class IntegerLiteral(Literal[int]):
@@ -375,6 +375,12 @@ class InfixExpression(FilterExpression):
         self.right = children[1]
 
 
+PRECEDENCE_LOWEST = 1
+PRECEDENCE_LOGICAL_OR = 3
+PRECEDENCE_LOGICAL_AND = 4
+PRECEDENCE_PREFIX = 7
+
+
 class BooleanExpression(FilterExpression):
     """An expression that always evaluates to `True` or `False`."""
 
@@ -408,13 +414,40 @@ class BooleanExpression(FilterExpression):
         )
 
     def __str__(self) -> str:
-        return str(self.expression)
+        return self._canonical_string(self.expression, PRECEDENCE_LOWEST)
 
     def __eq__(self, other: object) -> bool:
         return (
             isinstance(other, BooleanExpression) and self.expression == other.expression
         )
 
+    def _canonical_string(
+        self, expression: FilterExpression, parent_precedence: int
+    ) -> str:
+        if isinstance(expression, InfixExpression):
+            if expression.operator == "&&":
+                left = self._canonical_string(expression.left, PRECEDENCE_LOGICAL_AND)
+                right = self._canonical_string(expression.right, PRECEDENCE_LOGICAL_AND)
+                expr = f"{left} && {right}"
+                return (
+                    f"({expr})" if parent_precedence >= PRECEDENCE_LOGICAL_AND else expr
+                )
+
+            if expression.operator == "||":
+                left = self._canonical_string(expression.left, PRECEDENCE_LOGICAL_OR)
+                right = self._canonical_string(expression.right, PRECEDENCE_LOGICAL_OR)
+                expr = f"{left} || {right}"
+                return (
+                    f"({expr})" if parent_precedence >= PRECEDENCE_LOGICAL_OR else expr
+                )
+
+        if isinstance(expression, PrefixExpression):
+            operand = self._canonical_string(expression.right, PRECEDENCE_PREFIX)
+            expr = f"!{operand}"
+            return f"({expr})" if parent_precedence > PRECEDENCE_PREFIX else expr
+
+        return str(expression)
+
     def evaluate(self, context: FilterContext) -> bool:
         return context.env.is_truthy(self.expression.evaluate(context))
 

{python_jsonpath-1.2.1 → python_jsonpath-1.3.0}/jsonpath/lex.py

@@ -88,13 +88,13 @@ class Lexer:
     key_pattern = r"[\u0080-\uFFFFa-zA-Z_][\u0080-\uFFFFa-zA-Z0-9_-]*"
 
     # `not` or !
-    logical_not_pattern = r"(?:not|!)"
+    logical_not_pattern = r"(?:not\b)|!"
 
     # && or `and`
-    logical_and_pattern = r"(?:&&|and)"
+    logical_and_pattern = r"&&|(?:and\b)"
 
     # || or `or`
-    logical_or_pattern = r"(?:\|\||or)"
+    logical_or_pattern = r"\|\||(?:or\b)"
 
     def __init__(self, *, env: JSONPathEnvironment) -> None:
         self.env = env
@@ -153,15 +153,15 @@ class Lexer:
             ],
             (TOKEN_WILD, r"\*"),
             (TOKEN_FILTER, r"\?"),
-            (TOKEN_IN, r"in"),
-            (TOKEN_TRUE, r"[Tt]rue"),
-            (TOKEN_FALSE, r"[Ff]alse"),
-            (TOKEN_NIL, r"[Nn]il"),
-            (TOKEN_NULL, r"[Nn]ull"),
-            (TOKEN_NONE, r"[Nn]one"),
-            (TOKEN_CONTAINS, r"contains"),
-            (TOKEN_UNDEFINED, r"undefined"),
-            (TOKEN_MISSING, r"missing"),
+            (TOKEN_IN, r"in\b"),
+            (TOKEN_TRUE, r"[Tt]rue\b"),
+            (TOKEN_FALSE, r"[Ff]alse\b"),
+            (TOKEN_NIL, r"[Nn]il\b"),
+            (TOKEN_NULL, r"[Nn]ull\b"),
+            (TOKEN_NONE, r"[Nn]one\b"),
+            (TOKEN_CONTAINS, r"contains\b"),
+            (TOKEN_UNDEFINED, r"undefined\b"),
+            (TOKEN_MISSING, r"missing\b"),
             (TOKEN_LIST_START, r"\["),
             (TOKEN_RBRACKET, r"]"),
             (TOKEN_COMMA, r","),

{python_jsonpath-1.2.1 → python_jsonpath-1.3.0}/jsonpath/match.py

@@ -1,4 +1,5 @@
 """The JSONPath match object, as returned from `JSONPath.finditer()`."""
+
 from __future__ import annotations
 
 from typing import Any
@@ -104,6 +105,10 @@ class NodeList(List[JSONPathMatch]):
             return self[0].obj
         return [match.obj for match in self]
 
+    def paths(self) -> List[str]:
+        """Return a normalized path for each node in this node list."""
+        return [match.path for match in self]
+
     def empty(self) -> bool:
         """Return `True` if this node list is empty."""
         return not bool(self)

{python_jsonpath-1.2.1 → python_jsonpath-1.3.0}/jsonpath/selectors.py

@@ -1,4 +1,5 @@
 """JSONPath segments and selectors, as returned from `Parser.parse`."""
+
 from __future__ import annotations
 
 from abc import ABC
@@ -17,6 +18,7 @@ from typing import Union
 
 from .exceptions import JSONPathIndexError
 from .exceptions import JSONPathTypeError
+from .serialize import canonical_string
 
 if TYPE_CHECKING:
     from .env import JSONPathEnvironment
@@ -75,7 +77,11 @@ class PropertySelector(JSONPathSelector):
         self.shorthand = shorthand
 
     def __str__(self) -> str:
-        return f"['{self.name}']" if self.shorthand else f"'{self.name}'"
+        return (
+            f"[{canonical_string(self.name)}]"
+            if self.shorthand
+            else f"{canonical_string(self.name)}"
+        )
 
     def __eq__(self, __value: object) -> bool:
         return (
@@ -98,7 +104,7 @@ class PropertySelector(JSONPathSelector):
                     obj=self.env.getitem(match.obj, self.name),
                     parent=match,
                     parts=match.parts + (self.name,),
-                    path=match.path + f"['{self.name}']",
+                    path=match.path + f"[{canonical_string(self.name)}]",
                     root=match.root,
                 )
                 match.add_child(_match)
@@ -117,7 +123,7 @@ class PropertySelector(JSONPathSelector):
                     obj=await self.env.getitem_async(match.obj, self.name),
                     parent=match,
                     parts=match.parts + (self.name,),
-                    path=match.path + f"['{self.name}']",
+                    path=match.path + f"[{canonical_string(self.name)}]",
                     root=match.root,
                 )
                 match.add_child(_match)
@@ -321,20 +327,15 @@ class SliceSelector(JSONPathSelector):
             ):
                 raise JSONPathIndexError("index out of range", token=self.token)
 
-    def _normalized_index(self, obj: Sequence[object], index: int) -> int:
-        if index < 0 and len(obj) >= abs(index):
-            return len(obj) + index
-        return index
-
     def resolve(self, matches: Iterable[JSONPathMatch]) -> Iterable[JSONPathMatch]:
         for match in matches:
             if not isinstance(match.obj, Sequence) or self.slice.step == 0:
                 continue
 
-            idx = self.slice.start or 0
-            step = self.slice.step or 1
-            for obj in self.env.getitem(match.obj, self.slice):
-                norm_index = self._normalized_index(match.obj, idx)
+            for norm_index, obj in zip(  # noqa: B905
+                range(*self.slice.indices(len(match.obj))),
+                self.env.getitem(match.obj, self.slice),
+            ):
                 _match = self.env.match_class(
                     filter_context=match.filter_context(),
                     obj=obj,
@@ -345,7 +346,6 @@ class SliceSelector(JSONPathSelector):
                 )
                 match.add_child(_match)
                 yield _match
-                idx += step
 
     async def resolve_async(
         self, matches: AsyncIterable[JSONPathMatch]
@@ -354,10 +354,10 @@ class SliceSelector(JSONPathSelector):
             if not isinstance(match.obj, Sequence) or self.slice.step == 0:
                 continue
 
-            idx = self.slice.start or 0
-            step = self.slice.step or 1
-            for obj in await self.env.getitem_async(match.obj, self.slice):
-                norm_index = self._normalized_index(match.obj, idx)
+            for norm_index, obj in zip(  # noqa: B905
+                range(*self.slice.indices(len(match.obj))),
+                await self.env.getitem_async(match.obj, self.slice),
+            ):
                 _match = self.env.match_class(
                     filter_context=match.filter_context(),
                     obj=obj,
@@ -368,7 +368,6 @@ class SliceSelector(JSONPathSelector):
                 )
                 match.add_child(_match)
                 yield _match
-                idx += step
 
 
 class WildSelector(JSONPathSelector):
@@ -402,7 +401,7 @@ class WildSelector(JSONPathSelector):
                         obj=val,
                         parent=match,
                         parts=match.parts + (key,),
-                        path=match.path + f"['{key}']",
+                        path=match.path + f"[{canonical_string(key)}]",
                         root=match.root,
                     )
                     match.add_child(_match)
@@ -431,7 +430,7 @@ class WildSelector(JSONPathSelector):
                         obj=val,
                         parent=match,
                         parts=match.parts + (key,),
-                        path=match.path + f"['{key}']",
+                        path=match.path + f"[{canonical_string(key)}]",
                         root=match.root,
                     )
                     match.add_child(_match)
@@ -479,7 +478,7 @@ class RecursiveDescentSelector(JSONPathSelector):
                         obj=val,
                         parent=match,
                         parts=match.parts + (key,),
-                        path=match.path + f"['{key}']",
+                        path=match.path + f"[{canonical_string(key)}]",
                         root=match.root,
                     )
                     match.add_child(_match)
@@ -633,7 +632,7 @@ class Filter(JSONPathSelector):
                                 obj=val,
                                 parent=match,
                                 parts=match.parts + (key,),
-                                path=match.path + f"['{key}']",
+                                path=match.path + f"[{canonical_string(key)}]",
                                 root=match.root,
                             )
                             match.add_child(_match)
@@ -701,7 +700,7 @@ class Filter(JSONPathSelector):
                             obj=val,
                             parent=match,
                             parts=match.parts + (key,),
-                            path=match.path + f"['{key}']",
+                            path=match.path + f"[{canonical_string(key)}]",
                             root=match.root,
                         )
                         match.add_child(_match)

python_jsonpath-1.3.0/jsonpath/serialize.py

@@ -0,0 +1,13 @@
+"""Helper functions for serializing compiled JSONPath queries."""
+
+import json
+
+
+def canonical_string(value: str) -> str:
+    """Return _value_ as a canonically formatted string literal."""
+    single_quoted = (
+        json.dumps(value, ensure_ascii=False)[1:-1]
+        .replace('\\"', '"')
+        .replace("'", "\\'")
+    )
+    return f"'{single_quoted}'"

{python_jsonpath-1.2.1 → python_jsonpath-1.3.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 name = "python-jsonpath"
 description = 'JSONPath, JSON Pointer and JSON Patch for Python.'
 readme = "README.md"
-requires-python = ">=3.7"
+requires-python = ">=3.8"
 license = "MIT"
 keywords = []
 authors = [{ name = "James Prior", email = "jamesgr.prior@gmail.com" }]
@@ -15,7 +15,6 @@ classifiers = [
   "Intended Audience :: Developers",
   "License :: OSI Approved :: MIT License",
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.7",
   "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
@@ -67,7 +66,7 @@ lint = "ruff check ."
 typing = "mypy"
 
 [[tool.hatch.envs.test.matrix]]
-python = ["37", "38", "39", "310", "311", "312", "pypy38", "pypy39"]
+python = ["38", "39", "310", "311", "312", "pypy38", "pypy39"]
 
 [tool.hatch.envs.test.scripts]
 test = "pytest {args}"
@@ -168,7 +167,7 @@ select = [
   "YTT",
 ]
 
-ignore = ["S105", "S101", "D107", "D105", "PLR0913", "SIM108", "PT001"]
+ignore = ["S105", "S101", "D107", "D105", "PLR0913", "SIM108", "PT001", "A005"]
 
 fixable = ["I"]
 unfixable = []