simple_jsonpath 0.2.2__cp314-cp314-win32.whl

simple_jsonpath/__init__.py

@@ -0,0 +1,7 @@
+
+"""A simple - yet quick - JSONPath implementation for querying JSON data."""
+
+from .jsonpath import JsonPath, LocatedNode 
+
+
+__all__ = ["JsonPath", "LocatedNode"]

simple_jsonpath/_simple_jsonpath.pyi

@@ -0,0 +1,16 @@
+"""A Python module for querying JSON data using JSONPath expressions."""
+
+
+class SimpleJsonPath:
+    """A parser object that can be reused for multiple queries on the same JSON data."""
+    def __init__(self) -> None: ...
+    def set_data_from_json_str(self, input_data: str) -> None:
+        """Set the JSON data for the parser from a JSON string."""
+        ...
+    def find_from_set_data(self, path: str) -> str: 
+        """Find the value(s) in the JSON data that match the given JSONPath expression, using a cache for parsed paths."""
+        ...
+
+    def find_location_from_set_data(self, path: str) -> str:
+        """Find the value(s) in the JSON data that match the given JSONPath expression, along with their locations, using a cache for parsed paths."""
+        ...

simple_jsonpath/jsonpath.py

@@ -0,0 +1,144 @@
+from ._simple_jsonpath import SimpleJsonPath as RustSimpleJsonPath
+from typing import Any, Union
+from dataclasses import dataclass
+import builtins
+import json
+
+class PathComponentsIter:
+    def __init__(self, path: str, nodes: list[tuple[int, int]]):
+        self._current: int = 0
+        self._path: str = path    
+        self._end: int = len(nodes)
+        self._items: list[tuple[int,int]] = nodes
+
+    def __next__(self) -> Union[str, int]:
+
+        if self._current >= self._end:
+            raise StopIteration
+        if self._current == 0:
+            self._current +=1
+            return "$"
+        else:
+            item = self._items[self._current]
+            if item[0] == 0:
+                self._current += 1
+                return item[1]
+            else:
+                self._current += 1
+                return self._path[item[0]:item[1]]
+
+@dataclass(frozen=True)
+class PathComponents:
+    _path: str
+    _items: list[tuple[int, int]]
+
+    def __len__(self) -> int:
+        return len(self._items)
+
+    def __iter__(self) -> PathComponentsIter:
+        return PathComponentsIter(self._path, self._items)
+    
+    def __getitem__(self, index: int) -> Union[str, int]:
+        if index >= len(self._items):
+            raise IndexError("Index out of range")
+        elif index == 0:
+            return "$"
+        elif index < 0:
+            raise IndexError("Negative indexing is not supported")  
+        else:
+            item = self._items[index]
+            if item[0] == 0:
+                return item[1]
+            else:
+                return self._path[item[0]:item[1]]
+    def __contains__(self, item: Union[int, str]) -> bool:
+        if isinstance(item, int):
+            for i in range(len(self._items)):
+                if i == 0:
+                    continue
+                else:
+                    if self._items[i][0] == 0 and self._items[i][1] == item:
+                        return True
+            return False
+        else:
+            for i in range(len(self._items[1:])):
+                if i == 0:
+                    if item == "$":
+                        return True
+                else:   
+                    if self._path[self._items[i][0]:self._items[i][1]] == item:
+                        return True
+            return False
+          
+class LocatedNode:
+    """A struct to hold the located nodes found from a located JSONPath query."""
+    def __init__(self, full_path: str, path_components: list[tuple[int, int]], node: Union[str,int,float,bool,None,dict[str, Any], list[Any]]) -> None:
+        self._full_path: str = full_path
+        self._path_components: PathComponents = PathComponents(full_path, path_components)
+        self._node: Union[str,int,float,bool,None,dict[str, Any], list[Any]] = node
+
+    @builtins.property
+    def path_components(self) -> PathComponents:
+        """An iterator that yields the path components of the last query result."""
+        return self._path_components
+    @builtins.property
+    def full_path(self) -> str:
+        """The full path of the last query result."""
+        return self._full_path
+    @builtins.property   
+    def node(self) -> Union[str,int,float,bool,None,dict[str, Any], list[Any]]:
+        """The node value of the last query result."""
+        return self._node
+
+
+class JsonPath:
+    """A simple JSONPath implementation for querying JSON data.
+    
+    It uses a Rust backend for performance and supports caching of parsed
+    JSONPath expressions for repeated queries against the same JSON data.
+    """
+    def __init__(self) -> None:
+        self._parser = RustSimpleJsonPath()
+
+    def set_data(self, input_data: Union[dict[str, Any], list[Any]]) -> None:
+        """Set the JSON data for the parser from a Python dictionary or list.
+        
+        Args:
+            input_data: The JSON data to set, as a Python dictionary or list.
+
+        Returns:
+            None
+
+        Raises:
+            ValueError: If the input data is not a valid JSON object or array.
+        """
+        self._parser.set_data_from_json_str(json.dumps(input_data))
+
+    def find(self, path: str) -> list[Any]:
+        """Find the value(s) in the JSON data that match the given JSONPath expression.
+        
+        Args:
+            path: The JSONPath expression to evaluate.
+
+        Returns:
+            A list of values that match the JSONPath expression.
+
+        Raises:
+            ValueError: If the JSONPath expression is invalid.
+        """
+        return json.loads(self._parser.find_from_set_data(path))
+
+    def find_located(self, path: str) -> list[LocatedNode]:
+        """Find the value(s) in the JSON data that match the given JSONPath expression, along with their locations.
+        
+        Args:
+            path: The JSONPath expression to evaluate.
+
+        Returns:
+            A list of LocatedNode objects that match the JSONPath expression.
+
+        Raises:
+            ValueError: If the JSONPath expression is invalid.
+        """
+        result = json.loads(self._parser.find_location_from_set_data(path))
+        return [LocatedNode(item['full_path'], item['path_components'], item['node']) for item in result]

