simple_jsonpath 0.1.2__tar.gz → 0.2.2__tar.gz

{simple_jsonpath-0.1.2 → simple_jsonpath-0.2.2}/.github/workflows/CI.yml

@@ -7,9 +7,6 @@ name: CI
 
 on:
   push:
-    branches:
-      - main
-      - master
     tags:
       - '*'
   pull_request:
@@ -40,7 +37,7 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions/setup-python@v6
         with:
-          python-version: 3.x
+          python-version: '>=3.10 <3.15'
       - name: Build wheels
         uses: PyO3/maturin-action@v1
         with:
@@ -71,7 +68,7 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions/setup-python@v6
         with:
-          python-version: 3.x
+          python-version: '>=3.10 <3.15'
       - name: Build wheels
         uses: PyO3/maturin-action@v1
         with:
@@ -103,7 +100,7 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions/setup-python@v6
         with:
-          python-version: 3.13
+          python-version: '>=3.10 <3.15'
           architecture: ${{ matrix.platform.python_arch }}
       - name: Build wheels
         uses: PyO3/maturin-action@v1
@@ -130,7 +127,7 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions/setup-python@v6
         with:
-          python-version: 3.x
+          python-version: '>=3.10 <3.15'
       - name: Build wheels
         uses: PyO3/maturin-action@v1
         with:

{simple_jsonpath-0.1.2 → simple_jsonpath-0.2.2}/.gitignore

@@ -70,3 +70,6 @@ docs/_build/
 
 # Pyenv
 .python-version
+
+path.py
+device.json

{simple_jsonpath-0.1.2 → simple_jsonpath-0.2.2}/Cargo.lock

