python-jsonpath 1.3.2__py3-none-any.whl → 2.0.1__py3-none-any.whl

jsonpath/stream.py

@@ -1,99 +1,97 @@
-# noqa: D100
+"""Step through a stream of tokens."""
+
 from __future__ import annotations
 
-from collections import deque
-from typing import Deque
-from typing import Iterator
+from typing import Iterable
 
 from .exceptions import JSONPathSyntaxError
 from .token import TOKEN_EOF
+from .token import TOKEN_WHITESPACE
 from .token import Token
 
-# ruff: noqa: D102
-
 
 class TokenStream:
-    """Step through or iterate a stream of tokens."""
-
-    def __init__(self, token_iter: Iterator[Token]):
-        self.iter = token_iter
-        self._pushed: Deque[Token] = deque()
-        self.current = Token("", "", -1, "")
-        next(self)
-
-    class TokenStreamIterator:
-        """An iterable token stream."""
-
-        def __init__(self, stream: TokenStream):
-            self.stream = stream
-
-        def __iter__(self) -> Iterator[Token]:
-            return self
-
-        def __next__(self) -> Token:
-            tok = self.stream.current
-            if tok.kind is TOKEN_EOF:
-                self.stream.close()
-                raise StopIteration
-            next(self.stream)
-            return tok
-
-    def __iter__(self) -> Iterator[Token]:
-        return self.TokenStreamIterator(self)
-
-    def __next__(self) -> Token:
-        tok = self.current
-        if self._pushed:
-            self.current = self._pushed.popleft()
-        elif self.current.kind is not TOKEN_EOF:
-            try:
-                self.current = next(self.iter)
-            except StopIteration:
-                self.close()
-        return tok
+    """Step through a stream of tokens."""
+
+    def __init__(self, token_iter: Iterable[Token]):
+        self.tokens = list(token_iter)
+        self.pos = 0
+        path = self.tokens[0].path if self.tokens else ""
+        self.eof = Token(TOKEN_EOF, "", -1, path)
 
     def __str__(self) -> str:  # pragma: no cover
         return f"current: {self.current}\nnext: {self.peek}"
 
-    def next_token(self) -> Token:
-        """Return the next token from the stream."""
-        return next(self)
-
-    @property
-    def peek(self) -> Token:
-        """Look at the next token."""
-        current = next(self)
-        result = self.current
-        self.push(current)
-        return result
-
-    def push(self, tok: Token) -> None:
-        """Push a token back to the stream."""
-        self._pushed.append(self.current)
-        self.current = tok
-
-    def close(self) -> None:
-        """Close the stream."""
-        self.current = Token(TOKEN_EOF, "", -1, "")
+    def current(self) -> Token:
+        """Return the token at the current position in the stream."""
+        try:
+            return self.tokens[self.pos]
+        except IndexError:
+            return self.eof
+
+    def next(self) -> Token:
+        """Return the token at the current position and advance the pointer."""
+        try:
+            token = self.tokens[self.pos]
+            self.pos += 1
+            return token
+        except IndexError:
+            return self.eof
+
+    def peek(self, offset: int = 1) -> Token:
+        """Return the token at current position plus the offset.
+
+        Does not advance the pointer.
+        """
+        try:
+            return self.tokens[self.pos + offset]
+        except IndexError:
+            return self.eof
+
+    def eat(self, kind: str, message: str | None = None) -> Token:
+        """Assert tge type if the current token and advance the pointer."""
+        token = self.next()
+        if token.kind != kind:
+            raise JSONPathSyntaxError(
+                message or f"expected {kind}, found {token.kind!r}",
+                token=token,
+            )
+        return token
 
     def expect(self, *typ: str) -> None:
-        if self.current.kind not in typ:
+        """Raise an exception of the current token is not in `typ`."""
+        token = self.current()
+        if token.kind not in typ:
             if len(typ) == 1:
                 _typ = repr(typ[0])
             else:
                 _typ = f"one of {typ!r}"
             raise JSONPathSyntaxError(
-                f"expected {_typ}, found {self.current.kind!r}",
-                token=self.current,
+                f"expected {_typ}, found {token.kind!r}",
+                token=token,
             )
 
     def expect_peek(self, *typ: str) -> None:
