python-jsonpath 1.0.0__py3-none-any.whl → 1.1.1__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__ = "1.0.0"
+__version__ = "1.1.1"

jsonpath/__init__.py

@@ -17,6 +17,7 @@ from .exceptions import RelativeJSONPointerError
 from .exceptions import RelativeJSONPointerIndexError
 from .exceptions import RelativeJSONPointerSyntaxError
 from .filter import UNDEFINED
+from .fluent_api import Query
 from .lex import Lexer
 from .match import JSONPathMatch
 from .parse import Parser
@@ -52,6 +53,8 @@ __all__ = (
     "Lexer",
     "match",
     "Parser",
+    "query",
+    "Query",
     "RelativeJSONPointer",
     "RelativeJSONPointerError",
     "RelativeJSONPointerIndexError",
@@ -69,3 +72,4 @@ findall_async = DEFAULT_ENV.findall_async
 finditer = DEFAULT_ENV.finditer
 finditer_async = DEFAULT_ENV.finditer_async
 match = DEFAULT_ENV.match
+query = DEFAULT_ENV.query

jsonpath/env.py

@@ -27,6 +27,7 @@ from .filter import FilterExpression
 from .filter import FunctionExtension
 from .filter import InfixExpression
 from .filter import Path
+from .fluent_api import Query
 from .function_extensions import ExpressionType
 from .function_extensions import FilterFunction
 from .function_extensions import validate
@@ -76,8 +77,6 @@ class JSONPathEnvironment:
     - Hook in to mapping and sequence item getting by overriding `getitem()`.
     - Change filter comparison operator behavior by overriding `compare()`.
 
-    ## Class attributes
-
     Arguments:
         filter_caching (bool): If `True`, filter expressions will be cached
             where possible.
@@ -89,6 +88,8 @@ class JSONPathEnvironment:
 
             **New in version 0.10.0**
 
+    ## Class attributes
+
     Attributes:
         fake_root_token (str): The pattern used to select a "fake" root node, one level
             above the real root node.
@@ -229,9 +230,9 @@ class JSONPathEnvironment:
         *,
         filter_context: Optional[FilterContextVars] = None,
     ) -> List[object]:
-        """Find all objects in `data` matching the given JSONPath `path`.
+        """Find all objects in _data_ matching the JSONPath _path_.
 
-        If `data` is a string or a file-like objects, it will be loaded
+        If _data_ is a string or a file-like objects, it will be loaded
         using `json.loads()` and the default `JSONDecoder`.
 
         Arguments:
@@ -259,10 +260,10 @@ class JSONPathEnvironment:
         *,
         filter_context: Optional[FilterContextVars] = None,
     ) -> Iterable[JSONPathMatch]:
-        """Generate `JSONPathMatch` objects for each match.
+        """Generate `JSONPathMatch` objects for each match of _path_ in _data_.
 
-        If `data` is a string or a file-like objects, it will be loaded
-        using `json.loads()` and the default `JSONDecoder`.
+        If _data_ is a string or a file-like objects, it will be loaded using
+        `json.loads()` and the default `JSONDecoder`.
 
         Arguments:
             path: The JSONPath as a string.