simple_jsonpath-0.2.2.dist-info/METADATA

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: simple_jsonpath
+Version: 0.2.2
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+License-File: LICENSE
+Summary: A simple - yet quick - JSONPath implementation for querying JSON data.
+Keywords: jsonpath
+Author-email: Jeremy Spencer <seojumper@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.10, <3.15
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/seojumper/simple_jsonpath
+
+# simple_jsonpath
+
+## Installation
+
+```bash
+pip install simple_jsonpath
+```
+
+## About
+
+This module is a JSONPath [RFC9535 - JSONPath: Query Expressions for JSON](https://datatracker.ietf.org/doc/html/rfc9535) utility library.
+
+## Use
+
+This module exposes a single simple type - a ***JsonPath*** which has two methods after instantiation.
+
+- ***set_data()***: sets the data that will be queried against. If multiple queries will be performed against a single piece of JSON data, this helps with the type conversion cost involved. This function can be called with providing new data whenever the inner data held is wished to be changed while retaining already complied paths (useful for querying multiple similarly structured documents).
+- ***find()***: given a path that is wished to be found in the previously set data, this function will perform the query logic. Mulitple calls to **find()** will query against the previously 'set' data.
+- ***find_located()***: given a path that is wished to be found in the previously set data, this function can return a list of ***LocatedNode*** objects.  Each ***LocatedNode*** object will have attributes related to the path where the node was located as well as their corresponding data. This method is slower than ***find()***, so should ideally only be used when path information for the found nodes is needed.
+
+## Examples
+
+### 'Find' Example
+
+```python
+from simple_jsonpath import JsonPath
+
+
+json_data = {
+    "address": {
+        "prefix-list": [
+            {
+                "prefix": "2001:db8::1/64",
+                "eui-64": [
+                    None
+                ]
+            }
+        ],
+        "link-local-address": [
+            {
+                "address": "fe80::1",
+                "link-local": [
+                    None
+                ]
+            }
+        ]
+    }
+}
+
+# Instantiates the primary class
+finder = JsonPath()
+
+# Sets the data that is desired to be queried against
+finder.set_data(json_data)
+
+# A path is provided to query against the 'set' data.  The path is internally parsed > used to qeury against the 'set' dataset.
+# Notice that this implementaion allows for escaping of specials characters shorthand path syntax with single or double quotes
+results = finder.find("$.address.'prefix-list'[*].prefix")
+
+for data in results:
+    # Access the found node. 
+    print(f"{data}")
+    # 2001:db8::1/64
+
+```
+
+The inner implementation stores previously parsed 'paths'. This allows repeatedly used paths to bypass the parsing step invovled.
+
+This is ideal for situations where multiple similar JSON documents will be searched in succession.
+
+The same ***JsonPath*** object can then be reused with new data sets by calling ***set_data()*** on it again, and any previously parsed paths by the object will be retained.
+
+Only when moving onto data of differing structure would it be potentially advisable to instantiate a new ***JsonPath*** object.
+
+### 'Find Located' Example
+
+```python
+from simple_jsonpath import JsonPath, LocatedNode
+
+
+json_data = {
+    "items": [
+        {
+            "address": {
+                "prefix-list": [
+                    {
+                        "prefix": "2001:db8::1/64",
+                        "eui-64": [
+                            None
+                        ]
+                    }
+                ],
+                "link-local-address": [
+                    {
+                        "address": "fe80::1",
+                        "link-local": [
+                            None
+                        ]
+                    }
+                ]
+            }
+        },
+        {
+            "address": {
+                "prefix-list": [
+                    {
+                        "prefix": "2001:db8::1/64",
+                        "eui-64": [
+                            None
+                        ]
+                    }
+                ],
+                "link-local-address": [
+                    {
+                        "address": "fe80::1",
+                        "link-local": [
+                            None
+                        ]
+                    }
+                ]
+            }
+        }
+    ]
+}
+
+# Instantiates the primary class
+finder = JsonPath()
+
+# Sets the data that is desired to be queried against
+finder.set_data(json_data)
+
+# Now we are interested in the path information where matches were found as well as the data
+results: list[LocatedNode] = finder.find_located("$.items[*].address.'prefix-list'[*].prefix")
+
+# Iterate through each found LocatedNode object
+for data in results:
+
+    # Print the normalized full path where the node was found
+    print(f"{data.full_path}")
+    # $['items'][0]['address']['prefix-list'][0]['prefix']
+
+    # Iterate over the components of the found path
+    # Returned elements will either be a 'str' for keys or 'int' for index values
+    print(f"{', '.join([str(component) for component in data.path_components])}")
+    # $, items, 0, adddress, prefix-list, 0, prefix
+
+    # Access the found node. 
+    print(f"{data.node}")
+    # 2001:db8::1/64
+```
+

simple_jsonpath-0.2.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+simple_jsonpath/__init__.py,sha256=OofAgjl5Qzj6FaVVziW1JD8uhomAY6IhigeldJGbCrY,169
+simple_jsonpath/_simple_jsonpath.cp314-win32.pyd,sha256=Ln0d1d56hm5OfQVTF3cJap2awgEc_l5My44pPB_JJmo,1455616
+simple_jsonpath/_simple_jsonpath.pyi,sha256=xacGn97K908o7E1oYr4ZIdRgQuKr3W25rQCXPHB7R3M,791
+simple_jsonpath/jsonpath.py,sha256=mfUInqb8qJ_wUbu95_MvM75zOlrRYnSOHjOOTRyBhnM,5294
+simple_jsonpath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+simple_jsonpath-0.2.2.dist-info/METADATA,sha256=jmMmt3Vr_rGG7V_utkoA39HtA36KoT2dwpRw-z9vVq8,6152
+simple_jsonpath-0.2.2.dist-info/WHEEL,sha256=0RZTOoYFKCMMSuuhCfCow7TTDL6bY1Mq-hzasewFGUs,93
+simple_jsonpath-0.2.2.dist-info/licenses/LICENSE,sha256=wFYBgkhw1xlkSCQiuXbjktNcYtLoxAOAnSVyKJRryOw,1081
+simple_jsonpath-0.2.2.dist-info/sboms/simple_jsonpath.cyclonedx.json,sha256=UYAQhCBCpJo9CJO_xS3dJP-rSBIzN5qs65ULnoeD-3g,40961
+simple_jsonpath-0.2.2.dist-info/RECORD,,

simple_jsonpath-0.2.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.12.6)
+Root-Is-Purelib: false
+Tag: cp314-cp314-win32

simple_jsonpath-0.2.2.dist-info/licenses/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2026 Jeremy Spencer
+
+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.