-        if self.peek.kind not in typ:
+        """Raise an exception of the current token is not in `typ`."""
+        token = self.peek()
+        if token.kind not in typ:
             if len(typ) == 1:
                 _typ = repr(typ[0])
             else:
                 _typ = f"one of {typ!r}"
             raise JSONPathSyntaxError(
-                f"expected {_typ}, found {self.peek.kind!r}",
-                token=self.peek,
+                f"expected {_typ}, found {token.kind!r}",
+                token=token,
             )
+
+    def expect_peek_not(self, typ: str, message: str) -> None:
+        """Raise an exception if the next token kind of _typ_."""
+        if self.peek().kind == typ:
+            raise JSONPathSyntaxError(message, token=self.peek())
+
+    def skip_whitespace(self) -> bool:
+        """Skip whitespace."""
+        if self.current().kind == TOKEN_WHITESPACE:
+            self.pos += 1
+            return True
+        return False

jsonpath/token.py

@@ -1,74 +1,72 @@
 """JSONPath tokens."""
+
 import sys
 from typing import Tuple
 
 # Utility tokens
-TOKEN_EOF = sys.intern("EOF")
-TOKEN_ILLEGAL = sys.intern("ILLEGAL")
-TOKEN_SKIP = sys.intern("SKIP")
+TOKEN_EOF = sys.intern("TOKEN_EOF")
+TOKEN_WHITESPACE = sys.intern("TOKEN_WHITESPACE")
+TOKEN_ERROR = sys.intern("TOKEN_ERROR")
 
 # JSONPath expression tokens
-TOKEN_COLON = sys.intern("COLON")
-TOKEN_COMMA = sys.intern("COMMA")
-TOKEN_DDOT = sys.intern("DDOT")
-TOKEN_DOT = sys.intern("DOT")
-TOKEN_DOT_INDEX = sys.intern("DINDEX")
-TOKEN_DOT_PROPERTY = sys.intern("DOT_PROPERTY")
-TOKEN_FILTER = sys.intern("FILTER")
-TOKEN_FAKE_ROOT = sys.intern("FAKE_ROOT")
-TOKEN_KEY = sys.intern("KEY")
-TOKEN_KEYS = sys.intern("KEYS")
-TOKEN_RBRACKET = sys.intern("RBRACKET")
-TOKEN_BARE_PROPERTY = sys.intern("BARE_PROPERTY")
-TOKEN_LIST_SLICE = sys.intern("LSLICE")
-TOKEN_LIST_START = sys.intern("LBRACKET")
-TOKEN_PROPERTY = sys.intern("PROP")
-TOKEN_ROOT = sys.intern("ROOT")
-TOKEN_SLICE_START = sys.intern("SLICE_START")
-TOKEN_SLICE_STEP = sys.intern("SLICE_STEP")
-TOKEN_SLICE_STOP = sys.intern("SLICE_STOP")
-TOKEN_WILD = sys.intern("WILD")
+TOKEN_COLON = sys.intern("TOKEN_COLON")
+TOKEN_COMMA = sys.intern("TOKEN_COMMA")
+TOKEN_DDOT = sys.intern("TOKEN_DDOT")
+TOKEN_DOT = sys.intern("TOKEN_DOT")
+TOKEN_FILTER = sys.intern("TOKEN_FILTER")
+TOKEN_KEY = sys.intern("TOKEN_KEY")
+TOKEN_KEYS = sys.intern("TOKEN_KEYS")
+TOKEN_KEYS_FILTER = sys.intern("TOKEN_KEYS_FILTER")
+TOKEN_LBRACKET = sys.intern("TOKEN_LBRACKET")
+TOKEN_PSEUDO_ROOT = sys.intern("TOKEN_PSEUDO_ROOT")
+TOKEN_RBRACKET = sys.intern("TOKEN_RBRACKET")
+TOKEN_ROOT = sys.intern("TOKEN_ROOT")
+TOKEN_WILD = sys.intern("TOKEN_WILD")
+TOKEN_NAME = sys.intern("TOKEN_NAME")
+TOKEN_DOT_PROPERTY = sys.intern("TOKEN_DOT_PROPERTY")
+TOKEN_DOT_KEY_PROPERTY = sys.intern("TOKEN_DOT_KEY_PROPERTY")
+TOKEN_KEY_NAME = sys.intern("TOKEN_KEY_NAME")
 
 # Filter expression tokens
