python-jsonpath 0.4.0__tar.gz → 0.5.0.post1__tar.gz

python_jsonpath-0.5.0.post1/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present James Prior <jamesgr.prior@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python_jsonpath-0.5.0.post1/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.1
+Name: python-jsonpath
+Version: 0.5.0.post1
+Summary: Another JSONPath implementation 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-Expression: MIT
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+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
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# Python JSONPath
+
+[![PyPI - Version](https://img.shields.io/pypi/v/python-jsonpath.svg?style=flat-square)](https://pypi.org/project/python-jsonpath)
+[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/jg-rp/python-jsonpath/tests.yaml?branch=main&label=tests&style=flat-square)](https://github.com/jg-rp/python-jsonpath/actions)
+[![PyPI - License](https://img.shields.io/pypi/l/python-jsonpath?style=flat-square)](https://github.com/jg-rp/python-jsonpath/blob/main/LICENSE.txt)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/python-jsonpath.svg?style=flat-square)](https://pypi.org/project/python-jsonpath)
+
+---
+
+A flexible JSONPath engine for Python.
+
+**Table of Contents**
+
+- [Install](#install)
+- [Links](#links)
+- [Example](#example)
+- [License](#license)
+
+## Install
+
+Install Python JSONPath using [Pipenv](https://pipenv.pypa.io/en/latest/):
+
+```console
+pipenv install -u python-jsonpath
+```
+
+or [pip](https://pip.pypa.io/en/stable/getting-started/):
+
+```console
+pip install python-jsonpath
+```
+
+## Links
+
+- Documentation: https://jg-rp.github.io/python-jsonpath/.
+- JSONPath Syntax: https://jg-rp.github.io/python-jsonpath/syntax/
+- Change log: https://github.com/jg-rp/python-jsonpath/blob/main/CHANGELOG.md
+- PyPi: https://pypi.org/project/python-jsonpath
+- Source code: https://github.com/jg-rp/python-jsonpath
+- Issue tracker: https://github.com/jg-rp/python-jsonpath/issues
+
+## Example
+
+```python
+import jsonpath
+
+data = {
+    "categories": [
+        {
+            "name": "footwear",
+            "products": [
+                {
+                    "title": "Trainers",
+                    "description": "Fashionable trainers.",
+                    "price": 89.99,
+                },
+                {
+                    "title": "Barefoot Trainers",
+                    "description": "Running trainers.",
+                    "price": 130.00,
+                },
+            ],
+        },
+        {
+            "name": "headwear",
+            "products": [
+                {
+                    "title": "Cap",
+                    "description": "Baseball cap",
+                    "price": 15.00,
+                },
+                {
+                    "title": "Beanie",
+                    "description": "Winter running hat.",
+                    "price": 9.00,
+                },
+            ],
+        },
+    ],
+    "price_cap": 10,
+}
+
+products = jsonpath.findall("$..products.*", data)
+print(products)
+```
+
+## License
+
+`python-jsonpath` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

python_jsonpath-0.5.0.post1/README.md

@@ -0,0 +1,89 @@
+# Python JSONPath
+
+[![PyPI - Version](https://img.shields.io/pypi/v/python-jsonpath.svg?style=flat-square)](https://pypi.org/project/python-jsonpath)
+[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/jg-rp/python-jsonpath/tests.yaml?branch=main&label=tests&style=flat-square)](https://github.com/jg-rp/python-jsonpath/actions)
+[![PyPI - License](https://img.shields.io/pypi/l/python-jsonpath?style=flat-square)](https://github.com/jg-rp/python-jsonpath/blob/main/LICENSE.txt)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/python-jsonpath.svg?style=flat-square)](https://pypi.org/project/python-jsonpath)
+
+---
+
+A flexible JSONPath engine for Python.
+
+**Table of Contents**
+
+- [Install](#install)
+- [Links](#links)
+- [Example](#example)
+- [License](#license)
+
+## Install
+
+Install Python JSONPath using [Pipenv](https://pipenv.pypa.io/en/latest/):
+
+```console
+pipenv install -u python-jsonpath
+```
+
+or [pip](https://pip.pypa.io/en/stable/getting-started/):
+
+```console
+pip install python-jsonpath
+```
+
+## Links
+
+- Documentation: https://jg-rp.github.io/python-jsonpath/.
+- JSONPath Syntax: https://jg-rp.github.io/python-jsonpath/syntax/
+- Change log: https://github.com/jg-rp/python-jsonpath/blob/main/CHANGELOG.md
+- PyPi: https://pypi.org/project/python-jsonpath
+- Source code: https://github.com/jg-rp/python-jsonpath
+- Issue tracker: https://github.com/jg-rp/python-jsonpath/issues
+
+## Example
+
+```python
+import jsonpath
+
+data = {
+    "categories": [
+        {
+            "name": "footwear",
+            "products": [
+                {
+                    "title": "Trainers",
+                    "description": "Fashionable trainers.",
+                    "price": 89.99,
+                },
+                {
+                    "title": "Barefoot Trainers",
+                    "description": "Running trainers.",
+                    "price": 130.00,
+                },
+            ],
+        },
+        {
+            "name": "headwear",
+            "products": [
+                {
+                    "title": "Cap",
+                    "description": "Baseball cap",
+                    "price": 15.00,
+                },
+                {
+                    "title": "Beanie",
+                    "description": "Winter running hat.",
+                    "price": 9.00,
+                },
+            ],
+        },
+    ],
+    "price_cap": 10,
+}
+
+products = jsonpath.findall("$..products.*", data)
+print(products)
+```
+
+## License
+
+`python-jsonpath` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

{python_jsonpath-0.4.0 → python_jsonpath-0.5.0.post1}/jsonpath/__about__.py

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

{python_jsonpath-0.4.0 → python_jsonpath-0.5.0.post1}/jsonpath/__init__.py

@@ -7,6 +7,7 @@ from .exceptions import JSONPathError
 from .exceptions import JSONPathNameError
 from .exceptions import JSONPathSyntaxError
 from .exceptions import JSONPathTypeError
+from .filter import UNDEFINED
 from .lex import Lexer
 from .match import JSONPathMatch
 from .parse import Parser
@@ -29,6 +30,7 @@ __all__ = (
     "JSONPathTypeError",
     "Lexer",
     "Parser",
+    "UNDEFINED",
 )
 
 

{python_jsonpath-0.4.0 → python_jsonpath-0.5.0.post1}/jsonpath/env.py

@@ -1,7 +1,6 @@
 """Core JSONPath configuration object."""
 from __future__ import annotations
 
-import inspect
 import re
 from collections.abc import Collection
 from operator import getitem
@@ -22,8 +21,8 @@ from typing import Union
 from . import function_extensions
 from .exceptions import JSONPathNameError
 from .exceptions import JSONPathSyntaxError
-from .exceptions import JSONPathTypeError
 from .filter import UNDEFINED
+from .function_extensions import validate
 from .lex import Lexer
 from .parse import Parser
 from .path import CompoundJSONPath
@@ -69,13 +68,21 @@ class JSONPathEnvironment:
     ## Class attributes
 
     Attributes:
-        intersection_token: The pattern used as the intersection operator.
-        root_token: The pattern used to select the root node in a JSON document.
-        self_token: The pattern used to select the current node in a JSON document.
-        union_token: The pattern used as the union operator.
         filter_context_token: The pattern used to select extra filter context data.
+            Defaults to `"#"`.
+        intersection_token: The pattern used as the intersection operator. Defaults
+            to `"$"`.
         lexer_class: The lexer to use when tokenizing path strings.
+        max_int_index: The maximum integer allowed when selecting array items by index.
+            Defaults to `(2**53) - 1`.
+        min_int_index: The minimum integer allowed when selecting array items by index.
+            Defaults to `-(2**53) + 1`.
         parser_class: The parser to use when parsing tokens from the lexer.
+        root_token: The pattern used to select the root node in a JSON document.
+            Defaults to `"$"`.
+        self_token: The pattern used to select the current node in a JSON document.
+            Defaults to `"@"`
+        union_token: The pattern used as the union operator. Defaults to `"|"`.
     """
 
     # These should be unescaped strings. `re.escape` will be called
@@ -86,6 +93,9 @@ class JSONPathEnvironment:
     union_token: str = "|"
     filter_context_token: str = "#"
 
+    max_int_index: int = (2**53) - 1
+    min_int_index: int = -(2**53) + 1
+
     # Override these to customize path tokenization and parsing.
     lexer_class: Type[Lexer] = Lexer
     parser_class: Type[Parser] = Parser
@@ -122,6 +132,13 @@ class JSONPathEnvironment:
         if stream.current.kind != TOKEN_EOF:
             _path = CompoundJSONPath(env=self, path=_path)
             while stream.current.kind != TOKEN_EOF:
+                if stream.peek.kind == TOKEN_EOF:
+                    # trailing union or intersection
+                    raise JSONPathSyntaxError(
+                        f"expected a path after {stream.current.value!r}",
+                        token=stream.current,
+                    )
+
                 if stream.current.kind == TOKEN_UNION:
                     stream.next_token()
                     _path.union(
@@ -230,10 +247,13 @@ class JSONPathEnvironment:
         self.function_extensions["keys"] = function_extensions.keys
         self.function_extensions["length"] = function_extensions.length
         self.function_extensions["count"] = function_extensions.length
+        self.function_extensions["match"] = function_extensions.Match()
+        self.function_extensions["search"] = function_extensions.Search()
+        self.function_extensions["value"] = function_extensions.value
 
     def validate_function_extension_signature(
         self, token: Token, args: List[Any]
-    ) -> None:
+    ) -> List[Any]:
         """Compile-time validation of function extension arguments.
 
         The IETF JSONPath draft requires us to reject paths that use filter
@@ -246,36 +266,11 @@ class JSONPathEnvironment:
                 f"function {token.value!r} is not defined", token=token
             ) from err
 
-        params = list(inspect.signature(func).parameters.values())
-
-        # Keyword only params are not supported
-        if len([p for p in params if p.kind in (p.KEYWORD_ONLY, p.VAR_KEYWORD)]):
-            raise JSONPathTypeError(
-                f"function {token.value!r} requires keyword arguments",
-                token=token,
-            )
-
-        # Too few args?
-        positional_args = [
-            p for p in params if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)
-        ]
-        if len(args) < len(positional_args):
-            raise JSONPathTypeError(
-                f"{token.value!r}() requires {len(positional_args)} arguments",
-                token=token,
-            )
-
-        # Does the signature have var args?
-        if len([p for p in params if p.kind == p.VAR_POSITIONAL]):
-            return
-
-        # Too many args?
-        if len(args) > len(positional_args):
-            raise JSONPathTypeError(
-                f"{token.value!r}() requires at most "
-                f"{len(positional_args) + len(positional_args)} arguments",
-                token=token,
-            )
+        if hasattr(func, "validate"):
+            args = func.validate(self, args, token)
+            assert isinstance(args, list)
+            return args
+        return validate(self, func, args, token)
 
     def getitem(self, obj: Any, key: Any) -> Any:
         """Sequence and mapping item getter used throughout JSONPath resolution.
@@ -353,7 +348,7 @@ class JSONPathEnvironment:
             return operator == "<="
 
         if operator == "=~" and isinstance(right, re.Pattern) and isinstance(left, str):
-            return bool(right.match(left))
+            return bool(right.fullmatch(left))
 
         if isinstance(left, str) and isinstance(right, str):
             if operator == "<=":

{python_jsonpath-0.4.0 → python_jsonpath-0.5.0.post1}/jsonpath/exceptions.py

@@ -45,6 +45,10 @@ class JSONPathTypeError(JSONPathError):
     """
 
 
+class JSONPathIndexError(JSONPathError):
+    """An exception raised when an array index is out of range."""
+
+
 class JSONPathNameError(JSONPathError):
     """An exception raised when an unknown function extension is called."""
 

{python_jsonpath-0.4.0 → python_jsonpath-0.5.0.post1}/jsonpath/filter.py

@@ -181,6 +181,24 @@ class RegexLiteral(Literal[Pattern[str]]):
         return f"/{pattern}/{''.join(flags)}"
 
 
+class RegexArgument(FilterExpression):
+    """A compiled regex."""
+
+    __slots__ = ("pattern",)
+
+    def __init__(self, pattern: Pattern[str]) -> None:
+        self.pattern = pattern
+
+    def __str__(self) -> str:
+        return repr(self.pattern.pattern)
+
+    def evaluate(self, _: FilterContext) -> object:
+        return self.pattern
+
+    async def evaluate_async(self, _: FilterContext) -> object:
+        return self.pattern
+
+
 class ListLiteral(FilterExpression):
     """A list literal."""
 
@@ -313,15 +331,19 @@ class SelfPath(Path):
     def __str__(self) -> str:
         return "@" + str(self.path)[1:]
 
-    def evaluate(self, context: FilterContext) -> object:
+    def evaluate(self, context: FilterContext) -> object:  # noqa: PLR0911
+        if isinstance(context.current, str):
+            if self.path.empty():
+                return context.current
+            return UNDEFINED
         if not isinstance(context.current, (Sequence, Mapping)):
             if self.path.empty():
-                return UNDEFINED
-            return context.current
+                return context.current
+            return UNDEFINED
 
         try:
             matches = self.path.findall(context.current)
-        except json.JSONDecodeError:
+        except json.JSONDecodeError:  # this should never happen
             return UNDEFINED
 
         if not matches:
@@ -330,11 +352,15 @@ class SelfPath(Path):
             return matches[0]
         return matches
 
-    async def evaluate_async(self, context: FilterContext) -> object:
+    async def evaluate_async(self, context: FilterContext) -> object:  # noqa: PLR0911
+        if isinstance(context.current, str):
+            if self.path.empty():
+                return context.current
+            return UNDEFINED
         if not isinstance(context.current, (Sequence, Mapping)):
             if self.path.empty():
-                return UNDEFINED
-            return context.current
+                return context.current
+            return UNDEFINED
 
         try:
             matches = await self.path.findall_async(context.current)

python_jsonpath-0.5.0.post1/jsonpath/function_extensions/__init__.py

@@ -0,0 +1,16 @@
+# noqa: D104
+from .arguments import validate
+from .keys import keys
+from .length import length
+from .match import Match
+from .search import Search
+from .value import value
+
+__all__ = (
+    "Match",
+    "Search",
+    "value",
+    "keys",
+    "length",
+    "validate",
+)

python_jsonpath-0.5.0.post1/jsonpath/function_extensions/arguments.py

@@ -0,0 +1,56 @@
+"""Class-based function extension base."""
+import inspect
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Callable
+from typing import List
+
+if TYPE_CHECKING:
+    from ..env import JSONPathEnvironment
+    from ..token import Token
+
+from ..exceptions import JSONPathTypeError
+
+
+def validate(
+    _: "JSONPathEnvironment",
+    func: Callable[..., Any],
+    args: List[Any],
+    token: "Token",
+) -> List[Any]:
+    """Generic validation of function extension arguments using introspection.
+
+    The IETF JSONPath draft requires us to reject paths that use filter
+    functions with too many or too few arguments.
+    """
+    params = list(inspect.signature(func).parameters.values())
+
+    # Keyword only params are not supported
+    if len([p for p in params if p.kind in (p.KEYWORD_ONLY, p.VAR_KEYWORD)]):
+        raise JSONPathTypeError(
+            f"function {token.value!r} requires keyword arguments",
+            token=token,
+        )
+
+    # Too few args?
+    positional_args = [
+        p for p in params if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)
+    ]
+    if len(args) < len(positional_args):
+        raise JSONPathTypeError(
+            f"{token.value!r}() requires {len(positional_args)} arguments",
+            token=token,
+        )
+
+    # Does the signature have var args?
+    has_var_args = bool([p for p in params if p.kind == p.VAR_POSITIONAL])
+
+    # Too many args?
+    if not has_var_args and len(args) > len(positional_args):
+        raise JSONPathTypeError(
+            f"{token.value!r}() requires at most "
+            f"{len(positional_args) + len(positional_args)} arguments",
+            token=token,
+        )
+
+    return args

python_jsonpath-0.5.0.post1/jsonpath/function_extensions/match.py

@@ -0,0 +1,56 @@
+"""The standard `match` function extension."""
+
+import re
+from typing import TYPE_CHECKING
+from typing import List
+from typing import Pattern
+from typing import Union
+
+from ..exceptions import JSONPathTypeError
+from ..filter import RegexArgument
+from ..filter import StringLiteral
+
+if TYPE_CHECKING:
+    from ..env import JSONPathEnvironment
+    from ..token import Token
+
+
+class Match:
+    """The built-in `match` function.
+
+    This implementation uses the standard _re_ module, without attempting to map
+    I-Regexps to Python regex.
+    """
+
+    def __call__(self, string: str, pattern: Union[str, Pattern[str], None]) -> bool:
+        """Return `True` if _pattern_ matches the given string, `False` otherwise."""
+        # The IETF JSONPath draft requires us to return `False` if the pattern was
+        # invalid. We use `None` to indicate the pattern could not be compiled.
+        if string is None or pattern is None:
+            return False
+
+        try:
+            return bool(re.fullmatch(pattern, string))
+        except (TypeError, re.error):
+            return False
+
+    def validate(
+        self,
+        _: "JSONPathEnvironment",
+        args: List[object],
+        token: "Token",
+    ) -> List[object]:
+        """Function argument validation."""
+        if len(args) != 2:  # noqa: PLR2004
+            raise JSONPathTypeError(
+                f"{token.value!r} requires 2 arguments, found {len(args)}",
+                token=token,
+            )
+
+        if isinstance(args[1], StringLiteral):
+            try:
+                return [args[0], RegexArgument(re.compile(args[1].value))]
+            except re.error:
+                return [None, None]
+
+        return args

python_jsonpath-0.5.0.post1/jsonpath/function_extensions/search.py

@@ -0,0 +1,56 @@
+"""The standard `search` function extension."""
+
+import re
+from typing import TYPE_CHECKING
+from typing import List
+from typing import Pattern
+from typing import Union
+
+from ..exceptions import JSONPathTypeError
+from ..filter import RegexArgument
+from ..filter import StringLiteral
+
+if TYPE_CHECKING:
+    from ..env import JSONPathEnvironment
+    from ..token import Token
+
+
+class Search:
+    """The built-in `search` function.
+
+    This implementation uses the standard _re_ module, without attempting to map
+    I-Regexps to Python regex.
+    """
+
+    def __call__(self, string: str, pattern: Union[str, Pattern[str], None]) -> bool:
+        """Return `True` if the given string contains _pattern_, `False` otherwise."""
+        # The IETF JSONPath draft requires us to return `False` if the pattern was
+        # invalid. We use `None` to indicate the pattern could not be compiled.
+        if string is None or pattern is None:
+            return False
+
+        try:
+            return bool(re.search(pattern, string))
+        except (TypeError, re.error):
+            return False
+
+    def validate(
+        self,
+        _: "JSONPathEnvironment",
+        args: List[object],
+        token: "Token",
+    ) -> List[object]:
+        """Function argument validation."""
+        if len(args) != 2:  # noqa: PLR2004
+            raise JSONPathTypeError(
+                f"{token.value!r} requires 2 arguments, found {len(args)}",
+                token=token,
+            )
+
+        if isinstance(args[1], StringLiteral):
+            try:
+                return [args[0], RegexArgument(re.compile(args[1].value))]
+            except re.error:
+                return [None, None]
+
+        return args

python_jsonpath-0.5.0.post1/jsonpath/function_extensions/value.py

@@ -0,0 +1,15 @@
+"""The standard `value` function extension."""
+from typing import Sequence
+
+from ..filter import UNDEFINED
+
+
+def value(obj: object) -> object:
+    """Return the first object in the sequence if the sequence has only one item."""
+    if isinstance(obj, str):
+        return obj
+    if isinstance(obj, Sequence):
+        if len(obj) == 1:
+            return obj[0]
+        return UNDEFINED
+    return obj