python-jsonpath 0.4.0__py3-none-any.whl → 0.5.0.post1__py3-none-any.whl

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"

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",
 )
 
 

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 == "<=":

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."""
 

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)

jsonpath/function_extensions/__init__.py

@@ -1,8 +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",
 )

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

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

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

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

jsonpath/lex.py

@@ -72,11 +72,11 @@ if TYPE_CHECKING:
 class Lexer:
     """Tokenize a JSONPath string."""
 
+    key_pattern = r"[\u0080-\uFFFFa-zA-Z_][\u0080-\uFFFFa-zA-Z0-9_-]*"
+
     def __init__(self, *, env: JSONPathEnvironment) -> None:
         self.env = env
 
-        self.key_pattern = r"[\u0080-\uFFFFa-zA-Z_][\u0080-\uFFFFa-zA-Z0-9_-]*"
-
         self.double_quote_pattern = r'"(?P<G_DQUOTE>(?:(?!(?<!\\)").)*)"'
         self.single_quote_pattern = r"'(?P<G_SQUOTE>(?:(?!(?<!\\)').)*)'"
 
@@ -86,10 +86,6 @@ class Lexer:
         # [thing]
         self.bracketed_property_pattern = rf"\[\s*(?P<G_BPROP>{self.key_pattern})\s*]"
 
-        # .1
-        # NOTE: `.1` can be a dot property where the key is "1".
-        self.dot_index_pattern = r"\.\s*(?P<G_DINDEX>\d+)\b"
-
         # [1] or [-1]
         self.index_pattern = r"\[\s*(?P<G_INDEX>\-?\s*\d+)\s*]"
 
@@ -132,7 +128,6 @@ class Lexer:
             (TOKEN_DOUBLE_QUOTE_STRING, self.double_quote_pattern),
             (TOKEN_SINGLE_QUOTE_STRING, self.single_quote_pattern),
             (TOKEN_RE_PATTERN, self.re_pattern),
-            (TOKEN_DOT_INDEX, self.dot_index_pattern),
             (TOKEN_INDEX, self.index_pattern),
             (TOKEN_SLICE, self.slice_pattern),
             (TOKEN_WILD, self.wild_pattern),

jsonpath/parse.py

@@ -92,6 +92,41 @@ if TYPE_CHECKING:
 
 # ruff: noqa: D102
 
+INVALID_NAME_SELECTOR_CHARS = [
+    "\x00",
+    "\x01",
+    "\x02",
+    "\x03",
+    "\x04",
+    "\x05",
+    "\x06",
+    "\x07",
+    "\x08",
+    "\t",
+    "\n",
+    "\x0b",
+    "\x0c",
+    "\r",
+    "\x0e",
+    "\x0f",
+    "\x10",
+    "\x11",
+    "\x12",
+    "\x13",
+    "\x14",
+    "\x15",
+    "\x16",
+    "\x17",
+    "\x18",
+    "\x19",
+    "\x1a",
+    "\x1b",
+    "\x1c",
+    "\x1d",
+    "\x1e",
+    "\x1f",
+]
+
 
 class Parser:
     """A JSONPath parser bound to a JSONPathEnvironment."""
@@ -149,6 +184,11 @@ class Parser:
         "s": re.S,
     }
 
+    _INVALID_NAME_SELECTOR_CHARS = f"[{''.join(INVALID_NAME_SELECTOR_CHARS)}]"
+    RE_INVALID_NAME_SELECTOR = re.compile(
+        rf'(?:(?!(?<!\\)"){_INVALID_NAME_SELECTOR_CHARS})'
+    )
+
     def __init__(self, *, env: JSONPathEnvironment) -> None:
         self.env = env
 
@@ -245,7 +285,7 @@ class Parser:
                 )
             elif stream.current.kind == TOKEN_LIST_START:
                 yield self.parse_selector_list(stream)
-            elif stream.current.kind == TOKEN_FILTER_START and not in_filter:
+            elif stream.current.kind == TOKEN_FILTER_START:
                 yield self.parse_filter(stream)
             else:
                 if in_filter:
@@ -288,7 +328,9 @@ class Parser:
     def parse_selector_list(self, stream: TokenStream) -> ListSelector:
         """Parse a comma separated list JSONPath selectors from a stream of tokens."""
         tok = stream.next_token()
-        list_items: List[Union[IndexSelector, PropertySelector, SliceSelector]] = []
+        list_items: List[
+            Union[IndexSelector, PropertySelector, SliceSelector, WildSelector]
+        ] = []
 
         while stream.current.kind != TOKEN_RBRACKET:
             if stream.current.kind == TOKEN_INT:
@@ -299,32 +341,56 @@ class Parser:
                         index=int(stream.current.value),
                     )
                 )
-            elif stream.current.kind in (TOKEN_BARE_PROPERTY, TOKEN_STRING):
+            elif stream.current.kind == TOKEN_BARE_PROPERTY:
+                list_items.append(
+                    PropertySelector(
+                        env=self.env,
+                        token=stream.current,
+                        name=stream.current.value,
+                    ),
+                )
+            elif stream.current.kind == TOKEN_STRING:
+                if self.RE_INVALID_NAME_SELECTOR.search(stream.current.value):
+                    raise JSONPathSyntaxError(
+                        f"invalid name selector {stream.current.value!r}",
+                        token=stream.current,
+                    )
+
+                name = (
+                    codecs.decode(
+                        stream.current.value.replace("\\/", "/"), "unicode-escape"
+                    )
+                    .encode("utf-16", "surrogatepass")
+                    .decode("utf-16")
+                )
+
                 list_items.append(
                     PropertySelector(
                         env=self.env,
                         token=stream.current,
-                        name=codecs.decode(
-                            stream.current.value.replace("\\/", "/"), "unicode-escape"
-                        )
-                        .encode("utf-16", "surrogatepass")
-                        .decode("utf-16"),
+                        name=name,
                     ),
                 )
             elif stream.current.kind == TOKEN_SLICE_START:
                 list_items.append(self.parse_slice(stream))
-            elif stream.current.kind == TOKEN_EOF:
+            elif stream.current.kind == TOKEN_WILD:
+                list_items.append(WildSelector(env=self.env, token=stream.current))
+
+            if stream.peek.kind == TOKEN_EOF:
                 raise JSONPathSyntaxError(
                     "unexpected end of selector list",
                     token=stream.current,
                 )
 
             if stream.peek.kind != TOKEN_RBRACKET:
+                stream.expect_peek(TOKEN_COMMA)
                 stream.next_token()
 
             stream.next_token()
 
-        # TODO: is an empty list an error?
+        if not list_items:
+            raise JSONPathSyntaxError("empty segment", token=tok)
+
         return ListSelector(env=self.env, token=tok, items=list_items)
 
     def parse_filter(self, stream: TokenStream) -> Filter:
@@ -463,12 +529,16 @@ class Parser:
                 ) from err
 
             if stream.peek.kind != TOKEN_RPAREN:
+                if stream.peek.kind == TOKEN_FILTER_END:
+                    break
                 stream.expect_peek(TOKEN_COMMA)
                 stream.next_token()
 
             stream.next_token()
 
-        self.env.validate_function_extension_signature(tok, function_arguments)
+        function_arguments = self.env.validate_function_extension_signature(
+            tok, function_arguments
+        )
         return FunctionExtension(tok.value, function_arguments)
 
     def parse_filter_selector(

jsonpath/path.py

@@ -76,7 +76,6 @@ class JSONPath:
                 an incompatible way.
         """
         if isinstance(data, str):