-TOKEN_AND = sys.intern("AND")
-TOKEN_BLANK = sys.intern("BLANK")
-TOKEN_CONTAINS = sys.intern("CONTAINS")
-TOKEN_FILTER_CONTEXT = sys.intern("FILTER_CONTEXT")
-TOKEN_FUNCTION = sys.intern("FUNCTION")
-TOKEN_EMPTY = sys.intern("EMPTY")
-TOKEN_EQ = sys.intern("EQ")
-TOKEN_FALSE = sys.intern("FALSE")
-TOKEN_FLOAT = sys.intern("FLOAT")
-TOKEN_GE = sys.intern("GE")
-TOKEN_GT = sys.intern("GT")
-TOKEN_IN = sys.intern("IN")
-TOKEN_INT = sys.intern("INT")
-TOKEN_LE = sys.intern("LE")
-TOKEN_LG = sys.intern("LG")
-TOKEN_LPAREN = sys.intern("LPAREN")
-TOKEN_LT = sys.intern("LT")
-TOKEN_NE = sys.intern("NE")
-TOKEN_NIL = sys.intern("NIL")
-TOKEN_NONE = sys.intern("NONE")
-TOKEN_NOT = sys.intern("NOT")
-TOKEN_NULL = sys.intern("NULL")
-TOKEN_OP = sys.intern("OP")
-TOKEN_OR = sys.intern("OR")
-TOKEN_RE = sys.intern("RE")
-TOKEN_RE_FLAGS = sys.intern("RE_FLAGS")
-TOKEN_RE_PATTERN = sys.intern("RE_PATTERN")
-TOKEN_RPAREN = sys.intern("RPAREN")
-TOKEN_SELF = sys.intern("SELF")
-TOKEN_STRING = sys.intern("STRING")
-TOKEN_DOUBLE_QUOTE_STRING = sys.intern("DOUBLE_QUOTE_STRING")
-TOKEN_SINGLE_QUOTE_STRING = sys.intern("SINGLE_QUOTE_STRING")
-TOKEN_TRUE = sys.intern("TRUE")
-TOKEN_UNDEFINED = sys.intern("UNDEFINED")
-TOKEN_MISSING = sys.intern("MISSING")
+TOKEN_AND = sys.intern("TOKEN_AND")
+TOKEN_BLANK = sys.intern("TOKEN_BLANK")
+TOKEN_CONTAINS = sys.intern("TOKEN_CONTAINS")
+TOKEN_DOUBLE_QUOTE_STRING = sys.intern("TOKEN_DOUBLE_QUOTE_STRING")
+TOKEN_EMPTY = sys.intern("TOKEN_EMPTY")
+TOKEN_EQ = sys.intern("TOKEN_EQ")
+TOKEN_FALSE = sys.intern("TOKEN_FALSE")
+TOKEN_FILTER_CONTEXT = sys.intern("TOKEN_FILTER_CONTEXT")
+TOKEN_FLOAT = sys.intern("TOKEN_FLOAT")
+TOKEN_FUNCTION = sys.intern("TOKEN_FUNCTION")
+TOKEN_GE = sys.intern("TOKEN_GE")
+TOKEN_GT = sys.intern("TOKEN_GT")
+TOKEN_IN = sys.intern("TOKEN_IN")
+TOKEN_INT = sys.intern("TOKEN_INT")
+TOKEN_LE = sys.intern("TOKEN_LE")
+TOKEN_LG = sys.intern("TOKEN_LG")
+TOKEN_LPAREN = sys.intern("TOKEN_LPAREN")
+TOKEN_LT = sys.intern("TOKEN_LT")
+TOKEN_MISSING = sys.intern("TOKEN_MISSING")
+TOKEN_NE = sys.intern("TOKEN_NE")
+TOKEN_NIL = sys.intern("TOKEN_NIL")
+TOKEN_NONE = sys.intern("TOKEN_NONE")
+TOKEN_NOT = sys.intern("TOKEN_NOT")
+TOKEN_NULL = sys.intern("TOKEN_NULL")
+TOKEN_OP = sys.intern("TOKEN_OP")
+TOKEN_OR = sys.intern("TOKEN_OR")
+TOKEN_RE = sys.intern("TOKEN_RE")
+TOKEN_RE_FLAGS = sys.intern("TOKEN_RE_FLAGS")
+TOKEN_RE_PATTERN = sys.intern("TOKEN_RE_PATTERN")
+TOKEN_RPAREN = sys.intern("TOKEN_RPAREN")
+TOKEN_SELF = sys.intern("TOKEN_SELF")
+TOKEN_SINGLE_QUOTE_STRING = sys.intern("TOKEN_SINGLE_QUOTE_STRING")
+TOKEN_STRING = sys.intern("TOKEN_STRING")
+TOKEN_TRUE = sys.intern("TOKEN_TRUE")
+TOKEN_UNDEFINED = sys.intern("TOKEN_UNDEFINED")
 
 # Extension tokens