@@ -231,17 +231,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "pythonize"
-version = "0.28.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b79f670c9626c8b651c0581011b57b6ba6970bb69faf01a7c4c0cfc81c43f95"
-dependencies = [
- "pyo3",
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "quote"
 version = "1.0.45"
@@ -427,13 +416,14 @@ dependencies = [
 
 [[package]]
 name = "simple_jsonpath"
-version = "0.1.2"
+version = "0.2.2"
 dependencies = [
  "pyo3",
- "pythonize",
  "rstest",
+ "serde",
  "serde_json",
  "serde_json_path",
+ "serde_json_path_core",
 ]
 
 [[package]]

{simple_jsonpath-0.1.2 → simple_jsonpath-0.2.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "simple_jsonpath"
-version = "0.1.2"
+version = "0.2.2"
 edition = "2024"
 readme = "README.md"
 
@@ -12,9 +12,14 @@ crate-type = ["cdylib"]
 [dependencies]
 pyo3 = { version = "0.28.2", features = ["serde"] }
 serde_json_path = { git = "https://github.com/seojumper/serde_json_path.git", branch = "quotes" }
+serde_json_path_core = { git = "https://github.com/seojumper/serde_json_path.git", branch = "quotes" }
 serde_json = "1.0.149"
-pythonize = { version = "0.28.0", features = ["serde_json"] }
+serde = { version = "1.0.228", features = ["derive"] }
 
 
 [dev-dependencies]
 rstest = "0.26.1"
+
+[profile.release]
+lto = true
+codegen-units = 1

simple_jsonpath-0.2.2/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.

simple_jsonpath-0.2.2/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,150 @@
+# 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/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["maturin>=1.12,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "simple_jsonpath"
+requires-python = ">=3.10,<3.15"
+classifiers = [
+    "Intended Audience :: Developers",
+    "Programming Language :: Rust",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+authors = [
+    { name = "Jeremy Spencer", email = "seojumper@gmail.com" },
+]
+description = "A simple - yet quick - JSONPath implementation for querying JSON data."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"] 
+keywords = ["jsonpath"]
+
+dynamic = ["version"]
+
+[tool.maturin]
+python-source = "python"
+module-name = "simple_jsonpath._simple_jsonpath"
+
+[project.urls]
+Homepage = "https://github.com/seojumper/simple_jsonpath"

simple_jsonpath-0.2.2/python/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-0.2.2/python/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-0.2.2/python/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/src/lib.rs

@@ -0,0 +1,289 @@
+
+
+use pyo3::prelude::*;
+use serde_json_path::NormalizedPath;
+use serde_json::Value;
+use serde::{Serialize};
+
+
+/// A Python module for querying JSON data using JSONPath expressions.
+#[pymodule]
+#[pyo3(name = "_simple_jsonpath")]
+mod simple_jsonpath {
+    use super::*;   
+    use serde_json_path::JsonPath;
+    use serde_json::Value;
+    use std::{collections::HashMap, sync::Arc};
+
+    /// A parser object that can be reused for multiple queries on the same JSON data.
+    #[pyclass]
+    pub struct SimpleJsonPath {
+        inner: HashMap<String, JsonPath>,
+        data: Arc<Value>,  
+    }
+
+    #[pymethods]
+    impl SimpleJsonPath {
+        /// Create a new SimpleJsonPath object with an empty cache and null data.
+        #[new]
+        pub fn new() -> PyResult<Self> {
+            Ok(Self { inner: HashMap::new(), data: Arc::new(Value::Null) })
+        }
+
+        /// Set the JSON data for the parser from a JSON string.
+        pub fn set_data_from_json_str(&mut self, input_data: &str) -> PyResult<()> {
+            let value: Value = serde_json::from_str(input_data).map_err(|e| {
+                pyo3::exceptions::PyValueError::new_err(format!("Invalid JSON string: {}", e))
+            })?;
+            self.data = Arc::new(value);
+            Ok(())
+        }
+
+        /// Find the value(s) in the JSON data that match the given JSONPath expression, using a cache for parsed paths.
+        pub fn find_from_set_data(&mut self, path: &str) -> PyResult<String> {
+            if !self.inner.contains_key(path) {
+                let json_path = JsonPath::parse(path).map_err(|e| {
+                    pyo3::exceptions::PyValueError::new_err(format!(
+                        "Parse error at position {} for path {}: {}",
+                        e.position(),
+                        path,
+                        e.message()
+                    ))
+                })?;
+                self.inner.insert(path.to_string(), json_path);
+            }
+            let json_path = self.inner.get(path).unwrap();
+            let result = json_path.query(&self.data).all();
+            let pyresult: String = serde_json::to_string(&result).map_err(|e| {
+                    pyo3::exceptions::PyValueError::new_err(format!(
+                        "Error converting result to JSON string: {}",
+                        e
+                    ))
+                })?;
+            Ok(pyresult)
+        }
+
+        /// Find the value(s) in the JSON data that match the given JSONPath expression, along with their locations, using a cache for parsed paths.
+        pub fn find_location_from_set_data(
+            &mut self,
+            path: &str,
+        ) -> PyResult<String> {
+            if !self.inner.contains_key(path) {
+                let json_path = JsonPath::parse(path).map_err(|e| {
+                    pyo3::exceptions::PyValueError::new_err(format!(
+                        "Parse error at position {} for path {}: {}",
+                        e.position(),
+                        path,
+                        e.message()
+                    ))
+                })?;
+                self.inner.insert(path.to_string(), json_path);
+            }
+            let json_path = self.inner.get(path).unwrap();
+            let result = json_path.query_located(&self.data).all();
+            let mut located_nodes = Vec::new();
+            for item in &result {
+                located_nodes.push(LocatedNode::new(item.location(), item.node()));
+ 
+            }
+            let pyresult: String = serde_json::to_string(&located_nodes).map_err(|e| {
+                    pyo3::exceptions::PyValueError::new_err(format!(
+                        "Error converting result to JSON string: {}",
+                        e
+                    ))
+                })?;
+            Ok(pyresult)
+        }
+    }
+}
+
+
+/// A struct to hold the located nodes for serialization.
+#[derive(Serialize)]
+struct LocatedNode<'a> {
+    full_path: String,
+    path_components: Vec<(usize, usize)>,
+    node: &'a Value,
+}
+
+impl<'a> LocatedNode<'a> {
+    fn new(full_path: &'a NormalizedPath, node: &'a Value) -> LocatedNode<'a> {
+        let (full_path, path_components) = split_normalized_path_component_ranges(full_path);
+        LocatedNode { full_path, path_components, node }
+    }
+}
+
+/// Splits a normalized JSONPath into byte ranges `(start, end)` per component.
+///
+/// Example: `$['items'][0]['name']` -> `[(0,1), (1,10), (10,13), (13,21)]`
+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)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::split_normalized_path_component_ranges;
+    use super::simple_jsonpath::SimpleJsonPath;
+    use rstest::rstest;
+    use serde_json::Number;
+    use serde_json::Value;
+    use serde_json_path::{JsonPath};
+
+    #[rstest]
+    #[case("$.router.bgp[0].bgp.router_id.interface")]
+    #[case("$.router.'Cisco-IOS-XE-bgp:bgp'[0].bgp.default.'ipv4-unicast'")]
+    #[case("$.router.'Cisco-IOS-XE-bgp:bgp'[0].bgp.'log-neighbor-changes'")]
+    #[case("$.router.'Cisco-IOS-XE-bgp:bgp'[0].bgp.'graceful-restart'")]
+    #[case("$.router.'Cisco-IOS-XE-bgp:bgp'[0].bgp.'update-delay'")]
+    #[case("$.router.'Cisco-IOS-XE-bgp:bgp'[0].template.'peer-policy'[*]")]
+    #[case(
+        "$.router.'Cisco-IOS-XE-bgp:bgp'[0].'address-family'.'no-vrf'.ipv4[0].'ipv4-unicast'.'aggregate-address'[*]"
+    )]
+    fn path(#[case] input: &str) {
+        let result = JsonPath::parse(input);
+        match &result {
+            Ok(path) => {}
+            Err(e) => {
+                println!("Parse error at position {}: {}", e.position(), e.message());
+            }
+        }
+        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");   
+
+        assert_eq!(ranges.1, expected);
+    }
+
+
+
+    // #[test]
+    // fn find_location() {
+    //     let data = r#"[
+    //     {"name": "1/0/1", "description": "Test Interface 1/0/1", "media-type": "sfp", "switchport-conf": {"switchport": false}, "arp": {"timeout": 1000}, "bfd": {"Cisco-IOS-XE-bfd:enable": true, "Cisco-IOS-XE-bfd:local-address": "10.100.1.10", "Cisco-IOS-XE-bfd:interval-interface": {"msecs": 300, "min_rx": 300, "multiplier": 3}, "Cisco-IOS-XE-bfd:echo": false}, "bandwidth": {"kilobits": 1000000}, "mpls": {"Cisco-IOS-XE-mpls:ip": [null], "Cisco-IOS-XE-mpls:mtu": 1400}, "vrf": {"forwarding": "PRODUCTION"}, "ip": {"access-group": {"in": {"acl": {"acl-name": "ACL_IN", "in": [null]}}, "out": {"acl": {"acl-name": "ACL_OUT", "out": [null]}}}, "arp": {"inspection": {"limit": {"rate": 1000}, "trust": [null]}}, "address": {"primary": {"address": "10.100.1.10", "mask": "255.255.255.0"}}, "Cisco-IOS-XE-nat:nat": {"inside": [null]}, "helper-address": [{"address": "10.100.1.50", "vrf": "PRODUCTION"}], "pim": {"Cisco-IOS-XE-multicast:border": [null], "Cisco-IOS-XE-multicast:bfd": [null], "Cisco-IOS-XE-multicast:pim-mode-choice-cfg": {"sparse-mode": {}}, "Cisco-IOS-XE-multicast:dr-priority": 1000}, "proxy-arp": false, "redirects": false, "dhcp": {"Cisco-IOS-XE-dhcp:relay": {"information": {"option": {"vpn-id": [null]}}, "source-interface": "Loopback150"}}, "Cisco-IOS-XE-flow:flow": {"monitor-new": [{"name": "MONITOR_C9K_TEST", "direction": "input"}]}, "Cisco-IOS-XE-icmp:unreachables": false, "Cisco-IOS-XE-igmp:igmp": {"version": 3}, "Cisco-IOS-XE-nbar:nbar": {"protocol-discovery": {}}, "Cisco-IOS-XE-ospf:router-ospf": {"ospf": {"process-id": [{"id": 10, "area": [{"area-id": 0}]}], "cost": 10, "dead-interval": 60, "hello-interval": 15, "mtu-ignore": true, "message-digest-key": [{"id": 1, "md5": {"auth-type": 0, "auth-key": "cisco"}}], "network": {"point-to-point": [null]}, "multi-area": {"multi-area-id": [{"area-id": 1}, {"area-id": 2}]}, "priority": 10, "ttl-security": {"hops": 5}}}}, "ipv6": {"address": {"prefix-list": [{"prefix": "2001:db8::1/64", "eui-64": [null]}], "link-local-address": [{"address": "fe80::1", "link-local": [null]}]}, "enable": [null], "mtu": 1600, "nd": {"Cisco-IOS-XE-nd:ra": {"suppress": {"all": [null]}}}, "Cisco-IOS-XE-flow:flow": {"monitor-new": [{"name": "MONITOR_C9K_TEST_V6", "direction": "input"}]}, "Cisco-IOS-XE-multicast:pim-conf": {"pim": true}, "Cisco-IOS-XE-multicast:pim-container": {"bfd": [null], "dr-priority": 1000}}, "load-interval": 30, "logging": {"event": {"link-status-enable": true}}, "mtu": 1600, "Cisco-IOS-XE-cdp:cdp": {"enable": true, "tlv": {"default-wrp": {"app": false}, "server-location-config": false, "location-config": false}}, "Cisco-IOS-XE-dot1x:dot1x": {"pae": "authenticator", "max-reauth-req": 3, "max-req": 3, "timeout": {"auth-period": 10000, "held-period": 40000, "quiet-period": 10000, "ratelimit-period": 5000, "server-timeout": 5000, "start-period": 2000, "supp-timeout": 2000, "tx-period": 2000}}, "Cisco-IOS-XE-ethernet:port-settings": {"speed": {"speed-value": "100"}, "auto-negotiation": "disable"}, "Cisco-IOS-XE-ethernet:speed": {"nonegotiate": [null]}, "Cisco-IOS-XE-ospfv3:ospfv3": {"cost-config": {"value": 10}, "network-type": {"point-to-point": [null]}}, "Cisco-IOS-XE-policy:service-policy": {"input": "POLICY_IN", "output": "POLICY_OUT"}, "Cisco-IOS-XE-sanet:authentication": {"periodic": [null], "timer": {"reauthenticate": {"server-config": [null]}}}, "Cisco-IOS-XE-sanet:mab": {"eap": [null]}, "Cisco-IOS-XE-snmp:snmp": {"trap": {"link-status": true}}},
+    //     {"name": "1/0/1", "description": "Test Interface 1/0/1", "media-type": "sfp", "switchport-conf": {"switchport": false}, "arp": {"timeout": 1000}, "bfd": {"Cisco-IOS-XE-bfd:enable": true, "Cisco-IOS-XE-bfd:local-address": "10.100.1.10", "Cisco-IOS-XE-bfd:interval-interface": {"msecs": 300, "min_rx": 300, "multiplier": 3}, "Cisco-IOS-XE-bfd:echo": false}, "bandwidth": {"kilobits": 1000000}, "mpls": {"Cisco-IOS-XE-mpls:ip": [null], "Cisco-IOS-XE-mpls:mtu": 1400}, "vrf": {"forwarding": "PRODUCTION"}, "ip": {"access-group": {"in": {"acl": {"acl-name": "ACL_IN", "in": [null]}}, "out": {"acl": {"acl-name": "ACL_OUT", "out": [null]}}}, "arp": {"inspection": {"limit": {"rate": 1000}, "trust": [null]}}, "address": {"primary": {"address": "10.100.1.10", "mask": "255.255.255.0"}}, "Cisco-IOS-XE-nat:nat": {"inside": [null]}, "helper-address": [{"address": "10.100.1.50", "vrf": "PRODUCTION"}], "pim": {"Cisco-IOS-XE-multicast:border": [null], "Cisco-IOS-XE-multicast:bfd": [null], "Cisco-IOS-XE-multicast:pim-mode-choice-cfg": {"sparse-mode": {}}, "Cisco-IOS-XE-multicast:dr-priority": 1000}, "proxy-arp": false, "redirects": false, "dhcp": {"Cisco-IOS-XE-dhcp:relay": {"information": {"option": {"vpn-id": [null]}}, "source-interface": "Loopback150"}}, "Cisco-IOS-XE-flow:flow": {"monitor-new": [{"name": "MONITOR_C9K_TEST", "direction": "input"}]}, "Cisco-IOS-XE-icmp:unreachables": false, "Cisco-IOS-XE-igmp:igmp": {"version": 3}, "Cisco-IOS-XE-nbar:nbar": {"protocol-discovery": {}}, "Cisco-IOS-XE-ospf:router-ospf": {"ospf": {"process-id": [{"id": 10, "area": [{"area-id": 0}]}], "cost": 10, "dead-interval": 60, "hello-interval": 15, "mtu-ignore": true, "message-digest-key": [{"id": 1, "md5": {"auth-type": 0, "auth-key": "cisco"}}], "network": {"point-to-point": [null]}, "multi-area": {"multi-area-id": [{"area-id": 1}, {"area-id": 2}]}, "priority": 10, "ttl-security": {"hops": 5}}}}, "ipv6": {"address": {"prefix-list": [{"prefix": "2001:db8::1/64", "eui-64": [null]}], "link-local-address": [{"address": "fe80::1", "link-local": [null]}]}, "enable": [null], "mtu": 1600, "nd": {"Cisco-IOS-XE-nd:ra": {"suppress": {"all": [null]}}}, "Cisco-IOS-XE-flow:flow": {"monitor-new": [{"name": "MONITOR_C9K_TEST_V6", "direction": "input"}]}, "Cisco-IOS-XE-multicast:pim-conf": {"pim": true}, "Cisco-IOS-XE-multicast:pim-container": {"bfd": [null], "dr-priority": 1000}}, "load-interval": 30, "logging": {"event": {"link-status-enable": true}}, "mtu": 1600, "Cisco-IOS-XE-cdp:cdp": {"enable": true, "tlv": {"default-wrp": {"app": false}, "server-location-config": false, "location-config": false}}, "Cisco-IOS-XE-dot1x:dot1x": {"pae": "authenticator", "max-reauth-req": 3, "max-req": 3, "timeout": {"auth-period": 10000, "held-period": 40000, "quiet-period": 10000, "ratelimit-period": 5000, "server-timeout": 5000, "start-period": 2000, "supp-timeout": 2000, "tx-period": 2000}}, "Cisco-IOS-XE-ethernet:port-settings": {"speed": {"speed-value": "100"}, "auto-negotiation": "disable"}, "Cisco-IOS-XE-ethernet:speed": {"nonegotiate": [null]}, "Cisco-IOS-XE-ospfv3:ospfv3": {"cost-config": {"value": 10}, "network-type": {"point-to-point": [null]}}, "Cisco-IOS-XE-policy:service-policy": {"input": "POLICY_IN", "output": "POLICY_OUT"}, "Cisco-IOS-XE-sanet:authentication": {"periodic": [null], "timer": {"reauthenticate": {"server-config": [null]}}}, "Cisco-IOS-XE-sanet:mab": {"eap": [null]}, "Cisco-IOS-XE-snmp:snmp": {"trap": {"link-status": true}}}
+    //     ]"#;
+    //     let path = "$[*].name";
+    //     let data: Value = serde_json::from_str(data).unwrap();
+    //     let data_str = serde_json::to_string(&data).unwrap();
+    //     let mut finder = SimpleJsonPath::new().unwrap();
+    //     finder.set_data_from_json_str(&data_str).unwrap();
+    //     let result: Value = serde_json::from_str(&finder.find_location_from_set_data(path).unwrap()).unwrap();
+    //     assert_eq!(result.as_array().unwrap().len(), 2);
+    //     let array = result.as_array().unwrap();
+    //     let path_components_1 = Value::Array(vec![Value::String("$".to_string()), Value::Number(Number::from_str("0").unwrap()), Value::String("name".to_string())]);
+    //     let path_components_2 = Value::Array(vec![Value::String("$".to_string()), Value::Number(Number::from_str("1").unwrap()), Value::String("name".to_string())]);
+    //     assert_eq!(array.len(), 2);
+
+    //     println!("{:?}", array);
+    //     let located_node1 = array[0].as_object().unwrap();
+    //     let full_path = located_node1.get("full_path").unwrap().as_str().unwrap();
+    //     assert_eq!(full_path, " ");
+    //     let path_components = located_node1.get("path_components").unwrap().as_array().unwrap();
+    //     assert_eq!(path_components, path_components_1.as_array().unwrap());
+    //     let nodes = located_node1.get("nodes").unwrap().as_array().unwrap();
+    //     assert_eq!(nodes.len(), 1);
+
+
+    //     let located_node2 = array[1].as_object().unwrap();
+    //     let full_path = located_node2.get("full_path").unwrap().as_str().unwrap();
+    //     assert_eq!(full_path, "$[1]['name']");
+    //     let path_components = located_node2.get("path_components").unwrap().as_array().unwrap();
+    //     assert_eq!(path_components, path_components_2.as_array().unwrap());
+    //     let nodes = located_node2.get("nodes").unwrap().as_array().unwrap();
+    //     assert_eq!(nodes.len(), 1);
+        
+
+
+
+    //     // assert_eq!(result.as_array().unwrap()[0].as_str().unwrap(), "1/0/1");
+    // }
+}