-            # TODO: catch JSONDecodeError?
             _data = json.loads(data)
         elif isinstance(data, TextIO):
             _data = json.loads(data.read())
@@ -141,7 +140,6 @@ class JSONPath:
     ) -> List[object]:
         """An async version of `findall()`."""
         if isinstance(data, str):
-            # TODO: catch JSONDecodeError
             _data = json.loads(data)
         elif isinstance(data, TextIO):
             _data = json.loads(data.read())
@@ -187,7 +185,7 @@ class JSONPath:
 
     def empty(self) -> bool:
         """Return `True` if this path has no selectors."""
-        return bool(self._selectors)
+        return not bool(self._selectors)
 
 
 class CompoundJSONPath:

jsonpath/selectors.py

@@ -15,6 +15,7 @@ from typing import Optional
 from typing import TypeVar
 from typing import Union
 
+from .exceptions import JSONPathIndexError
 from .exceptions import JSONPathTypeError
 from .match import JSONPathMatch
 
@@ -113,6 +114,9 @@ class IndexSelector(JSONPathSelector):
         token: Token,
         index: int,
     ) -> None:
+        if index < env.min_int_index or index > env.max_int_index:
+            raise JSONPathIndexError("index out of range", token=token)
+
         super().__init__(env=env, token=token)
         self.index = index
         self._as_key = str(self.index)