-TOKEN_UNION = sys.intern("UNION")
-TOKEN_INTERSECTION = sys.intern("INTERSECT")
+TOKEN_INTERSECTION = sys.intern("TOKEN_INTERSECTION")
+TOKEN_UNION = sys.intern("TOKEN_UNION")
 
 
 class Token:
@@ -99,7 +97,7 @@ class Token:
 
     def __repr__(self) -> str:  # pragma: no cover
         return (
-            f"Token(kind={self.kind!r}, value={self.value!r}, "
+            f"Token(kind={self.kind}, value={self.value!r}, "
             f"index={self.index}, path={self.path!r})"
         )
 

jsonpath/unescape.py

@@ -0,0 +1,134 @@
+r"""Replace `\uXXXX` escape sequences with Unicode code points."""
+
+from typing import List
+from typing import Tuple
+
+from .exceptions import JSONPathSyntaxError
+from .token import Token
+
+
+def unescape_string(value: str, token: Token, quote: str) -> str:
+    """Return `value` with escape sequences replaced with Unicode code points."""
+    unescaped: List[str] = []
+    index = 0
+
+    while index < len(value):
+        ch = value[index]
+        if ch == "\\":
+            index += 1
+            _ch, index = _decode_escape_sequence(value, index, token, quote)
+            unescaped.append(_ch)
+        else:
+            _string_from_codepoint(ord(ch), token)
+            unescaped.append(ch)
+        index += 1
+    return "".join(unescaped)
+
+
+def _decode_escape_sequence(  # noqa: PLR0911
+    value: str, index: int, token: Token, quote: str
+) -> Tuple[str, int]:
+    try:
+        ch = value[index]
+    except IndexError as err:
+        raise JSONPathSyntaxError("incomplete escape sequence", token=token) from err
+
+    if ch == quote:
+        return quote, index
+    if ch == "\\":
+        return "\\", index
+    if ch == "/":
+        return "/", index
+    if ch == "b":
+        return "\x08", index
+    if ch == "f":
+        return "\x0c", index
+    if ch == "n":
+        return "\n", index
+    if ch == "r":
+        return "\r", index
+    if ch == "t":
+        return "\t", index
+    if ch == "u":
+        codepoint, index = _decode_hex_char(value, index, token)
+        return _string_from_codepoint(codepoint, token), index
+
+    raise JSONPathSyntaxError(
+        f"unknown escape sequence at index {token.index + index - 1}",
+        token=token,
+    )
+
+
+def _decode_hex_char(value: str, index: int, token: Token) -> Tuple[int, int]:
+    length = len(value)
+
+    if index + 4 >= length:
+        raise JSONPathSyntaxError(
+            f"incomplete escape sequence at index {token.index + index - 1}",
+            token=token,
+        )
+
+    index += 1  # move past 'u'
+    codepoint = _parse_hex_digits(value[index : index + 4], token)
+
+    if _is_low_surrogate(codepoint):
+        raise JSONPathSyntaxError(
+            f"unexpected low surrogate at index {token.index + index - 1}",
+            token=token,
+        )
+
+    if _is_high_surrogate(codepoint):
+        # expect a surrogate pair
+        if not (
+            index + 9 < length and value[index + 4] == "\\" and value[index + 5] == "u"
+        ):
+            raise JSONPathSyntaxError(
+                f"incomplete escape sequence at index {token.index + index - 2}",
+                token=token,
+            )
+
+        low_surrogate = _parse_hex_digits(value[index + 6 : index + 10], token)
+
+        if not _is_low_surrogate(low_surrogate):
+            raise JSONPathSyntaxError(
+                f"unexpected codepoint at index {token.index + index + 4}",
+                token=token,
+            )
+
+        codepoint = 0x10000 + (((codepoint & 0x03FF) << 10) | (low_surrogate & 0x03FF))
+
+        return (codepoint, index + 9)
+
+    return (codepoint, index + 3)
+
+
+def _parse_hex_digits(digits: str, token: Token) -> int:
+    codepoint = 0
+    for digit in digits.encode():
+        codepoint <<= 4
+        if digit >= 48 and digit <= 57:
+            codepoint |= digit - 48
+        elif digit >= 65 and digit <= 70:
+            codepoint |= digit - 65 + 10
+        elif digit >= 97 and digit <= 102:
+            codepoint |= digit - 97 + 10
+        else:
+            raise JSONPathSyntaxError(
+                "invalid \\uXXXX escape sequence",
+                token=token,
+            )
+    return codepoint
+
+
+def _string_from_codepoint(codepoint: int, token: Token) -> str:
+    if codepoint <= 0x1F:
+        raise JSONPathSyntaxError("invalid character", token=token)
+    return chr(codepoint)
+
+
+def _is_high_surrogate(codepoint: int) -> bool:
+    return codepoint >= 0xD800 and codepoint <= 0xDBFF
+
+
+def _is_low_surrogate(codepoint: int) -> bool:
+    return codepoint >= 0xDC00 and codepoint <= 0xDFFF

