simple_jsonpath 0.3.3__tar.gz → 0.4.3__tar.gz

{simple_jsonpath-0.3.3 → simple_jsonpath-0.4.3}/.gitignore

@@ -73,4 +73,5 @@ docs/_build/
 
 path.py
 device.json
-ben
+ben
+uv.lock

{simple_jsonpath-0.3.3 → simple_jsonpath-0.4.3}/Cargo.lock

@@ -2,6 +2,18 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "1.1.4"
@@ -11,6 +23,18 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "bitflags"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.4"
@@ -108,12 +132,27 @@ version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
 
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
 [[package]]
 name = "libc"
 version = "0.2.183"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
 
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
 [[package]]
 name = "memchr"
 version = "2.8.0"
@@ -142,6 +181,29 @@ version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
 [[package]]
 name = "pin-project-lite"
 version = "0.2.17"
@@ -240,6 +302,15 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags",
+]
+
 [[package]]
 name = "regex"
 version = "1.12.3"
@@ -319,6 +390,12 @@ version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
 [[package]]
 name = "semver"
 version = "1.0.27"
@@ -416,7 +493,7 @@ dependencies = [
 
 [[package]]
 name = "simple_jsonpath"
-version = "0.3.3"
+version = "0.4.3"
 dependencies = [
  "pyo3",
  "rstest",
@@ -424,6 +501,7 @@ dependencies = [
  "serde_json",
  "serde_json_path",
  "serde_json_path_core",
+ "ustr",
 ]
 
 [[package]]
@@ -432,6 +510,12 @@ version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
 
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
 [[package]]
 name = "syn"
 version = "2.0.117"
@@ -505,6 +589,30 @@ version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
+[[package]]
+name = "ustr"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18b19e258aa08450f93369cf56dd78063586adf19e92a75b338a800f799a0208"
+dependencies = [
+ "ahash",
+ "byteorder",
+ "lazy_static",
+ "parking_lot",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
 [[package]]
 name = "winnow"
 version = "0.7.15"
@@ -514,6 +622,26 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "zerocopy"
+version = "0.8.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efbb2a062be311f2ba113ce66f697a4dc589f85e78a4aea276200804cea0ed87"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e8bc7269b54418e7aeeef514aa68f8690b8c0489a06b0136e5f57c4c5ccab89"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "zmij"
 version = "1.0.21"

{simple_jsonpath-0.3.3 → simple_jsonpath-0.4.3}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "simple_jsonpath"
-version = "0.3.3"
+version = "0.4.3"
 edition = "2024"
 readme = "README.md"
 
@@ -15,7 +15,7 @@ serde_json_path = { git = "https://github.com/seojumper/serde_json_path.git", br
 serde_json_path_core = { git = "https://github.com/seojumper/serde_json_path.git", branch = "quotes" }
 serde_json = "1.0.149"
 serde = { version = "1.0.228", features = ["derive"] }
-
+ustr = "1.1.0"
 
 [dev-dependencies]
 rstest = "0.26.1"

{simple_jsonpath-0.3.3 → simple_jsonpath-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple_jsonpath
-Version: 0.3.3
+Version: 0.4.3
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
@@ -31,7 +31,8 @@ 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.
+This module is a JSONPath [RFC9535 - JSONPath: Query Expressions for JSON](https://datatracker.ietf.org/doc/html/rfc9535) utility library that supports performing querying for data in a JSON document.  It does **NOT** supporting modifying data
+in place.
 
 ## Use
 
@@ -182,12 +183,16 @@ results: list[LocatedNode] = finder.find_located("$.items[*].address.'prefix-lis
 for data in results:
 
     # Print the normalized full path where the node was found
-    print(f"{data.full_path}")
+    print(f"{data.path}")
     # $['items'][0]['address']['prefix-list'][0]['prefix']
 
+    # Print the normalized full path of the parent where the node was found
+    print(f"{data.parent_path}")
+    # $['items'][0]['address']['prefix-list'][0]
+
     # 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])}")
+    print(f"{', '.join([str(component) for component in data.path])}")
     # $, items, 0, adddress, prefix-list, 0, prefix
 
     # Access the found node. 

{simple_jsonpath-0.3.3 → simple_jsonpath-0.4.3}/README.md

@@ -8,7 +8,8 @@ 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.
+This module is a JSONPath [RFC9535 - JSONPath: Query Expressions for JSON](https://datatracker.ietf.org/doc/html/rfc9535) utility library that supports performing querying for data in a JSON document.  It does **NOT** supporting modifying data
+in place.
 
 ## Use
 
@@ -159,12 +160,16 @@ results: list[LocatedNode] = finder.find_located("$.items[*].address.'prefix-lis
 for data in results:
 
     # Print the normalized full path where the node was found
-    print(f"{data.full_path}")
+    print(f"{data.path}")
     # $['items'][0]['address']['prefix-list'][0]['prefix']
 
+    # Print the normalized full path of the parent where the node was found
+    print(f"{data.parent_path}")
+    # $['items'][0]['address']['prefix-list'][0]
+
     # 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])}")
+    print(f"{', '.join([str(component) for component in data.path])}")
     # $, items, 0, adddress, prefix-list, 0, prefix
 
     # Access the found node. 

simple_jsonpath-0.4.3/python/simple_jsonpath/__init__.py

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

{simple_jsonpath-0.3.3 → simple_jsonpath-0.4.3}/python/simple_jsonpath/_simple_jsonpath.pyi

@@ -1,11 +1,24 @@
 """A Python module for querying JSON data using JSONPath expressions."""
 
-from typing import Any
+from typing import Any, Union, Optional
+
+class Path:
+    """Object that represents the JSONPath where a node was found."""
+    @classmethod
+    def parent_path(cls) -> Optional[Path]:
+        """Returns the parent path to this path item.
+
+        Returns:
+            Optional[Path]
+        """
+        ...
+    def __getitem__(self, index: int) -> Union[int, str]: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
 
 class SimpleJsonPath:
     """A parser object that can be reused for multiple queries on the same JSON data."""
     def __init__(self) -> None: ...
-
     def child(self, value: str) -> SimpleJsonPath:
         """Spawn a child instance fo the Parser"""
         ...
@@ -15,10 +28,9 @@ class SimpleJsonPath:
     def set_data(self, input_data: bytes) -> None:
         """Set the JSON data for the parser from a JSON string."""
         ...
-    def find(self, path: str) -> list[Any]: 
+    def find(self, path: str) -> list[Any]:
         """Find the value(s) in the JSON data that match the given JSONPath expression, using a cache for parsed paths."""
         ...
-
-    def find_located(self, path: str) -> list[Any]:
+    def find_located(self, path: str) -> list[tuple[Path, Any]]:
         """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-0.3.3 → simple_jsonpath-0.4.3}/python/simple_jsonpath/jsonpath.py

@@ -1,110 +1,54 @@
-from ._simple_jsonpath import SimpleJsonPath as RustSimpleJsonPath
+from ._simple_jsonpath import SimpleJsonPath as RustSimpleJsonPath, Path
 import sys
+
 if sys.version_info >= (3, 11):
-    from typing import Self, Union, Any
+    from typing import Self, Union, Any, Optional
 else:
-    from typing_extensions import Self, Union, Any
+    from typing_extensions import Self, Union, Any, Optional
 import orjson
-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
+    """A class that represents a node found in the JSON data along with its location path."""
+
+    def __init__(
+        self,
+        path: Path,
+        node: Union[str, int, float, bool, None, dict[str, Any], list[Any]],
+    ) -> None:
+        self._path: Path = path
+        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
+    def path(self) -> Path:
+        """An iterator that yields the path components of the last query result.
+
+        The full path can be converted to a str through the str() method against this object.
+        """
+        return self._path
+
     @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]]:
+    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
+    
+    @builtins.property
+    def parent_path(self) -> Optional[Path]:
+        """The parent path of the last query result."""
+        return self._path.parent_path()
 
 
 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 child(self) -> Self:
         """Spawns a child instance of the class.
 
@@ -112,16 +56,16 @@ class JsonPath:
         to set_data() need to be called on it for it to function.
 
         It does however retain shared mutable access to the parent's collection
-        of pre-parsed path objects across all spawned children. 
+        of pre-parsed path objects across all spawned children.
 
         This is useful for the pattern of:
             1. Searching a document for a path query.
             2. Then using those results returned as the basis of a new 'root element'
             for 'deeper' searches into a document.
-        
-        Instead of assigning the original query results to current instance, it can 
+
+        Instead of assigning the original query results to current instance, it can
         be beneficial to spawn a child for each result, and assign the result
-        data to the child or multiple children if more than one result was returned. 
+        data to the child or multiple children if more than one result was returned.
 
         With this pattern the 'base' parent object will automatically contain
         all parsed paths for the document that were searched by
@@ -134,10 +78,10 @@ class JsonPath:
         child_cls = self.__class__
         child = child_cls()
         return child
-    
+
     def has_data(self) -> bool:
         """Returns True if this instance has data set to it, False otherwise."""
-        return self._parser.has_data()  
+        return self._parser.has_data()
 
     def set_data(self, input_data: Union[dict[str, Any], list[Any]]) -> None:
         """Set the JSON data for the query engine from a Python object.
@@ -146,7 +90,7 @@ class JsonPath:
         operations performed against this instance.
 
         Calling the function consecutively will replace any existing 'set' data.
-        
+
         Args:
             input_data: The JSON data to set, as a Python dictionary or list.
 
@@ -163,19 +107,21 @@ class JsonPath:
 
         The path expression is first parsed, then executed against the data previously
         'set'. Parsed path expressions are cached for efficient future use.
-        
+
         Args:
-            path: The JSONPath expression to evaluate.
+            path(str): The JSONPath expression to evaluate.
 
         Returns:
-            A list of values that match the JSONPath expression.
+            list[Any]: A list of values that match the JSONPath expression.
 
         Raises:
             ValueError: If the JSONPath expression is invalid.
             LookupError: If this is called before data has not been set to this object through 'set_data()'.
         """
         if not self._parser.has_data():
-            raise LookupError("Data must be set through calling 'set_data()' before attempting a query")
+            raise LookupError(
+                "Data must be set through calling 'set_data()' before attempting a query"
+            )
         return self._parser.find(path)
 
     def find_located(self, path: str) -> list[LocatedNode]:
@@ -183,19 +129,20 @@ class JsonPath:
 
         The path expression is first parsed, then executed against the data previously
         'set'. Parsed path expressions are cached for efficient future use.
-        
+
         Args:
-            path: The JSONPath expression to evaluate.
+            path(str): The JSONPath expression to evaluate.
 
         Returns:
-            A list of LocatedNode objects that match the JSONPath expression.
+            list[LocatedNode]: A list of 'LocatedNode' objects that match the JSONPath expression.
 
         Raises:
             ValueError: If the JSONPath expression is invalid.
             LookupError: If this is called before data has not been set to this object through 'set_data()'.
         """
         if not self._parser.has_data():
-            raise LookupError("Data must be set through calling 'set_data()' before attempting a query")
+            raise LookupError(
+                "Data must be set through calling 'set_data()' before attempting a query"
+            )
         result = self._parser.find_located(path)
-        return [LocatedNode(item['full_path'], item['path_components'], item['node']) for item in result]
-
+        return [LocatedNode(path, node) for (path, node) in result]

{simple_jsonpath-0.3.3 → simple_jsonpath-0.4.3}/src/lib.rs

@@ -1,23 +1,25 @@
+//! Module that provides a Python interface for querying JSON data using JSONPath expressions, implemented in Rust for performance.
+
 use pyo3::{
     exceptions,
     prelude::*,
-    types::{PyBool, PyDict, PyDictMethods, PyFloat, PyInt, PyList, PyListMethods, PyString},
+    types::{PyBool, PyDict, PyDictMethods, PyFloat, PyList, PyListMethods, PyString},
 };
 use serde_json_path::NormalizedPath;
-// use simple_jsonpath::SimpleJsonPath;
 
 /// A Python module for querying JSON data using JSONPath expressions.
 #[pymodule]
 #[pyo3(name = "_simple_jsonpath")]
 mod simple_jsonpath {
     use super::*;
-    use pyo3::types::PyBytes;
+    use pyo3::types::{PyBytes, PyInt, PySlice};
     use serde_json::Value;
     use serde_json_path::JsonPath;
     use std::{
         collections::HashMap,
         sync::{Arc, Mutex},
     };
+    use ustr::Ustr;
 
     /// A parser object that can be reused for multiple queries on the same JSON data.
     #[pyclass]
@@ -32,7 +34,7 @@ mod simple_jsonpath {
         #[new]
         pub fn new() -> PyResult<Self> {
             Ok(Self {
-                inner: Arc::new(Mutex::new(HashMap::new())),
+                inner: Arc::new(Mutex::new(HashMap::with_capacity(500))),
                 data: None,
             })
         }
@@ -53,6 +55,7 @@ mod simple_jsonpath {
             })
         }
 
+        /// Check if the parser has JSON data set for querying.
         pub fn has_data(&self) -> bool {
             self.data.is_some()
         }
@@ -130,14 +133,147 @@ mod simple_jsonpath {
             };
             let pyresult = PyList::empty(py);
             for item in &result {
-                pyresult.append(
-                    LocatedNode::new(item.location(), item.node()).convert_to_py_any(py)?,
-                )?;
+                pyresult.append((
+                    Path::new(item.location()),
+                    serialize_value(py, item.node())?,
+                ))?;
             }
 
             Ok(pyresult)
         }
     }
+    /// An enum to represent either a string key or an integer index in a JSONPath segment.
+    #[derive(Clone, Copy)]
+    enum Index {
+        U(Ustr),
+        I(usize),
+    }
+
+    impl Index {
+        fn to_normalized_segment(&self) -> String {
+            match self {
+                Self::I(num) => format!("[{num}]"),
+                Self::U(u) => format!("['{}']", u.as_str()),
+            }
+        }
+    }
+    /// A struct to represent a JSONPath location as a sequence of indexes, which can be accessed from Python.
+    #[pyclass(sequence)]
+    struct Path {
+        indexes: Vec<Index>,
+    }
+
+    #[pymethods]
+    impl Path {
+        /// Return the segment of the path at the given index, where the index can be an integer (positive or negative). 
+        /// If the index is out of range, raise an IndexError. If the index is a slice, raise a ValueError since slicing is not supported.
+        fn __getitem__<'py>(&self, index: Bound<'py, PyAny>) -> PyResult<Bound<'py, PyAny>> {
+            let py = index.py();
+            match index.cast::<PyInt>() {
+                Ok(index) => {
+                    let mut i = index.extract::<isize>()?;
+                    if i < 0 {
+                        if i == -1 {
+                            let last = self.indexes.last().unwrap();
+                            match last {
+                                Index::U(u) => Ok(PyString::new(py, u.as_str()).into_any()),
+                                Index::I(i) => Ok(PyInt::new(py, i).into_any()),
+                            }
+                        } else {
+                            let abs_index = i.unsigned_abs();
+                            if abs_index > self.__len__() {
+                                Err(exceptions::PyIndexError::new_err("Index out of Range"))
+                            } else if abs_index == self.__len__() {
+                                Ok(PyString::new(py, "$").into_any())
+                            } else {
+                                let found =
+                                    self.indexes.get(self.indexes.len() - abs_index).unwrap();
+                                match found {
+                                    Index::U(u) => Ok(PyString::new(py, u.as_str()).into_any()),
+                                    Index::I(i) => Ok(PyInt::new(py, i).into_any()),
+                                }
+                            }
+                        }
+                    } else if i as usize == 0 {
+                        Ok(PyString::new(py, "$").into_any())
+                    } else {
+                        i -= 1;
+                        if let Some(i) = self.indexes.get(i as usize) {
+                            match i {
+                                Index::U(u) => Ok(PyString::new(py, u.as_str()).into_any()),
+                                Index::I(i) => Ok(PyInt::new(py, i).into_any()),
+                            }
+                        } else {
+                            Err(exceptions::PyIndexError::new_err("Index out of Range"))
+                        }
+                    }
+                }
+                Err(_) => match index.cast::<PySlice>() {
+                    Ok(_) => Err(exceptions::PyValueError::new_err(
+                        "Slicing operations are not supported",
+                    )),
+                    Err(e) => Err(e.into()),
+                },
+            }
+        }
+
+        /// Return the number of segments in the path, which is one more than the number of indexes (to account for the root '$' segment).
+        fn __len__(&self) -> usize {
+            self.indexes.len() + 1
+        }
+        fn __repr__(&self) -> String {
+            if self.indexes.len() == 1 {
+                "$".to_string()
+            } else {
+                let mut string = "$".to_string();
+                string.extend(self.indexes[1..].iter().map(|i| match i {
+                    Index::U(u) => format!("['{}']", u),
+                    Index::I(num) => format!("[{num}]"),
+                }));
+                string
+            }
+        }
+        /// Return a string representation of the path, which is the same as the __repr__ method in this case.
+        fn __str__(&self) -> String {
+            if self.indexes.len() == 1 {
+                "$".to_string()
+            } else {
+                let mut string = "$".to_string();
+                string.extend(self.indexes.iter().map(|i| i.to_normalized_segment()));
+                string
+            }
+        }
+        /// Return a new Path object that represents the parent path of the current path, which is the same path without the last segment. If the current path is the root '$', return None.
+        fn parent_path(&self) -> Option<Path> {
+            if !self.indexes.is_empty() {
+                let mut path = Vec::with_capacity(self.__len__() - 1);
+                path.extend(
+                    self.indexes[..self.indexes.len() - 1]
+                        .iter()
+                        .map(|index| *index),
+                );
+                Some(Path { indexes: path })
+            } else {
+                None
+            }
+        }
+    }
+
+    impl Path {
+        /// Create a new Path object from a NormalizedPath, which is a sequence of PathElements. Each PathElement can be either a Name (string key) or an Index (integer index), and we convert them into our Index enum to store in the Path struct.
+        fn new(location: &NormalizedPath) -> Self {
+            let ids: Vec<Index> = location
+                .iter()
+                .map(|item| match item {
+                    serde_json_path::PathElement::Name(name) => Index::U(Ustr::from(name)),
+                    serde_json_path::PathElement::Index(num) => Index::I(*num),
+                })
+                .collect();
+            Self { indexes: ids }
+        }
+    }
+
+    /// Helper function to serialize a serde_json::Value into a corresponding Python object.
     fn serialize_value<'a>(py: Python<'a>, value: &'a Value) -> PyResult<Bound<'a, PyAny>> {
         match value {
             Value::Null => Ok(py.None().into_bound(py)),
@@ -167,125 +303,14 @@ mod simple_jsonpath {
             }
         }
     }
-
-    struct LocatedNode<'a> {
-        full_path: String,
-        path_components: Vec<(usize, usize)>,
-        node: &'a Value,
-    }
-
-    impl<'a> LocatedNode<'a> {
-        fn new(full_path: &NormalizedPath, node: &'a Value) -> Self {
-            let (full_path, path_components) = split_normalized_path_component_ranges(full_path);
-            LocatedNode {
-                full_path,
-                path_components,
-                node,
-            }
-        }
-        // Implement the conversion function
-        fn convert_to_py_any<'py>(self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
-            // Convert the inner value to a Python integer;
-            let dict = PyDict::new(py);
-            let mapping = dict.as_mapping();
-            mapping.set_item("full_path", self.full_path)?;
-            mapping.set_item("path_components", self.path_components)?;
-            mapping.set_item("node", serialize_value(py, self.node)?)?;
-
-            Ok(dict.into_any())
-        }
-    }
-
-    pub fn split_normalized_path_component_ranges(
-        path: &NormalizedPath,
-    ) -> (String, Vec<(usize, usize)>) {
-        let path_str = path.to_string();
-        let chars = &path_str.as_str();
-
-        let mut ranges = Vec::with_capacity(path.len() + 1);
-        ranges.push((0, 1)); // Start with the root component '$'
-
-        #[derive(Debug)]
-        enum State {
-            Start,
-            Root,
-            InBracket,
-            InQuotedField,
-            InEscapedChar,
-            InIndex,
-        }
-        let mut num_start = None;
-        let mut start = None;
-        let mut state = State::Start;
-        for (i, c) in chars.char_indices() {
-            match state {
-                State::Start => {
-                    if c == '$' {
-                        state = State::Root;
-                    }
-                }
-                State::Root => {
-                    if c == '[' {
-                        state = State::InBracket;
-                    }
-                }
-                State::InBracket => {
-                    if c == ']' {
-                        state = State::Root;
-                    } else if c == '\'' {
-                        state = State::InQuotedField;
-                    } else {
-                        state = State::InIndex;
-                        num_start = Some(i);
-                    }
-                }
-                State::InQuotedField => match c {
-                    '\\' => state = State::InEscapedChar,
-                    '\'' => {
-                        match start {
-                            Some(_) => ranges.push((start.take().unwrap(), i)),
-                            None => ranges.push((i + 1, i - 1)),
-                        }
-                        state = State::InBracket;
-                    }
-                    _ => match start {
-                        Some(_) => {}
-                        None => start = Some(i),
-                    },
-                },
-                State::InEscapedChar => {
-                    state = State::InQuotedField;
-                }
-                State::InIndex => {
-                    if c == ']' {
-                        if num_start.is_some() {
-                            let num = chars[num_start.take().unwrap()..i]
-                                .parse::<usize>()
-                                .unwrap();
-                            ranges.push((0, num));
-                        }
-                        state = State::Root;
-                    }
-                }
-            }
-        }
-
-        (path_str, ranges)
-    }
 }
 
-/// A struct to hold the located nodes for serialization.
 
-/// Splits a normalized JSONPath into byte ranges `(start, end)` per component.
-///
-/// Example: `$['items'][0]['name']` -> `[(0,1), (1,10), (10,13), (13,21)]`
 
 #[cfg(test)]
 mod tests {
     // use super::simple_jsonpath::SimpleJsonPath;
-    use super::simple_jsonpath::split_normalized_path_component_ranges;
     use rstest::rstest;
-    use serde_json::Value;
     use serde_json_path::JsonPath;
 
     #[rstest]
@@ -309,22 +334,22 @@ mod tests {
         assert!(result.is_ok());
     }
 
-    #[test]
-    fn split_normalized_path_into_component_ranges() {
-        let data: Value = serde_json::from_str(r#"{"items":[{"name":"a"}] }"#).unwrap();
-        let path = JsonPath::parse("$.items[0].name").unwrap();
-        let located = path.query_located(&data).all();
-        let location = located.first().unwrap().location();
-        // $['items'][0]['name']
-        println!("Getting here");
-        let ranges = split_normalized_path_component_ranges(&location);
-        println!("Getting here 2");
-        let expected = vec![(0, 1), (3, 7), (0, 0), (15, 18)];
-        for range in &ranges.1 {
-            println!("Component: {}", &location.to_string()[range.0..range.1]);
-        }
-        println!("Getting here 3");
+    // #[test]
+    // fn split_normalized_path_into_component_ranges() {
+    //     let data: Value = serde_json::from_str(r#"{"items":[{"name":"a"}] }"#).unwrap();
+    //     let path = JsonPath::parse("$.items[0].name").unwrap();
+    //     let located = path.query_located(&data).all();
+    //     let location = located.first().unwrap().location();
+    //     // $['items'][0]['name']
+    //     println!("Getting here");
+    //     let ranges = split_normalized_path_component_ranges(&location);
+    //     println!("Getting here 2");
+    //     let expected = vec![(0, 1), (3, 7), (0, 0), (15, 18)];
+    //     for range in &ranges.1 {
+    //         println!("Component: {}", &location.to_string()[range.0..range.1]);
+    //     }
+    //     println!("Getting here 3");
 
-        assert_eq!(ranges.1, expected);
-    }
+    //     assert_eq!(ranges.1, expected);
+    // }
 }

simple_jsonpath-0.3.3/python/simple_jsonpath/__init__.py

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