@@ -201,6 +205,7 @@ class SliceSelector(JSONPathSelector):
         step: Optional[int] = None,
     ) -> None:
         super().__init__(env=env, token=token)
+        self._check_range(start, stop, step)
         self.slice = slice(start, stop, step)
 
     def __str__(self) -> str:
@@ -209,6 +214,13 @@ class SliceSelector(JSONPathSelector):
         step = self.slice.step if self.slice.step is not None else "1"
         return f"[{start}:{stop}:{step}]"
 
+    def _check_range(self, *indices: Optional[int]) -> None:
+        for i in indices:
+            if i is not None and (
+                i < self.env.min_int_index or i > self.env.max_int_index
+            ):
+                raise JSONPathIndexError("index out of range")
+
     def _normalized_index(self, obj: Sequence[object], index: int) -> int:
         if index < 0 and len(obj) >= abs(index):
             return len(obj) + index
@@ -396,7 +408,9 @@ class ListSelector(JSONPathSelector):
         *,
         env: JSONPathEnvironment,
         token: Token,
-        items: List[Union[SliceSelector, IndexSelector, PropertySelector]],
+        items: List[
+            Union[SliceSelector, IndexSelector, PropertySelector, WildSelector]
+        ],
     ) -> None:
         super().__init__(env=env, token=token)
         self.items = items
@@ -411,6 +425,8 @@ class ListSelector(JSONPathSelector):
                 buf.append(f"{start}:{stop}:{step}")
             elif isinstance(item, PropertySelector):
                 buf.append(f"'{item.name}'")
+            elif isinstance(item, WildSelector):
+                buf.append("*")
             else:
                 buf.append(str(item.index))
         return f"[{', '.join(buf)}]"

python_jsonpath-0.5.0.post1.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,24 @@
+jsonpath/__about__.py,sha256=hZldckvbIhXFrYcYa_nKfZAxjOcYFuOGy9lZRk4iF8I,139
+jsonpath/__init__.py,sha256=gUgI3mFEPMOAtgh_Pfx6iq-Vq1SIsybOsC_Lixp7qZo,1070
+jsonpath/env.py,sha256=E3LDUjdj-XXFw5koMkaVBhgwWNFRFDjxuUwUL08U6mM,14434
+jsonpath/exceptions.py,sha256=A6lCV7Mtm5ZorJX2cr8qXXWXBqLyX4hRzs6y5rzc4zs,1906
+jsonpath/filter.py,sha256=cVWygNCUGNVmDUDrVJCb8qCz4su_tjD45r0qmziW1hY,12325
+jsonpath/lex.py,sha256=OXz8Az0gMoWQ7XRK1wzGlZ5tbWydfplfQnOI35_4VyY,10881
+jsonpath/match.py,sha256=lJn27VWgTMUeAEO4FtmAmUPvf9FK7hTF8f2yq38KiOk,2513
+jsonpath/parse.py,sha256=MXNQ-TyDLceBP5dWZkQolXpmRDbu8OG2SCGCdJuMmxM,19148
+jsonpath/path.py,sha256=Jp-NQp7bnBWBDqkCrunwWOk8Ujiu2atb9Tc6wTznDjY,11290
+jsonpath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jsonpath/selectors.py,sha256=6TIrYpMSvH8NDqfSIo1-4KezS29OFmYMdBdoGdvkpfM,22016
+jsonpath/stream.py,sha256=V9OtMAYl6jdsj2G8e3u-vH7L4iFhA-vm4Z2Aom10Dxk,2567
+jsonpath/token.py,sha256=BS01OCzriOGn85NkyGoC93h_96BQn-GXeeeM2k_sDPc,3650
+jsonpath/function_extensions/__init__.py,sha256=HFtDFqurbIly31Z5R5p5CmpP_su5MOHBo9jGBjrNwB4,269
+jsonpath/function_extensions/arguments.py,sha256=buFAlfRZtH-yPT_ENJetZlehHMiGkZF0Ew_xw_4WRyc,1694
+jsonpath/function_extensions/keys.py,sha256=vNdIV8xqr1LMG6RLJwb6iA5-VXgYSZu6CqprXEs6rYM,364
+jsonpath/function_extensions/length.py,sha256=QdwkLLNTbgNKWIx1M8umAHnc5vyc9cjM_vODc6hXDK0,313
+jsonpath/function_extensions/match.py,sha256=yyv9LMItJBs_20MTPRq7SKn1RrUrXcJtT9oX-WAqS4g,1697
+jsonpath/function_extensions/search.py,sha256=WaX2PDa7Zp6deh5H88r1oSoWbNHnnFMwGd0wygIOyms,1698
+jsonpath/function_extensions/value.py,sha256=7qBf02eqwj6HJp_Gaaw_8UPoH_cAouBfzBEmmb6joRk,402
+python_jsonpath-0.5.0.post1.dist-info/METADATA,sha256=gxF3x6alLfirs4vi1kfZ_RB2Znaqmawq4fKhaDLdWFs,3653
+python_jsonpath-0.5.0.post1.dist-info/WHEEL,sha256=Fd6mP6ydyRguakwUJ05oBE7fh2IPxgtDN9IwHJ9OqJQ,87
+python_jsonpath-0.5.0.post1.dist-info/licenses/LICENSE.txt,sha256=u7PksAQGI1QYWcERHeauMseZ4XAzDKUrKW8Z4wbeU1k,1101
+python_jsonpath-0.5.0.post1.dist-info/RECORD,,