{python_jsonpath-1.3.2.dist-info → python_jsonpath-2.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-jsonpath
-Version: 1.3.2
+Version: 2.0.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
@@ -8,6 +8,7 @@ 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
+Keywords: JSON,JSON Patch,JSON Path,JSON Pointer,JSONPath,RFC 9535
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -21,6 +22,9 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.8
+Provides-Extra: strict
+Requires-Dist: iregexp-check>=0.1.4; extra == 'strict'
+Requires-Dist: regex; extra == 'strict'
 Description-Content-Type: text/markdown
 
 <h1 align="center">Python JSONPath</h1>
@@ -91,9 +95,9 @@ conda install -c conda-forge python-jsonpath
 
 ## Related projects
 
-- [JSONPath RFC 9535](https://github.com/jg-rp/python-jsonpath-rfc9535) - A Python implementation of JSONPath that follows RFC 9535 much more strictly. If you require maximum interoperability with JSONPath implemented in other languages - at the expense of extra features - choose [jsonpath-rfc9535](https://pypi.org/project/jsonpath-rfc9535/) over [python-jsonpath](https://pypi.org/project/python-jsonpath/).
+- [JSONPath RFC 9535](https://github.com/jg-rp/python-jsonpath-rfc9535) - A minimal, slightly cleanr Python implementation of RFC 9535. If you're not interested JSONPath sytax beyond that defined in RFC 9535, you might choose [jsonpath-rfc9535](https://pypi.org/project/jsonpath-rfc9535/) over [python-jsonpath](https://pypi.org/project/python-jsonpath/).
 
-  jsonpath-rfc9535 matches RFC 9535's JSONPath model internally and is careful to use the spec's terminology. It also includes utilities for verifying and testing the [JSONPath Compliance Test Suite](https://github.com/jsonpath-standard/jsonpath-compliance-test-suite). Most notably the nondeterministic behavior of some JSONPath selectors.
+  jsonpath-rfc9535 also includes utilities for verifying and testing the [JSONPath Compliance Test Suite](https://github.com/jsonpath-standard/jsonpath-compliance-test-suite). Most notably the nondeterministic behavior of some JSONPath selectors.
 
 - [JSON P3](https://github.com/jg-rp/json-p3) - RFC 9535 implemented in TypeScript. JSON P3 does not include all the non-standard features of Python JSONPath, but does define some optional [extra syntax](https://jg-rp.github.io/json-p3/guides/jsonpath-extra).
 

python_jsonpath-2.0.1.dist-info/RECORD

@@ -0,0 +1,42 @@
+jsonpath/__about__.py,sha256=-7JogzyaEMlAT9mZnAfz6WvYW2e1688bbokpApou5SM,132
+jsonpath/__init__.py,sha256=-a4CE0KwMtXNtOvTIriRZ37EQezZ85EpLz7sj2XpXeQ,11101
+jsonpath/__main__.py,sha256=6Y5wOE7U-MHymopXOsxofaY30tVZYPGTJO0L4vytoUw,61
+jsonpath/_data.py,sha256=JEpu5Kg0_kgxYKUilBcHVdTmPxf3-Vc0NgaW6olsqyY,577
+jsonpath/_types.py,sha256=mxwypalUAI64XdDwXCwIM_1MXCUOTM13y826j-UD8LY,818
+jsonpath/cli.py,sha256=QNDOzRvGWW9jDNhPpsE9tL1jyS9LS5kSQeMh3q86C6E,10217
+jsonpath/env.py,sha256=G0UK9NZvxaLEicdD10hxrd3C_pp-o9FxekkzpZb_O4I,24540
+jsonpath/exceptions.py,sha256=V7A4A76NjFffa11ePEYgYcV6gG8sdmL9fh3KGEGqPu8,6498
+jsonpath/filter.py,sha256=W4TyM8um0AQzA_m4Iy-dr1Jd5341YmTP6UWmXfSpia4,22617
+jsonpath/fluent_api.py,sha256=mfAA2t-xUGOmGVr_1h9lxo3y4FsAvaxOpvOH8jZ4DHU,9117
+jsonpath/lex.py,sha256=_64KcaE5Mi3-E5DdYMyX1tHRHtokQWXGKT-ToMb_dfs,12019
+jsonpath/lru_cache.py,sha256=ohd_ssx2UnBWlLyt16bh2Vg6a_SDA1xHyI_wyOkHLvY,4047
+jsonpath/match.py,sha256=hPz0OEVJOYJ3MzenJuUzxxHSC0-NNPrLyHXHBRYzOZE,4167
+jsonpath/parse.py,sha256=QplaB5u2QRl_MyVUDkJ39cPKI6s2oX-ztZ10KUcxNQM,29973
+jsonpath/patch.py,sha256=pwlAPFlwHZ-gW8COy60Axk9e1yIVNnQ4ctD0IEILaA4,25593
+jsonpath/path.py,sha256=k4LEmfMhNcJ0ZnEIqOX--G1SoCWhtZZ2S1OzC6kHotA,15661
+jsonpath/pointer.py,sha256=VEd_cX2_5eR-z755yRatmIS-OLAl_e-9wZhF-t4F1YM,23037
+jsonpath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jsonpath/segments.py,sha256=a3gTT6capn2VTjMLbVUeYgkzNhEMCjcopZh7WkdrGbs,4458
+jsonpath/selectors.py,sha256=ozxKBwd81E3Fd0F-E-9nrPZYqmNLfdrWYjliGfE8jGU,24645
+jsonpath/serialize.py,sha256=viMcWY52wkUseTNfPKillVWswHePJ2L_B3PV3bDVvmU,360
+jsonpath/stream.py,sha256=oAucLnRJWlBgz543oF1o89RsIcZA2zSSOZnlOaE7qd0,3090
+jsonpath/token.py,sha256=fc8fio4pqVyV3cJee79AQlOKEaXpVFJtTAAXfgGFohg,4167
+jsonpath/unescape.py,sha256=CBZawMNDL5VWGKC4BkyocSrv3pCeOtXD6AEIjcMPkFI,3973
+jsonpath/function_extensions/__init__.py,sha256=dcbt-G40PbksRTK1nw7Q8ZYrxiD2xev6wAmh0kiPVcY,602
+jsonpath/function_extensions/_pattern.py,sha256=Ham8k79oWR0CoSgA1M3Wdm9Xw1jkhShFZsYI6-9534I,3267
+jsonpath/function_extensions/arguments.py,sha256=gldld_5YHBEWRsZ5jDj9sDm3qj8i6O_8PlOQ3hdH0WU,1696
+jsonpath/function_extensions/count.py,sha256=FzTOkOLa01PFFSR1wjkDEOyBr_ZC_6yrNfFyGgx7NAk,581
+jsonpath/function_extensions/filter_function.py,sha256=B6z-02xO6CtNghLN92Acr_UmeiWwJaRDLCOTMcPOrfg,834
+jsonpath/function_extensions/is_instance.py,sha256=qm9m3UpKJew7qsuSQ5dEem7Ybo4jhCM1uf12wre0SRg,1760
+jsonpath/function_extensions/keys.py,sha256=-m4MwUvSRN9A1_3LLM3FQaOjKzvbhyGtyn86ph9WPDc,822
+jsonpath/function_extensions/length.py,sha256=Z9gtz0zhzT1_8LzzHm1TRhJlMWT5yEsqNtQCuWg14I0,786
+jsonpath/function_extensions/match.py,sha256=LdVfX7b_AMhwkSMh-kyNogTpI7_neBxOlQuvrZQjO4c,573
+jsonpath/function_extensions/search.py,sha256=H2Si0js_UG6LACxHfZDPhKK8qqmVtUUhr3TY0i3hrkE,573
+jsonpath/function_extensions/starts_with.py,sha256=z-9hkNjQQj_p579CnM6W-E6nc1ucooHHwKwpefO_EBA,676
+jsonpath/function_extensions/typeof.py,sha256=yCAj9zOqSnam1mfHCGolNHWDmsBOvU3rAhbZDYycx50,1780
+jsonpath/function_extensions/value.py,sha256=fQMbPUV87Jn1nOwAlBpTeLmLIG5ejH0XQBOM_SR-Us4,721
+python_jsonpath-2.0.1.dist-info/METADATA,sha256=fyv3QwOwtVsP_9Nkqv-1Cn8Natr-WHF1jd0n9gYFAts,6529
+python_jsonpath-2.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_jsonpath-2.0.1.dist-info/entry_points.txt,sha256=xvbWnAebJyOMI_9ugK0xrpFRlwmEsAJD2kNHU0Dvscc,43
+python_jsonpath-2.0.1.dist-info/licenses/LICENSE.txt,sha256=u7PksAQGI1QYWcERHeauMseZ4XAzDKUrKW8Z4wbeU1k,1101
+python_jsonpath-2.0.1.dist-info/RECORD,,

python_jsonpath-1.3.2.dist-info/RECORD

@@ -1,36 +0,0 @@
-jsonpath/__about__.py,sha256=lKzAT7eRQ0XCM36oMem3ZY_sdLarE9W-QFI1Ret5qKc,132
-jsonpath/__init__.py,sha256=WlqHtXZcMy2AnAqvBQeiUcS1_I7Upif2j7SSLYZGTNg,2335
-jsonpath/__main__.py,sha256=6Y5wOE7U-MHymopXOsxofaY30tVZYPGTJO0L4vytoUw,61
-jsonpath/_data.py,sha256=JEpu5Kg0_kgxYKUilBcHVdTmPxf3-Vc0NgaW6olsqyY,577
-jsonpath/cli.py,sha256=scpWfJXl1jLQ80ZyXqMCu8JtRgZUXluC11x6OkC4oeA,10026
-jsonpath/env.py,sha256=Q3ymsGf0ktpiVGU5OLjYCayHFCEfN-jvZCjFzFJJ3HU,22814
-jsonpath/exceptions.py,sha256=ku3XNuMn4CsYhe-iZpZ8DuFPR2AEcV0SEl55X3Huhaw,4218
-jsonpath/filter.py,sha256=Ay71K1PzI3_Vur5Y7pAQguV0ceo4yqBZVsuj_jD7nck,22755
-jsonpath/fluent_api.py,sha256=mfAA2t-xUGOmGVr_1h9lxo3y4FsAvaxOpvOH8jZ4DHU,9117
-jsonpath/lex.py,sha256=8yrSLd3Q3A9Y4GeacOjboUp40XsR_BkRDQ3CC3UVcP8,10296
-jsonpath/match.py,sha256=qJ8IUn8RsuC-iL6RKr2vTn0l1f7bcx1m9cnZiAEqYH0,3657
-jsonpath/parse.py,sha256=s7BuFsSgX2GuDubrFr-SDcCk2ZInGzPV04FNFcUwxPM,25214
-jsonpath/patch.py,sha256=T6CP0GDJg6drD9qWs6ueRFdQRhXj_xPGEtW5x01iJb8,25388
-jsonpath/path.py,sha256=RUeP7k_WcvP5ZnYblcRDd_-wgo9VnMKyIevTcRImYE4,16421
-jsonpath/pointer.py,sha256=UjqqWQWL8D-chjSEQ2al_Ev5xcHaKxFFfQxPfuBSwO0,23100
-jsonpath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jsonpath/selectors.py,sha256=oesy964W8Qd1qSSb0qtWJY63A2D0lZc0ppF-pGEYmgU,27313
-jsonpath/serialize.py,sha256=viMcWY52wkUseTNfPKillVWswHePJ2L_B3PV3bDVvmU,360
-jsonpath/stream.py,sha256=S1xxgOsJlivu6Y8-kejMoYm7MgSlhjnoX_H5cem5Yhk,2815
-jsonpath/token.py,sha256=2xD2Wrxj7TgyREUhQxzcBcOWLhjz8demYBJ7BqaNJMA,3938
-jsonpath/function_extensions/__init__.py,sha256=wrUayhwlm6iNLnSIx_ER6EeGiqR91T_SIjNBUr42nX0,548
-jsonpath/function_extensions/arguments.py,sha256=gldld_5YHBEWRsZ5jDj9sDm3qj8i6O_8PlOQ3hdH0WU,1696
-jsonpath/function_extensions/count.py,sha256=FzTOkOLa01PFFSR1wjkDEOyBr_ZC_6yrNfFyGgx7NAk,581
-jsonpath/function_extensions/filter_function.py,sha256=B6z-02xO6CtNghLN92Acr_UmeiWwJaRDLCOTMcPOrfg,834
-jsonpath/function_extensions/is_instance.py,sha256=qm9m3UpKJew7qsuSQ5dEem7Ybo4jhCM1uf12wre0SRg,1760
-jsonpath/function_extensions/keys.py,sha256=vNdIV8xqr1LMG6RLJwb6iA5-VXgYSZu6CqprXEs6rYM,364
-jsonpath/function_extensions/length.py,sha256=Z9gtz0zhzT1_8LzzHm1TRhJlMWT5yEsqNtQCuWg14I0,786
-jsonpath/function_extensions/match.py,sha256=KjsH33fCFGonp2RV__FuaeIOTwLLcvgaaCi0juyEl-U,712
-jsonpath/function_extensions/search.py,sha256=O11fnkHlbvf0QPrLISYfhlPXBvVPBr-U8V0dGbd614Y,710
-jsonpath/function_extensions/typeof.py,sha256=yCAj9zOqSnam1mfHCGolNHWDmsBOvU3rAhbZDYycx50,1780
-jsonpath/function_extensions/value.py,sha256=fQMbPUV87Jn1nOwAlBpTeLmLIG5ejH0XQBOM_SR-Us4,721
-python_jsonpath-1.3.2.dist-info/METADATA,sha256=_fv6UDYXR5zUSS_JPOqW8yM4pgdLxz-MhHS1b4BN_qg,6493
-python_jsonpath-1.3.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_jsonpath-1.3.2.dist-info/entry_points.txt,sha256=xvbWnAebJyOMI_9ugK0xrpFRlwmEsAJD2kNHU0Dvscc,43
-python_jsonpath-1.3.2.dist-info/licenses/LICENSE.txt,sha256=u7PksAQGI1QYWcERHeauMseZ4XAzDKUrKW8Z4wbeU1k,1101
-python_jsonpath-1.3.2.dist-info/RECORD,,