python-jsonpath 1.1.0__tar.gz → 1.1.1__tar.gz

{python_jsonpath-1.1.0 → python_jsonpath-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-jsonpath
-Version: 1.1.0
+Version: 1.1.1
 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

{python_jsonpath-1.1.0 → python_jsonpath-1.1.1}/jsonpath/__about__.py

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

{python_jsonpath-1.1.0 → python_jsonpath-1.1.1}/jsonpath/__init__.py

@@ -31,12 +31,10 @@ from .pointer import resolve
 __all__ = (
     "compile",
     "CompoundJSONPath",
-    "find",
     "findall_async",
     "findall",
     "finditer_async",
     "finditer",
-    "first",
     "JSONPatch",
     "JSONPath",
     "JSONPathEnvironment",

{python_jsonpath-1.1.0 → python_jsonpath-1.1.1}/jsonpath/filter.py

@@ -318,7 +318,7 @@ class PrefixExpression(FilterExpression):
 class InfixExpression(FilterExpression):
     """A pair of expressions and a comparison or logical operator."""
 
-    __slots__ = ("left", "operator", "right")
+    __slots__ = ("left", "operator", "right", "logical")
 
     def __init__(
         self,
@@ -329,10 +329,11 @@ class InfixExpression(FilterExpression):
         self.left = left
         self.operator = operator
         self.right = right
+        self.logical = operator in ("&&", "||")
         super().__init__()
 
     def __str__(self) -> str:
-        if self.operator in ("&&", "||"):
+        if self.logical:
             return f"({self.left} {self.operator} {self.right})"
         return f"{self.left} {self.operator} {self.right}"
 
@@ -346,22 +347,22 @@ class InfixExpression(FilterExpression):
 
     def evaluate(self, context: FilterContext) -> bool:
         left = self.left.evaluate(context)
-        if isinstance(left, NodeList) and len(left) == 1:
+        if not self.logical and isinstance(left, NodeList) and len(left) == 1:
             left = left[0].obj
 
         right = self.right.evaluate(context)
-        if isinstance(right, NodeList) and len(right) == 1:
+        if not self.logical and isinstance(right, NodeList) and len(right) == 1:
             right = right[0].obj
 
         return context.env.compare(left, self.operator, right)
 
     async def evaluate_async(self, context: FilterContext) -> bool:
         left = await self.left.evaluate_async(context)
-        if isinstance(left, NodeList) and len(left) == 1:
+        if not self.logical and isinstance(left, NodeList) and len(left) == 1:
             left = left[0].obj
 
         right = await self.right.evaluate_async(context)
-        if isinstance(right, NodeList) and len(right) == 1:
+        if not self.logical and isinstance(right, NodeList) and len(right) == 1:
             right = right[0].obj
 
         return context.env.compare(left, self.operator, right)

{python_jsonpath-1.1.0 → python_jsonpath-1.1.1}/jsonpath/selectors.py

@@ -1,4 +1,4 @@
-"""JSONPath selector objects, as returned from `Parser.parse`."""
+"""JSONPath segments and selectors, as returned from `Parser.parse`."""
 from __future__ import annotations
 
 from abc import ABC
@@ -28,7 +28,7 @@ if TYPE_CHECKING:
 
 
 class JSONPathSelector(ABC):
-    """Base class for all JSONPath selectors."""
+    """Base class for all JSONPath segments and selectors."""
 
     __slots__ = ("env", "token")
 
@@ -38,7 +38,17 @@ class JSONPathSelector(ABC):
 
     @abstractmethod
     def resolve(self, matches: Iterable[JSONPathMatch]) -> Iterable[JSONPathMatch]:
-        """Expand matches from previous JSONPath selectors in to new matches."""
+        """Apply the segment/selector to each node in _matches_.
+
+        Arguments:
+            matches: Nodes matched by preceding segments/selectors. This is like
+                a lazy _NodeList_, as described in RFC 9535, but each match carries
+                more than the node's value and location.
+
+        Returns:
+            The `JSONPathMatch` instances created by applying this selector to each
+            preceding node.
+        """
 
     @abstractmethod
     def resolve_async(
@@ -48,7 +58,7 @@ class JSONPathSelector(ABC):
 
 
 class PropertySelector(JSONPathSelector):
-    """A JSONPath property."""
+    """A shorthand or bracketed property selector."""
 
     __slots__ = ("name", "shorthand")
 
@@ -115,7 +125,12 @@ class PropertySelector(JSONPathSelector):
 
 
 class IndexSelector(JSONPathSelector):
-    """Dotted and bracketed sequence access by index."""
+    """Select an element from an array by index.
+
+    Considering we don't require mapping (JSON object) keys/properties to
+    be quoted, and that we support mappings with numeric keys, we also check
+    to see if the "index" is a mapping key, which is non-standard.
+    """
 
     __slots__ = ("index", "_as_key")
 
@@ -213,7 +228,10 @@ class IndexSelector(JSONPathSelector):
 
 
 class KeysSelector(JSONPathSelector):
-    """Select an mapping's keys/properties."""
+    """Select mapping/object keys/properties.
+
+    NOTE: This is a non-standard selector.
+    """
 
     __slots__ = ("shorthand",)
 
@@ -354,7 +372,7 @@ class SliceSelector(JSONPathSelector):
 
 
 class WildSelector(JSONPathSelector):
-    """Wildcard expansion selector."""
+    """Select all items from a sequence/array or values from a mapping/object."""
 
     __slots__ = ("shorthand",)
 
@@ -433,7 +451,10 @@ class WildSelector(JSONPathSelector):
 
 
 class RecursiveDescentSelector(JSONPathSelector):
-    """A JSONPath selector that visits all objects recursively."""
+    """A JSONPath selector that visits all nodes recursively.
+
+    NOTE: Strictly this is a "segment", not a "selector".
+    """
 
     def __str__(self) -> str:
         return ".."
@@ -504,7 +525,10 @@ async def _alist(it: List[T]) -> AsyncIterable[T]:
 
 
 class ListSelector(JSONPathSelector):
-    """A JSONPath selector representing a list of properties, slices or indices."""
+    """A bracketed list of selectors, the results of which are concatenated together.
+
+    NOTE: Strictly this is a "segment", not a "selector".
+    """
 
     __slots__ = ("items",)
 
@@ -555,7 +579,7 @@ class ListSelector(JSONPathSelector):
 
 
 class Filter(JSONPathSelector):
-    """A filter selector."""
+    """Filter sequence/array items or mapping/object values with a filter expression."""
 
     __slots__ = ("expression", "cacheable_nodes")
 
@@ -713,7 +737,7 @@ class Filter(JSONPathSelector):
 
 
 class FilterContext:
-    """A filter expression context."""
+    """Contextual information and data for evaluating a filter expression."""
 
     __slots__ = (
         "current_key",