python-jsonpath 0.10.1__tar.gz → 0.10.3__tar.gz

{python_jsonpath-0.10.1 → python_jsonpath-0.10.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-jsonpath
-Version: 0.10.1
+Version: 0.10.3
 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
@@ -36,6 +36,9 @@ A flexible JSONPath engine for Python with JSON Pointer and JSON Patch.
   <a href="https://github.com/jg-rp/python-jsonpath/actions">
     <img src="https://img.shields.io/github/actions/workflow/status/jg-rp/python-jsonpath/tests.yaml?branch=main&label=tests&style=flat-square" alt="Tests">
   </a>
+  <a href="https://pypi.org/project/python-jsonpath">
+    <img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/python-jsonpath?style=flat-square">
+  </a>
   <br>
   <a href="https://pypi.org/project/python-jsonpath">
     <img src="https://img.shields.io/pypi/v/python-jsonpath.svg?style=flat-square" alt="PyPi - Version">

{python_jsonpath-0.10.1 → python_jsonpath-0.10.3}/README.md

@@ -11,6 +11,9 @@ A flexible JSONPath engine for Python with JSON Pointer and JSON Patch.
   <a href="https://github.com/jg-rp/python-jsonpath/actions">
     <img src="https://img.shields.io/github/actions/workflow/status/jg-rp/python-jsonpath/tests.yaml?branch=main&label=tests&style=flat-square" alt="Tests">
   </a>
+  <a href="https://pypi.org/project/python-jsonpath">
+    <img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/python-jsonpath?style=flat-square">
+  </a>
   <br>
   <a href="https://pypi.org/project/python-jsonpath">
     <img src="https://img.shields.io/pypi/v/python-jsonpath.svg?style=flat-square" alt="PyPi - Version">

{python_jsonpath-0.10.1 → python_jsonpath-0.10.3}/jsonpath/__about__.py

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

{python_jsonpath-0.10.1 → python_jsonpath-0.10.3}/jsonpath/filter.py

@@ -623,7 +623,19 @@ class FunctionExtension(FilterExpression):
                 if func.arg_types[idx] != ExpressionType.NODES and isinstance(
                     arg, NodeList
                 ):
-                    _args.append(arg.values_or_singular())
+                    if len(arg) == 0:
+                        # If the query results in an empty nodelist, the
+                        # argument is the special result Nothing.
+                        _args.append(UNDEFINED)
+                    elif len(arg) == 1:
+                        # If the query results in a nodelist consisting of a
+                        # single node, the argument is the value of the node
+                        _args.append(arg[0].obj)
+                    else:
+                        # This should not be possible as a non-singular query
+                        # would have been rejected when checking function
+                        # well-typedness.
+                        _args.append(arg)
                 else:
                     _args.append(arg)
             return _args

{python_jsonpath-0.10.1 → python_jsonpath-0.10.3}/jsonpath/function_extensions/length.py

@@ -1,7 +1,9 @@
 """The standard `length` function extension."""
 from collections.abc import Sized
-from typing import Optional
+from typing import Union
 
+from jsonpath.filter import UNDEFINED
+from jsonpath.filter import _Undefined
 from jsonpath.function_extensions import ExpressionType
 from jsonpath.function_extensions import FilterFunction
 
@@ -12,9 +14,13 @@ class Length(FilterFunction):
     arg_types = [ExpressionType.VALUE]
     return_type = ExpressionType.VALUE
 
-    def __call__(self, obj: Sized) -> Optional[int]:
-        """Return an object's length, or `None` if the object does not have a length."""
+    def __call__(self, obj: Sized) -> Union[int, _Undefined]:
+        """Return an object's length.
+
+        If the object does not have a length, the special _Nothing_ value is
+        returned.
+        """
         try:
             return len(obj)
         except TypeError:
-            return None
+            return UNDEFINED

{python_jsonpath-0.10.1 → python_jsonpath-0.10.3}/jsonpath/lex.py

@@ -66,10 +66,34 @@ if TYPE_CHECKING:
 
 
 class Lexer:
-    """Tokenize a JSONPath string."""
+    """Tokenize a JSONPath string.
+
+    Some customization can be achieved by subclassing _Lexer_ and setting
+    class attributes. Then setting `lexer_class` on a `JSONPathEnvironment`.
+
+    Attributes:
+        key_pattern: The regular expression pattern used to match mapping
+            keys/properties.
+        logical_not_pattern: The regular expression pattern used to match
+            logical negation tokens. By default, `not` and `!` are
+            equivalent.
+        logical_and_pattern: The regular expression pattern used to match
+            logical _and_ tokens. By default, `and` and `&&` are equivalent.
+        logical_or_pattern: The regular expression pattern used to match
+            logical _or_ tokens. By default, `or` and `||` are equivalent.
+    """
 
     key_pattern = r"[\u0080-\uFFFFa-zA-Z_][\u0080-\uFFFFa-zA-Z0-9_-]*"
 
+    # `not` or !
+    logical_not_pattern = r"(?:not|!)"
+
+    # && or `and`
+    logical_and_pattern = r"(?:&&|and)"
+
+    # || or `or`
+    logical_or_pattern = r"(?:\|\||or)"
+
     def __init__(self, *, env: JSONPathEnvironment) -> None:
         self.env = env
 
@@ -85,15 +109,6 @@ class Lexer:
             r"(?::\s*(?P<G_LSLICE_STEP>\-?\d*))?"
         )
 