simple_jsonpath-0.1.2/PKG-INFO

@@ -1,7 +0,0 @@
-Metadata-Version: 2.4
-Name: simple_jsonpath
-Version: 0.1.2
-Classifier: Programming Language :: Rust
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.8

simple_jsonpath-0.1.2/README.md

@@ -1,7 +0,0 @@
-# simple_jsonpath
-
-## Installation
-
-```bash
-pip install simple_json
-```

simple_jsonpath-0.1.2/pyproject.toml

@@ -1,13 +0,0 @@
-[build-system]
-requires = ["maturin>=1.12,<2.0"]
-build-backend = "maturin"
-
-[project]
-name = "simple_jsonpath"
-requires-python = ">=3.8"
-classifiers = [
-    "Programming Language :: Rust",
-    "Programming Language :: Python :: Implementation :: CPython",
-    "Programming Language :: Python :: Implementation :: PyPy",
-]
-dynamic = ["version"]

simple_jsonpath-0.1.2/simple_jsonpath.pyi

@@ -1,6 +0,0 @@
-"""A Python module for querying JSON data using JSONPath expressions."""
-
-from typing import Optional
-
-def find(path: str, data: object) -> Optional[str]:
-    """Find the value(s) in the JSON data that match the given JSONPath expression."""

simple_jsonpath-0.1.2/src/lib.rs