@@ -310,6 +311,50 @@ class JSONPathEnvironment:
         """
         return self.compile(path).match(data, filter_context=filter_context)
 
+    def query(
+        self,
+        path: str,
+        data: Union[str, IOBase, Sequence[Any], Mapping[str, Any]],
+        filter_context: Optional[FilterContextVars] = None,
+    ) -> Query:
+        """Return a `Query` object over matches found by applying _path_ to _data_.
+
+        `Query` objects are iterable.
+
+        ```
+        for match in jsonpath.query("$.foo..bar", data):
+            ...
+        ```
+
+        You can skip and limit results with `Query.skip()` and `Query.limit()`.
+
+        ```
+        matches = (
+            jsonpath.query("$.foo..bar", data)
+            .skip(5)
+            .limit(10)
+        )
+
+        for match in matches
+            ...
+        ```
+
+        `Query.tail()` will get the last _n_ results.
+
+        ```
+        for match in jsonpath.query("$.foo..bar", data).tail(5):
+            ...
+        ```
+
+        Get values for each match using `Query.values()`.
+
+        ```
+        for obj in jsonpath.query("$.foo..bar", data).limit(5).values():
+            ...
+        ```
+        """
+        return Query(self.finditer(path, data, filter_context=filter_context))
+
     async def findall_async(
         self,
         path: str,

jsonpath/filter.py

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

jsonpath/fluent_api.py

@@ -0,0 +1,161 @@
+"""A fluent API for managing JSONPathMatch iterators."""
+from __future__ import annotations
+
+import collections
+import itertools
+from typing import TYPE_CHECKING
+from typing import Iterable
+from typing import Iterator
+from typing import Optional
+from typing import Tuple
+
+if TYPE_CHECKING:
+    from jsonpath import JSONPathMatch
+    from jsonpath import JSONPointer
+
+
+class Query:
+    """A fluent API for managing `JSONPathMatch` iterators.
+
+    Usually you'll want to use `jsonpath.query()` or `JSONPathEnvironment.query()`
+    to create instances of `Query` rather than instantiating `Query` directly.
+
+    Arguments:
+        it: A `JSONPathMatch` iterable, as you'd get from `jsonpath.finditer()` or
+            `JSONPathEnvironment.finditer()`.
+
+    **New in version 1.1.0**
+    """
+
+    def __init__(self, it: Iterable[JSONPathMatch]) -> None:
+        self._it = iter(it)
+
+    def __iter__(self) -> Iterator[JSONPathMatch]:
+        return self._it
+
+    def limit(self, n: int) -> Query:
+        """Limit the query iterator to at most _n_ matches.
+
+        Raises:
+            ValueError: If _n_ < 0.
+        """
+        if n < 0:
+            raise ValueError("can't limit by a negative number of matches")
+
+        self._it = itertools.islice(self._it, n)
+        return self
+
+    def head(self, n: int) -> Query:
+        """Limit the query iterator to at most the first _n_ matches.
+
+        `head()` is an alias for `limit()`.
+
+        Raises:
+            ValueError: If _n_ < 0.
+        """
+        return self.limit(n)
+
+    def first(self, n: int) -> Query:
+        """Limit the query iterator to at most the first _n_ matches.
+
+        `first()` is an alias for `limit()`.
+
+        Raises:
+            ValueError: If _n_ < 0.
+        """
+        return self.limit(n)
+
+    def drop(self, n: int) -> Query:
+        """Skip up to _n_ matches from the query iterator.
+
+        Raises:
+            ValueError: If _n_ < 0.
+        """
+        if n < 0:
+            raise ValueError("can't drop a negative number of matches")
+
+        if n > 0:
+            next(itertools.islice(self._it, n, n), None)
+
+        return self
+
+    def skip(self, n: int) -> Query:
+        """Skip up to _n_ matches from the query iterator.
+
+        Raises:
+            ValueError: If _n_ < 0.
+        """
+        return self.drop(n)
+
+    def tail(self, n: int) -> Query:
+        """Drop matches up to the last _n_ matches from the iterator.
+
+        Raises:
+            ValueError: If _n_ < 0.
+        """
+        if n < 0:
+            raise ValueError("can't select a negative number of matches")
+
+        self._it = iter(collections.deque(self._it, maxlen=n))
+        return self
+
+    def last(self, n: int) -> Query:
+        """Drop up to the last _n_ matches from the iterator.
+
+        `last()` is an alias for `tail()`.
+
+        Raises:
+            ValueError: If _n_ < 0.
+        """
+        return self.tail(n)
+
+    def values(self) -> Iterable[object]:
+        """Return an iterable of objects associated with each match."""
+        return (m.obj for m in self._it)
+
+    def locations(self) -> Iterable[str]:
+        """Return an iterable of normalized paths, one for each match."""
+        return (m.path for m in self._it)
+
+    def items(self) -> Iterable[Tuple[str, object]]:
+        """Return an iterable of (object, path) tuples, one for each match."""
+        return ((m.path, m.obj) for m in self._it)
+
+    def pointers(self) -> Iterable[JSONPointer]:
+        """Return an iterable of JSONPointers, one for each match."""
+        return (m.pointer() for m in self._it)
+
+    def first_one(self) -> Optional[JSONPathMatch]:
+        """Return the first `JSONPathMatch` or `None` if there were no matches."""
+        try:
+            return next(self._it)
+        except StopIteration:
+            return None
+
+    def one(self) -> Optional[JSONPathMatch]:
+        """Return the first `JSONPathMatch` or `None` if there were no matches.
+
+        `one()` is an alias for `first_one()`.
+        """
+        return self.first_one()
+
+    def last_one(self) -> Optional[JSONPathMatch]:
+        """Return the last `JSONPathMatch` or `None` if there were no matches."""
+        try:
+            return next(iter(self.tail(1)))
+        except StopIteration:
+            return None
+
+    def tee(self, n: int = 2) -> Tuple[Query, ...]:
+        """Return _n_ independent queries by teeing this query's iterator.
+
+        It is not safe to use a `Query` instance after calling `tee()`.
+        """
+        return tuple(Query(it) for it in itertools.tee(self._it, n))
+
+    def take(self, n: int) -> Query:
+        """Return a new query iterating over the next _n_ matches.
+
+        It is safe to continue using this query after calling take.
+        """
+        return Query(list(itertools.islice(self._it, n)))

jsonpath/match.py

@@ -76,6 +76,11 @@ class JSONPathMatch:
         """Return a `JSONPointer` pointing to this match's path."""
         return JSONPointer.from_match(self)
 