-        # `not` or !
-        self.logical_not_pattern = r"(?:not|!)"
-
-        # && or `and`
-        self.bool_and_pattern = r"(?:&&|and)"
-
-        # || or `or`
-        self.bool_or_pattern = r"(?:\|\||or)"
-
         # /pattern/ or /pattern/flags
         self.re_pattern = r"/(?P<G_RE>.+?)/(?P<G_RE_FLAGS>[aims]*)"
 
@@ -114,8 +129,8 @@ class Lexer:
             (TOKEN_FLOAT, r"-?\d+\.\d*(?:e[+-]?\d+)?"),
             (TOKEN_INT, r"-?\d+(?P<G_EXP>e[+\-]?\d+)?\b"),
             (TOKEN_DDOT, r"\.\."),
-            (TOKEN_AND, self.bool_and_pattern),
-            (TOKEN_OR, self.bool_or_pattern),
+            (TOKEN_AND, self.logical_and_pattern),
+            (TOKEN_OR, self.logical_or_pattern),
             (TOKEN_ROOT, re.escape(self.env.root_token)),
             (TOKEN_SELF, re.escape(self.env.self_token)),
             (TOKEN_KEY, re.escape(self.env.key_token)),

{python_jsonpath-0.10.1 → python_jsonpath-0.10.3}/jsonpath/parse.py

@@ -158,7 +158,7 @@ class Parser:
         TOKEN_LG: PRECEDENCE_RELATIONAL,
         TOKEN_LT: PRECEDENCE_RELATIONAL,
         TOKEN_NE: PRECEDENCE_RELATIONAL,
-        TOKEN_NOT: PRECEDENCE_LOGICALRIGHT,
+        TOKEN_NOT: PRECEDENCE_PREFIX,
         TOKEN_OR: PRECEDENCE_LOGICAL,
         TOKEN_RE: PRECEDENCE_RELATIONAL,
         TOKEN_RPAREN: PRECEDENCE_LOWEST,
@@ -180,7 +180,7 @@ class Parser:
         TOKEN_RE: "=~",
     }
 
-    SINGULAR_QUERY_COMPARISON_OPERATORS = frozenset(
+    COMPARISON_OPERATORS = frozenset(
         [
             "==",
             ">=",
@@ -446,6 +446,7 @@ class Parser:
                 )
 
             if stream.peek.kind != TOKEN_RBRACKET:
+                # TODO: error message .. expected a comma or logical operator
                 stream.expect_peek(TOKEN_COMMA)
                 stream.next_token()
 
@@ -499,9 +500,7 @@ class Parser:
         assert tok.kind == TOKEN_NOT
         return PrefixExpression(
             operator="!",
-            right=self.parse_filter_selector(
-                stream, precedence=self.PRECEDENCE_LOGICALRIGHT
-            ),
+            right=self.parse_filter_selector(stream, precedence=self.PRECEDENCE_PREFIX),
         )
 
     def parse_infix_expression(
@@ -512,10 +511,7 @@ class Parser:
         right = self.parse_filter_selector(stream, precedence)
         operator = self.BINARY_OPERATORS[tok.kind]
 
-        self._raise_for_non_singular_query(left, tok)  # TODO: store tok on expression
-        self._raise_for_non_singular_query(right, tok)
-
-        if operator in self.SINGULAR_QUERY_COMPARISON_OPERATORS:
+        if self.env.well_typed and operator in self.COMPARISON_OPERATORS:
             self._raise_for_non_comparable_function(left, tok)
             self._raise_for_non_comparable_function(right, tok)
 
@@ -667,26 +663,18 @@ class Parser:
 
         return token.value
 
-    def _raise_for_non_singular_query(
-        self, expr: FilterExpression, token: Token
-    ) -> None:
-        if (
-            self.env.well_typed
-            and isinstance(expr, Path)
-            and not expr.path.singular_query()
-        ):
-            raise JSONPathSyntaxError(
-                "non-singular query is not comparable", token=token
-            )
-
     def _raise_for_non_comparable_function(
         self, expr: FilterExpression, token: Token
     ) -> None:
-        if not self.env.well_typed or not isinstance(expr, FunctionExtension):
-            return
-        func = self.env.function_extensions.get(expr.name)
-        if (
-            isinstance(func, FilterFunction)
-            and func.return_type != ExpressionType.VALUE
-        ):
-            raise JSONPathTypeError(f"result of {expr.name}() is not comparable", token)
+        if isinstance(expr, Path) and not expr.path.singular_query():
+            raise JSONPathTypeError("non-singular query is not comparable", token=token)
+
+        if isinstance(expr, FunctionExtension):
+            func = self.env.function_extensions.get(expr.name)
+            if (
+                isinstance(func, FilterFunction)
+                and func.return_type != ExpressionType.VALUE
+            ):
+                raise JSONPathTypeError(
+                    f"result of {expr.name}() is not comparable", token
+                )