@@ -1,74 +0,0 @@
-use pyo3::{prelude::*};
-use serde_json_path::{JsonPath};
-
-/// A Python module for querying JSON data using JSONPath expressions.
-#[pymodule]
-mod simple_jsonpath {
-    use super::*;
-    
-    /// Find the value(s) in the JSON data that match the given JSONPath expression.
-    #[pyfunction]
-    fn find(path: String, data: String) -> PyResult<Option<String>> {
-        match serde_json::from_str(&data) {
-            Ok(json) => {
-                match JsonPath::parse(&path) {
-                    Ok(json_path) => {
-                        let result = json_path.query(&json).all();
-                        if result.is_empty() {
-                            Ok(None)
-                        } else {
-                            // Convert the result to a JSON string
-                            match serde_json::to_string(&result) {
-                                Ok(json_result) => Ok(Some(json_result)),
-                                Err(e) => return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("Error converting result to JSON string: {}", e))),
-                            }
-                        }
-                    }
-                    Err(e) => Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("Parse error at position {} for path {}:\n{}", e.position(), path, e.message()))),
-                }
-            }
-            Err(e) => Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("Invalid JSON data: {}", e))),
-        }
-    }
-
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use rstest::rstest;
-    use serde_json_path::{JsonPath, ParseError};
-    use serde_json::Value;
-
-    #[rstest]
-    #[case("$.router.bgp[0].bgp.router_id.interface")]
-    #[case("$.router.'Cisco-IOS-XE-bgp:bgp'[0].bgp.default.'ipv4-unicast'")]
-    #[case("$.router.'Cisco-IOS-XE-bgp:bgp'[0].bgp.'log-neighbor-changes'")]
-    #[case("$.router.'Cisco-IOS-XE-bgp:bgp'[0].bgp.'graceful-restart'")]
-    #[case("$.router.'Cisco-IOS-XE-bgp:bgp'[0].bgp.'update-delay'")]
-    #[case("$.router.'Cisco-IOS-XE-bgp:bgp'[0].template.'peer-policy'[*]")]
-    #[case(
-        "$.router.'Cisco-IOS-XE-bgp:bgp'[0].'address-family'.'no-vrf'.ipv4[0].'ipv4-unicast'.'aggregate-address'[*]"
-    )]
-    fn path(#[case] input: &str) {
-        let result = JsonPath::parse(input);
-        match &result {
-            Ok(path) => {}
-            Err(e) => {
-                println!("Parse error at position {}: {}", e.position(), e.message());
-            }
-        }
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn find() {
-        let data = r#"
-        {"name": "1/0/1", "description": "Test Interface 1/0/1", "media-type": "sfp", "switchport-conf": {"switchport": false}, "arp": {"timeout": 1000}, "bfd": {"Cisco-IOS-XE-bfd:enable": true, "Cisco-IOS-XE-bfd:local-address": "10.100.1.10", "Cisco-IOS-XE-bfd:interval-interface": {"msecs": 300, "min_rx": 300, "multiplier": 3}, "Cisco-IOS-XE-bfd:echo": false}, "bandwidth": {"kilobits": 1000000}, "mpls": {"Cisco-IOS-XE-mpls:ip": [null], "Cisco-IOS-XE-mpls:mtu": 1400}, "vrf": {"forwarding": "PRODUCTION"}, "ip": {"access-group": {"in": {"acl": {"acl-name": "ACL_IN", "in": [null]}}, "out": {"acl": {"acl-name": "ACL_OUT", "out": [null]}}}, "arp": {"inspection": {"limit": {"rate": 1000}, "trust": [null]}}, "address": {"primary": {"address": "10.100.1.10", "mask": "255.255.255.0"}}, "Cisco-IOS-XE-nat:nat": {"inside": [null]}, "helper-address": [{"address": "10.100.1.50", "vrf": "PRODUCTION"}], "pim": {"Cisco-IOS-XE-multicast:border": [null], "Cisco-IOS-XE-multicast:bfd": [null], "Cisco-IOS-XE-multicast:pim-mode-choice-cfg": {"sparse-mode": {}}, "Cisco-IOS-XE-multicast:dr-priority": 1000}, "proxy-arp": false, "redirects": false, "dhcp": {"Cisco-IOS-XE-dhcp:relay": {"information": {"option": {"vpn-id": [null]}}, "source-interface": "Loopback150"}}, "Cisco-IOS-XE-flow:flow": {"monitor-new": [{"name": "MONITOR_C9K_TEST", "direction": "input"}]}, "Cisco-IOS-XE-icmp:unreachables": false, "Cisco-IOS-XE-igmp:igmp": {"version": 3}, "Cisco-IOS-XE-nbar:nbar": {"protocol-discovery": {}}, "Cisco-IOS-XE-ospf:router-ospf": {"ospf": {"process-id": [{"id": 10, "area": [{"area-id": 0}]}], "cost": 10, "dead-interval": 60, "hello-interval": 15, "mtu-ignore": true, "message-digest-key": [{"id": 1, "md5": {"auth-type": 0, "auth-key": "cisco"}}], "network": {"point-to-point": [null]}, "multi-area": {"multi-area-id": [{"area-id": 1}, {"area-id": 2}]}, "priority": 10, "ttl-security": {"hops": 5}}}}, "ipv6": {"address": {"prefix-list": [{"prefix": "2001:db8::1/64", "eui-64": [null]}], "link-local-address": [{"address": "fe80::1", "link-local": [null]}]}, "enable": [null], "mtu": 1600, "nd": {"Cisco-IOS-XE-nd:ra": {"suppress": {"all": [null]}}}, "Cisco-IOS-XE-flow:flow": {"monitor-new": [{"name": "MONITOR_C9K_TEST_V6", "direction": "input"}]}, "Cisco-IOS-XE-multicast:pim-conf": {"pim": true}, "Cisco-IOS-XE-multicast:pim-container": {"bfd": [null], "dr-priority": 1000}}, "load-interval": 30, "logging": {"event": {"link-status-enable": true}}, "mtu": 1600, "Cisco-IOS-XE-cdp:cdp": {"enable": true, "tlv": {"default-wrp": {"app": false}, "server-location-config": false, "location-config": false}}, "Cisco-IOS-XE-dot1x:dot1x": {"pae": "authenticator", "max-reauth-req": 3, "max-req": 3, "timeout": {"auth-period": 10000, "held-period": 40000, "quiet-period": 10000, "ratelimit-period": 5000, "server-timeout": 5000, "start-period": 2000, "supp-timeout": 2000, "tx-period": 2000}}, "Cisco-IOS-XE-ethernet:port-settings": {"speed": {"speed-value": "100"}, "auto-negotiation": "disable"}, "Cisco-IOS-XE-ethernet:speed": {"nonegotiate": [null]}, "Cisco-IOS-XE-ospfv3:ospfv3": {"cost-config": {"value": 10}, "network-type": {"point-to-point": [null]}}, "Cisco-IOS-XE-policy:service-policy": {"input": "POLICY_IN", "output": "POLICY_OUT"}, "Cisco-IOS-XE-sanet:authentication": {"periodic": [null], "timer": {"reauthenticate": {"server-config": [null]}}}, "Cisco-IOS-XE-sanet:mab": {"eap": [null]}, "Cisco-IOS-XE-snmp:snmp": {"trap": {"link-status": true}}}"#;
-        let path = "$.name";
-        let data: Value = serde_json::from_str(data).unwrap();
-        let result = JsonPath::parse(path).unwrap().query(&data).all();
-        assert_eq!(result.len(), 1);
-        assert_eq!(result[0].as_str().unwrap(), "1/0/1");
-    }
-}