+    @property
+    def value(self) -> object:
+        """Return the value associated with this match/node."""
+        return self.obj
+
 
 def _truncate(val: str, num: int, end: str = "...") -> str:
     # Replaces consecutive whitespace with a single newline.

jsonpath/parse.py

@@ -1,4 +1,5 @@
 """The default JSONPath parser."""
+
 from __future__ import annotations
 
 import json
@@ -142,14 +143,15 @@ class Parser:
     """A JSONPath parser bound to a JSONPathEnvironment."""
 
     PRECEDENCE_LOWEST = 1
-    PRECEDENCE_LOGICALRIGHT = 3
-    PRECEDENCE_LOGICAL = 4
+    PRECEDENCE_LOGICALRIGHT = 2
+    PRECEDENCE_LOGICAL_OR = 3
+    PRECEDENCE_LOGICAL_AND = 4
     PRECEDENCE_RELATIONAL = 5
     PRECEDENCE_MEMBERSHIP = 6
     PRECEDENCE_PREFIX = 7
 
     PRECEDENCES = {
-        TOKEN_AND: PRECEDENCE_LOGICAL,
+        TOKEN_AND: PRECEDENCE_LOGICAL_AND,
         TOKEN_CONTAINS: PRECEDENCE_MEMBERSHIP,
         TOKEN_EQ: PRECEDENCE_RELATIONAL,
         TOKEN_GE: PRECEDENCE_RELATIONAL,
@@ -160,7 +162,7 @@ class Parser:
         TOKEN_LT: PRECEDENCE_RELATIONAL,
         TOKEN_NE: PRECEDENCE_RELATIONAL,
         TOKEN_NOT: PRECEDENCE_PREFIX,
-        TOKEN_OR: PRECEDENCE_LOGICAL,
+        TOKEN_OR: PRECEDENCE_LOGICAL_OR,
         TOKEN_RE: PRECEDENCE_RELATIONAL,
         TOKEN_RPAREN: PRECEDENCE_LOWEST,
     }
@@ -563,9 +565,9 @@ class Parser:
 
     def parse_regex(self, stream: TokenStream) -> FilterExpression:
         pattern = stream.current.value
+        flags = 0
         if stream.peek.kind == TOKEN_RE_FLAGS:
             stream.next_token()
-            flags = 0
             for flag in set(stream.current.value):
                 flags |= self.RE_FLAG_MAP[flag]
         return RegexLiteral(value=re.compile(pattern, flags))

jsonpath/selectors.py

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