python_jsonpath-0.5.0.post1.dist-info/licenses/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.4.0.dist-info/METADATA

@@ -1,326 +0,0 @@
-Metadata-Version: 2.1
-Name: python-jsonpath
-Version: 0.4.0
-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)
-
----
-
-**Table of Contents**
-
-- [Install](#install)
-- [API](#api)
-- [Syntax](#syntax)
-- [License](#license)
-
-A flexible JSONPath engine for Python.
-
-JSONPath is a mini language for extracting objects from data formatted in JavaScript Object Notation, or equivalent Python objects, like dictionaries and lists.
-
-```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)
-```
-
-## 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
-```
-
-or [pipx](https://pypa.github.io/pipx/)
-
-```console
-pipx install python-jsonpath
-```
-
-## API
-
-### jsonpath.findall
-
-`findall(path: str, data: Sequence | Mapping) -> list[object]`
-
-Find all objects in `data` matching the given JSONPath `path`. If data is a string, it will be loaded using `json.loads()` and the default `JSONDecoder`.
-
-Returns a list of matched objects, or an empty list if there were no matches.
-
-### jsonpath.finditer
-
-`finditer(path: str, data: Sequence | Mapping) -> iterable[JSONPathMatch]`
-
-Return an iterator yielding a `JSONPathMatch` instance for each match of the `path` in the given `data`. If data is a string, it will be loaded using `json.loads()` and the default `JSONDecoder`.
-
-### jsonpath.compile
-
-`compile(path: str) -> JSONPath | CompoundJSONPath`
-
-Prepare a path for repeated matching against different data. `jsonpath.findall()` and `jsonpath.finditer()` are convenience functions that call `compile()` for you.
-
-`JSONPath` and `CompoundJSONPath` both have `findall()` and `finditer()` methods that behave the same as `jsonpath.findall()` and `jsonpath.finditer()`, just without the path argument.
-
-### async
-
-`findall_async()` and `finditer_async()` are async equivalents of `findall()` and `finditer()`. They are used when integrating Python JSONPath with [Python Liquid](https://github.com/jg-rp/liquid) and use Python Liquid's [async protocol](https://jg-rp.github.io/liquid/introduction/async-support).
-
-### Extra filter context
-
-`findall()` and `finditer()` take an optional `filter_context` argument, being a mapping of strings to arbitrary data that can be referenced from a [filter expression](#filters-expression).
-
-Use `#` to query extra filter data, similar to how one might use `@` or `$`.
-
-## Syntax
-
-Python JSONPath's default syntax is an opinionated combination of JSONPath features from existing, popular implementations, and much of the [IETF JSONPath draft](https://datatracker.ietf.org/doc/html/draft-ietf-jsonpath-base-11). If you're already familiar with JSONPath syntax, skip to [notable differences](#notable-differences).
-
-Imagine a JSON document as a tree structure, where each object (mapping) and array can contain more objects (mappings), arrays and scalar values. Every object (mapping), array and scalar value is a node in the tree, and the outermost object (mapping) or array is the "root" node.
-
-For our purposes, a JSON "document" could be a file containing valid JSON data, a Python string containing valid JSON data, or a Python `Object` made up of dictionaries (or any [Mapping](https://docs.python.org/3/library/collections.abc.html#collections-abstract-base-classes)), lists (or any [Sequence](https://docs.python.org/3/library/collections.abc.html#collections-abstract-base-classes)), strings, etc.
-
-We chain _selectors_ together to retrieve nodes from the target document. Each selector operates on the nodes matched by preceding selectors.
-
-### Root (`$`)
-
-`$` refers to the first node in the target document, be it an object or an array. Unless referencing the root node from inside a filter expression, `$` is optional. The following two examples are equivalent.
-
-```text
-$.categories.*.name
-```
-
-```text
-categories.*.name
-```
-
-An empty path or a path containing just the root (`$`) selector returns the input data in its entirety.
-
-### Properties (`.thing`, `[thing]` or `['thing']`)
-
-Select nodes by property/key name using dot notation (`.something`) or bracket notation (`[something]`). If a target property/key contains reserved characters, it must use bracket notation and be enclosed in quotes (`['thing']`).
-
-A dot in front of bracket notation is OK, but unnecessary. The following examples are equivalent.
-
-```text
-$.categories[0].name
-```
-
-```text
-$.categories[0][name]
-```
-
-```text
-$.categories[0]['name']
-```
-
-### Array indices (`.0`, `[0]` or `[-1]`)
-
-Select an item from an array by its index. Indices are zero-based and enclosed in brackets. If the index is negative, items are selected from the end of the array. Considering example data from the top of this page, the following examples are equivalent.
-
-```text
-$.categories[0]
-```
-
-```text
-$.categories.0
-```
-
-```text
-$.categories[-1]
-```
-
-### Wildcard (`.*` or `[*]`)
-
-Select all elements from an array or all values from an object using `*`. These two examples are equivalent.
-
-```text
-$.categories[0].products.*
-```
-
-```text
-$.categories[0].products[*]
-```
-
-### Slices (`[0:-1]` or `[-1:0:-1]`)
-
-Select a range of elements from an array using slice notation. The start index, stop index and step are all optional. These examples are equivalent.
-
-```text
-$.categories[0:]
-```
-
-```text
-$.categories[0:-1:]
-```
-
-```text
-$.categories[0:-1:1]
-```
-
-```text
-$.categories[::]
-```
-
-### Lists (`[1, 2, 10:20]`)
-
-Select multiple indices, slices or properties using list notation (sometimes known as a "union" or "segment", we use "union" to mean something else).
-
-```text
-$..products.*.[title, price]
-```
-
-### Recursive descent (`..`)
-
-The `..` selector visits every node beneath the current selection. If a property selector, using dot notation, follows `..`, the dot is optional. These two examples are equivalent.
-
-```text
-$..title
-```
-
-```text
-$...title
-```
-
-### Filters (`[?(EXPRESSION)]`)
-
-Filters allow you to remove nodes from a selection using a Boolean expression. Within a filter, `@` refers to the current node and `$` refers to the root node in the target document. `@` and `$` can be used to select nodes as part of the expression. Since version 0.3.0, the parentheses are optional, as per the IETF JSONPath draft. These two examples are equivalent.
-
-```text
-$..products[?(@.price < $.price_cap)]
-```
-
-```text
-$..products[?@.price < $.price_cap]
-```
-
-Comparison operators include `==`, `!=`, `<`, `>`, `<=` and `>=`. Plus `<>` as an alias for `!=`.
-
-`in` and `contains` are membership operators. `left in right` is equivalent to `right contains left`.
-
-`&&` and `||` are logical operators, `and` and `or` work too.
-
-`=~` matches the left value with a regular expression literal. Regular expressions use a syntax similar to that found in JavaScript, where the pattern to match is surrounded by slashes, optionally followed by flags.
-
-```text
-$..products[?(@.description =~ /.*trainers/i)]
-```
-
-Filters can use [function extensions](#function-extensions) too.
-
-### Union (`|`) and intersection (`&`)
-
-Union (`|`) and intersection (`&`) are similar to Python's set operations, but we don't dedupe the matches (matches will often contain unhashable objects).
-
-The `|` operator combines matches from two or more paths. This example selects a single list of all prices, plus the price cap as the last element.
-
-```text
-$..products.*.price | $.price_cap
-```
-
-The `&` operator produces matches that are common to both left and right paths. This example would select the list of products that are common to both the "footwear" and "headwear" categories.
-
-```text
-$.categories[?(@.name == 'footwear')].products.* & $.categories[?(@.name == 'headwear')].products.*
-```
-
-Note that `|` and `&` are not allowed inside filter expressions.
-
-## Function extensions
-
-TODO:
-
-## Notable differences
-
-This is a list of things that you might find in other JSONPath implementation that we don't support (yet).
-
-- We don't support extension functions of the form `selector.func()`.
-- We always return a list of matches from `jsonpath.findall()`, never a scalar value.
-- We do not support arithmetic in filter expression.
-- Python JSONPath is strictly read only. There are no update "selectors".
-
-And this is a list of areas where we deviate from the [IETF JSONPath draft](https://datatracker.ietf.org/doc/html/draft-ietf-jsonpath-base-11).
-
-- For now, the only built-in function extension is `length()`.
-- We don't require filters that use a function extension to include a comparison operator.
-- Whitespace is mostly insignificant unless inside quotes.
-- The root token (default `$`) is optional.
-- Paths starting with a dot (`.`) are OK. `.thing` is the same as `$.thing`, as is `thing`, `$[thing]` and `$["thing"]`.
-- Nested filters are not supported.
-
-And this is a list of features that are uncommon or unique to Python JSONPath.
-
-- `|` is a union operator, where matches from two or more JSONPaths are combined. This is not part of the Python API, but built-in to the JSONPath syntax.
-- `&` is an intersection operator, where we exclude matches that don't exist in both left and right paths. This is not part of the Python API, but built-in to the JSONPath syntax.
-- `#` is a filter context selector. With usage similar to `$` and `@`, `#` exposes arbitrary data from the `filter_context` argument to `findall()` and `finditer()`.
-
-## License
-
-`python-jsonpath` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

python_jsonpath-0.4.0.dist-info/RECORD

@@ -1,19 +0,0 @@
-jsonpath/__about__.py,sha256=KQpPS9HnR8qrZ7FopeZE_aEgURV3rMaSR0Flb7lvXK4,132
-jsonpath/__init__.py,sha256=rqknIKK4kCu_mlKsCe9c9CoH4W4exuOgmG7Wp0qg5Ao,1023
-jsonpath/env.py,sha256=7Rn43jEd9BTa-Xo0yxwIczV2QaIKOHKkKvZyfoNdKZw,14371
-jsonpath/exceptions.py,sha256=PGHORFjnuln5ot4m9ixIi2BsAADIaaOAbZCXgaX5od4,1796
-jsonpath/filter.py,sha256=lrh6EjOv542a3NoKAdw8bRWQuxxhqmUUF9Ye2Dz9iyg,11536
-jsonpath/lex.py,sha256=v0gqUOvWSODWiv10IPo_80Yr1a8c6fEjpAizY2YxTeg,11085
-jsonpath/match.py,sha256=lJn27VWgTMUeAEO4FtmAmUPvf9FK7hTF8f2yq38KiOk,2513
-jsonpath/parse.py,sha256=v5V5t3TcNaPJaq5YRbWHe1vDYGa8gjIRzEgmRcfzfzw,17562
-jsonpath/path.py,sha256=wIlZDLUscZdAwBshoKR6b0Hb7kCTvYgi1tSlZ2ANb6A,11371
-jsonpath/selectors.py,sha256=O6tGtGLdaChi9NNarsYNaYPSBEmiCUpdn1pyjfh-LKA,21397
-jsonpath/stream.py,sha256=V9OtMAYl6jdsj2G8e3u-vH7L4iFhA-vm4Z2Aom10Dxk,2567
-jsonpath/token.py,sha256=BS01OCzriOGn85NkyGoC93h_96BQn-GXeeeM2k_sDPc,3650
-jsonpath/function_extensions/__init__.py,sha256=w4vQh5zViiLhJ767bG6T27IZrwjvp4r47N3ZVSqaYnA,104
-jsonpath/function_extensions/keys.py,sha256=vNdIV8xqr1LMG6RLJwb6iA5-VXgYSZu6CqprXEs6rYM,364
-jsonpath/function_extensions/length.py,sha256=QdwkLLNTbgNKWIx1M8umAHnc5vyc9cjM_vODc6hXDK0,313
-python_jsonpath-0.4.0.dist-info/METADATA,sha256=LTS_flB6aXxUIBkPlykKK06mYbkE-c7WqIbHRGarecA,12076
-python_jsonpath-0.4.0.dist-info/WHEEL,sha256=Fd6mP6ydyRguakwUJ05oBE7fh2IPxgtDN9IwHJ9OqJQ,87
-python_jsonpath-0.4.0.dist-info/licenses/LICENSE.txt,sha256=0tA1mPzOZoK7XLCxN8Lqnp52hZYHgGqtdbC2L-V6sAs,1102
-python_jsonpath-0.4.0.dist-info/RECORD,,

python_jsonpath-0.4.0.dist-info/licenses/LICENSE.txt

@@ -1,9 +0,0 @@
-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.