{python_jsonpath-1.0.0.dist-info → python_jsonpath-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-jsonpath
-Version: 1.0.0
+Version: 1.1.1
 Summary: JSONPath, JSON Pointer and JSON Patch for Python.
 Project-URL: Documentation, https://jg-rp.github.io/python-jsonpath/
 Project-URL: Issues, https://github.com/jg-rp/python-jsonpath/issues

{python_jsonpath-1.0.0.dist-info → python_jsonpath-1.1.1.dist-info}/RECORD

@@ -1,19 +1,20 @@
-jsonpath/__about__.py,sha256=Cu-PEBxbBVY0OAuHBjefIrn3EkElmKpnhNWrTPtFgvI,132
-jsonpath/__init__.py,sha256=VyX-rbLzz-g-2khpIKPE4Xg92LidBatcuNllQkCKl-c,2022
+jsonpath/__about__.py,sha256=E4FhSU883i2VaRcAnHWVbCWT0excoHeyG4xrr6DJ54M,132
+jsonpath/__init__.py,sha256=oMtSyvfoxP5zIiSvlLHXSG716i-zZ1R5ZtqDortONC0,2104
 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=MEI4sSysatNfqVcTzwhn5f5kdkMJBb72dizXJZLGBbM,21084
+jsonpath/env.py,sha256=kxlYqOIagW6arm4tinlinTkk_opy9ClTgWMJH8B5r3Y,22240
 jsonpath/exceptions.py,sha256=5n-9vaKTu5asWllHT0IN-824ewcNCyQIyKvQ58TERVk,4351
-jsonpath/filter.py,sha256=oJ0M2D0UZ_Y5AkcVgaNuvm9P6vB2Gl7JVuyZBjICEG0,20511
+jsonpath/filter.py,sha256=ocrU4l1QwYquf-GQzkRClbX1mGcdRwqg_hbdQ08DV-I,20638
+jsonpath/fluent_api.py,sha256=59MB8h3Q23oxpMrLTBYCVVpAGIdqd-OYamDOB9yw6m0,4795
 jsonpath/lex.py,sha256=7Nt7l_VyfkgDdtdDSJXP91uJRTAFH2pktm_j0W6oQDQ,10265
-jsonpath/match.py,sha256=_5ds2mEM0jBmo8uBuLA39o8ulKPs5_QvBQ373RduwGo,3369
-jsonpath/parse.py,sha256=5f7GYUOVTZqsYKy_50BzGNlxmqNtKQ1rsR9ZIjcmPyM,23563
+jsonpath/match.py,sha256=b8fkPHsYjJSrTEOi68MFEyOCj0-FoQjFmMq-Ex4qvo0,3503
+jsonpath/parse.py,sha256=66ZcMACyf6yesClpjj0RY0O_YPjHZ5eikVxDFROXnkU,23601
 jsonpath/patch.py,sha256=V_BiRr20qyByBNppBeA0e2I1nfbPJ_svPspDubMzA20,21350
 jsonpath/path.py,sha256=SEGCzoIpWWuUaMyVs2zHD4U1zUCtw3OSJgNHUMY6fys,14645
 jsonpath/pointer.py,sha256=YvfNAp5qADiqJGuTE1jvPrtCTVyyDk9rlT2xJB9SjtE,22234
 jsonpath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jsonpath/selectors.py,sha256=lYTzTYSBbAnx3gO-71Hixt3pFwre0S3cTRGwPnAppHY,26416
+jsonpath/selectors.py,sha256=u7YcHBt_yEQv0CeTtsOwVQuP5bHLT0_lnulUwShCKdQ,27370
 jsonpath/stream.py,sha256=S1xxgOsJlivu6Y8-kejMoYm7MgSlhjnoX_H5cem5Yhk,2815
 jsonpath/token.py,sha256=2xD2Wrxj7TgyREUhQxzcBcOWLhjz8demYBJ7BqaNJMA,3938
 jsonpath/function_extensions/__init__.py,sha256=wrUayhwlm6iNLnSIx_ER6EeGiqR91T_SIjNBUr42nX0,548
@@ -27,8 +28,8 @@ jsonpath/function_extensions/match.py,sha256=KjsH33fCFGonp2RV__FuaeIOTwLLcvgaaCi
 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.0.0.dist-info/METADATA,sha256=SQuPGGkwvbg-Y7ihzSQ7j0jJaHOXG6eVHy6Alp3NfgA,5346
-python_jsonpath-1.0.0.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
-python_jsonpath-1.0.0.dist-info/entry_points.txt,sha256=xvbWnAebJyOMI_9ugK0xrpFRlwmEsAJD2kNHU0Dvscc,43
-python_jsonpath-1.0.0.dist-info/licenses/LICENSE.txt,sha256=u7PksAQGI1QYWcERHeauMseZ4XAzDKUrKW8Z4wbeU1k,1101
-python_jsonpath-1.0.0.dist-info/RECORD,,
+python_jsonpath-1.1.1.dist-info/METADATA,sha256=Kfwo1Zy1v-NjBzt9af3ac9fKclvAiudFYx3E59_wYYY,5346
+python_jsonpath-1.1.1.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
+python_jsonpath-1.1.1.dist-info/entry_points.txt,sha256=xvbWnAebJyOMI_9ugK0xrpFRlwmEsAJD2kNHU0Dvscc,43
+python_jsonpath-1.1.1.dist-info/licenses/LICENSE.txt,sha256=u7PksAQGI1QYWcERHeauMseZ4XAzDKUrKW8Z4wbeU1k,1101
+python_jsonpath-1.1.1.dist-info/RECORD,,