jsonschema-path 0.4.2__tar.gz → 0.4.4__tar.gz

{jsonschema_path-0.4.2 → jsonschema_path-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jsonschema-path
-Version: 0.4.2
+Version: 0.4.4
 Summary: JSONSchema Spec with object-oriented paths
 License: Apache-2.0
 License-File: LICENSE
@@ -120,6 +120,21 @@ Usage
    {'type': 'string', 'default': '1.0'}
 
 
+Resolved cache
+##############
+
+The resolved-path cache is intended for repeated path lookups and may significantly improve
+``read_value``/membership hot paths. Cache entries are invalidated when the
+resolver registry evolves during reference resolution.
+
+This cache is optional and disabled by default
+(``resolved_cache_maxsize=0``). You can enable it when creating paths or
+accessors, for example:
+
+.. code-block:: python
+
+   >>> path = SchemaPath.from_dict(d, resolved_cache_maxsize=64)
+
 Benchmarks
 ##########
 
@@ -140,12 +155,13 @@ For a quick smoke run:
    poetry run python -m tests.benchmarks.bench_parse --output reports/bench-parse.quick.json --quick
    poetry run python -m tests.benchmarks.bench_lookup --output reports/bench-lookup.quick.json --quick
 
-You can also control repeats/warmup via env vars:
+You can also control repeats/warmup and resolved cache maxsize via env vars:
 
 .. code-block:: console
 
    export JSONSCHEMA_PATH_BENCH_REPEATS=5
    export JSONSCHEMA_PATH_BENCH_WARMUP=1
+   export JSONSCHEMA_PATH_BENCH_RESOLVED_CACHE_MAXSIZE=64
 
 Compare two results:
 

{jsonschema_path-0.4.2 → jsonschema_path-0.4.4}/README.rst

@@ -90,6 +90,21 @@ Usage
    {'type': 'string', 'default': '1.0'}
 
 
+Resolved cache
+##############
+
+The resolved-path cache is intended for repeated path lookups and may significantly improve
+``read_value``/membership hot paths. Cache entries are invalidated when the
+resolver registry evolves during reference resolution.
+
+This cache is optional and disabled by default
+(``resolved_cache_maxsize=0``). You can enable it when creating paths or
+accessors, for example:
+
+.. code-block:: python
+
+   >>> path = SchemaPath.from_dict(d, resolved_cache_maxsize=64)
+
 Benchmarks
 ##########
 
@@ -110,12 +125,13 @@ For a quick smoke run:
    poetry run python -m tests.benchmarks.bench_parse --output reports/bench-parse.quick.json --quick
    poetry run python -m tests.benchmarks.bench_lookup --output reports/bench-lookup.quick.json --quick
 
-You can also control repeats/warmup via env vars:
+You can also control repeats/warmup and resolved cache maxsize via env vars:
 
 .. code-block:: console
 
    export JSONSCHEMA_PATH_BENCH_REPEATS=5
    export JSONSCHEMA_PATH_BENCH_WARMUP=1
+   export JSONSCHEMA_PATH_BENCH_RESOLVED_CACHE_MAXSIZE=64
 
 Compare two results:
 

{jsonschema_path-0.4.2 → jsonschema_path-0.4.4}/jsonschema_path/__init__.py

@@ -4,7 +4,7 @@ from jsonschema_path.paths import SchemaPath
 
 __author__ = "Artur Maciag"
 __email__ = "maciag.artur@gmail.com"
-__version__ = "0.4.2"
+__version__ = "0.4.4"
 __url__ = "https://github.com/p1c2u/jsonschema-path"
 __license__ = "Apache-2.0"
 

{jsonschema_path-0.4.2 → jsonschema_path-0.4.4}/jsonschema_path/accessors.py

@@ -17,21 +17,32 @@ from referencing._core import Resolved
 from referencing._core import Resolver
 from referencing.jsonschema import DRAFT202012
 
+from jsonschema_path.caches import FullPathResolvedCache
 from jsonschema_path.handlers import default_handlers
+from jsonschema_path.resolvers import CachedPathResolver
 from jsonschema_path.retrievers import SchemaRetriever
 from jsonschema_path.typing import ResolverHandlers
 from jsonschema_path.typing import Schema
-from jsonschema_path.utils import is_ref
 
 
 class SchemaAccessor(LookupAccessor):
-    _resolver_refs: dict[int, Resolver[Schema] | None] = {}
+    def __init__(
+        self,
+        schema: Schema,
+        resolver: Resolver[Schema],
+        resolved_cache_maxsize: int = 0,
+    ):
+        if resolved_cache_maxsize < 0:
+            raise ValueError("resolved_cache_maxsize must be >= 0")
 
-    def __init__(self, schema: Schema, resolver: Resolver[Schema]):
         super().__init__(cast(LookupNode, schema))
-        self.resolver = resolver
-
-        self._resolver_refs[id(schema)] = resolver
+        self._path_resolver: CachedPathResolver = CachedPathResolver(
+            resolver,
+        )
+        self._resolved_cache_maxsize = resolved_cache_maxsize
+        self._resolved_cache: FullPathResolvedCache = FullPathResolvedCache(
+            maxsize=resolved_cache_maxsize
+        )
 
     @classmethod
     def from_schema(
@@ -40,6 +51,7 @@ class SchemaAccessor(LookupAccessor):
         specification: Specification[Schema] = DRAFT202012,
         base_uri: str = "",
         handlers: ResolverHandlers | None = None,
+        resolved_cache_maxsize: int = 0,
     ) -> "SchemaAccessor":
         if handlers is None:
             handlers = default_handlers
@@ -50,7 +62,11 @@ class SchemaAccessor(LookupAccessor):
         )
         registry = registry.with_resource(base_uri, base_resource)
         resolver = registry.resolver(base_uri=base_uri)
-        return cls(schema, resolver)
+        return cls(
+            schema,
+            resolver,
+            resolved_cache_maxsize=resolved_cache_maxsize,
+        )
 
     def __getitem__(self, parts: Sequence[LookupKey]) -> LookupNode:
         resolved = self.get_resolved(parts)
@@ -143,49 +159,14 @@ class SchemaAccessor(LookupAccessor):
             pass
 
     def get_resolved(self, parts: Sequence[LookupKey]) -> Resolved[LookupNode]:
-        resolved = self._get_resolved(self.node, parts, resolver=self.resolver)
-        self.resolver = self.resolver._evolve(
-            self.resolver._base_uri,
-            registry=resolved.resolver._registry,
-        )
-        return resolved
+        cached_resolved = self._resolved_cache.get(parts)
+        if cached_resolved is not None:
+            return cached_resolved
 
-    @classmethod
-    def _get_resolved(
-        cls,
-        node: LookupNode,
-        parts: Sequence[LookupKey],
-        resolver: Resolver[Schema] | None = None,
-    ) -> Resolved[LookupNode]:
-        if resolver is None:
-            raise ValueError("resolver must be provided")
-
-        current_node: LookupNode = node
-        current_resolver: Resolver[Schema] = resolver
-
-        for part in parts:
-            resolved = cls._resolve_node(current_node, current_resolver)
-            current_node, current_resolver = (
-                resolved.contents,
-                resolved.resolver,
-            )
-            current_node = cls._get_subnode(current_node, part)
-
-        resolved = cls._resolve_node(current_node, current_resolver)
-        return cast(Resolved[LookupNode], resolved)
+        result = self._path_resolver.resolve(self.node, parts)
+        if result.registry_changed:
+            self._resolved_cache.invalidate()
 
-    @classmethod
-    def _resolve_node(
-        cls,
-        node: LookupNode,
-        resolver: Resolver[Schema],
-    ) -> Resolved[Schema]:
-        if is_ref(node):
-            ref_node = cls._get_subnode(node, "$ref")
-            ref = cls._read_node(ref_node)
-            resolved = resolver.lookup(ref)
-            return cls._resolve_node(
-                resolved.contents,
-                resolved.resolver,
-            )
-        return Resolved(cast(Schema, node), resolver)  # type: ignore
+        self._resolved_cache.set(parts, result.resolved)
+
+        return result.resolved

jsonschema_path-0.4.4/jsonschema_path/caches.py

@@ -0,0 +1,108 @@
+"""JSONSchema path caches module."""
+
+from collections import OrderedDict
+from collections.abc import Sequence
+
+from pathable.types import LookupKey
+from pathable.types import LookupNode
+from referencing._core import Resolved
+
+
+class FullPathResolvedCache:
+    def __init__(self, maxsize: int):
+        self._maxsize = maxsize
+        self._generation = 0
+        self._cache: OrderedDict[
+            tuple[tuple[LookupKey, ...], int],
+            Resolved[LookupNode],
+        ] = OrderedDict()
+
+    def _make_key(
+        self,
+        parts: Sequence[LookupKey],
+    ) -> tuple[tuple[LookupKey, ...], int] | None:
+        if self._maxsize <= 0:
+            return None
+
+        parts_tuple = tuple(parts)
+        try:
+            hash(parts_tuple)
+        except TypeError:
+            return None
+
+        return (parts_tuple, self._generation)
+
+    def get(
+        self,
+        parts: Sequence[LookupKey],
+    ) -> Resolved[LookupNode] | None:
+        key = self._make_key(parts)
+        if key is None:
+            return None
+
+        cached = self._cache.get(key)
+        if cached is None:
+            return None
+
+        self._cache.move_to_end(key)
+        return cached
+
+    def set(
+        self,
+        parts: Sequence[LookupKey],
+        resolved: Resolved[LookupNode],
+    ) -> None:
+        key = self._make_key(parts)
+        if key is None:
+            return
+
+        self._cache[key] = resolved
+        self._cache.move_to_end(key)
+        if len(self._cache) > self._maxsize:
+            self._cache.popitem(last=False)
+
+    def invalidate(self) -> None:
+        self._generation += 1
+        self._cache.clear()
+
+
+class PrefixResolvedCache:
+    def __init__(self) -> None:
+        self._cache: dict[tuple[LookupKey, ...], Resolved[LookupNode]] = {}
+
+    def seed_root(self, resolved: Resolved[LookupNode]) -> None:
+        self._cache[()] = resolved
+
+    def longest_prefix_hit(
+        self,
+        parts: tuple[LookupKey, ...],
+    ) -> tuple[int, Resolved[LookupNode]] | None:
+        for idx in range(len(parts) - 1, -1, -1):
+            prefix = parts[:idx]
+            try:
+                cached = self._cache.get(prefix)
+            except TypeError:
+                continue
+
+            if cached is not None:
+                return idx, cached
+
+        return None
+
+    def store_intermediate(
+        self,
+        parts: tuple[LookupKey, ...],
+        index: int,
+        resolved: Resolved[LookupNode],
+    ) -> None:
+        if index >= len(parts) - 1:
+            return
+
+        prefix = parts[: index + 1]
+        try:
+            self._cache[prefix] = resolved
+        except TypeError:
+            pass
+
+    def invalidate(self) -> None:
+        self._cache.clear()

jsonschema_path-0.4.4/jsonschema_path/nodes.py

@@ -0,0 +1,29 @@
+"""JSONSchema spec nodes module."""
+
+from typing import cast
+
+from pathable.accessors import LookupAccessor
+from pathable.types import LookupNode
+from referencing._core import Resolved
+from referencing._core import Resolver
+
+from jsonschema_path.typing import Schema
+from jsonschema_path.utils import is_ref
+
+
+class SchemaNode(LookupAccessor):
+    @classmethod
+    def _resolve_node(
+        cls,
+        node: LookupNode,
+        resolver: Resolver[Schema],
+    ) -> Resolved[Schema]:
+        if is_ref(node):
+            ref_node = cls._get_subnode(node, "$ref")
+            ref = cls._read_node(ref_node)
+            resolved = resolver.lookup(ref)
+            return cls._resolve_node(
+                resolved.contents,
+                resolved.resolver,
+            )
+        return Resolved(cast(Schema, node), resolver)  # type: ignore

{jsonschema_path-0.4.2 → jsonschema_path-0.4.4}/jsonschema_path/paths.py

@@ -105,6 +105,7 @@ class SchemaPath(AccessorPath[SchemaNode, SchemaKey, SchemaValue]):
         specification: Specification[Schema] = DRAFT202012,
         base_uri: str = "",
         handlers: ResolverHandlers = default_handlers,
+        resolved_cache_maxsize: int = 0,
         spec_url: str | None = None,
         ref_resolver_handlers: ResolverHandlers | None = None,
     ) -> TSchemaPath:
@@ -127,6 +128,7 @@ class SchemaPath(AccessorPath[SchemaNode, SchemaKey, SchemaValue]):
             specification=specification,
             base_uri=base_uri,
             handlers=handlers,
+            resolved_cache_maxsize=resolved_cache_maxsize,
         )
 
         return cls(accessor, *args, separator=separator)
@@ -135,19 +137,29 @@ class SchemaPath(AccessorPath[SchemaNode, SchemaKey, SchemaValue]):
     def from_path(
         cls: type[TSchemaPath],
         path: Path,
+        resolved_cache_maxsize: int = 0,
     ) -> TSchemaPath:
         reader = PathReader(path)
         data, base_uri = reader.read()
-        return cls.from_dict(data, base_uri=base_uri)
+        return cls.from_dict(
+            data,
+            base_uri=base_uri,
+            resolved_cache_maxsize=resolved_cache_maxsize,
+        )
 
     @classmethod
     def from_file_path(
         cls: type[TSchemaPath],
         file_path: str,
+        resolved_cache_maxsize: int = 0,
     ) -> TSchemaPath:
         reader = FilePathReader(file_path)
         data, base_uri = reader.read()
-        return cls.from_dict(data, base_uri=base_uri)
+        return cls.from_dict(
+            data,
+            base_uri=base_uri,
+            resolved_cache_maxsize=resolved_cache_maxsize,
+        )
 
     @classmethod
     def from_file(
@@ -155,10 +167,16 @@ class SchemaPath(AccessorPath[SchemaNode, SchemaKey, SchemaValue]):
         fileobj: SupportsRead,
         base_uri: str = "",
         spec_url: str | None = None,
+        resolved_cache_maxsize: int = 0,
     ) -> TSchemaPath:
         reader = FileReader(fileobj)
         data, _ = reader.read()
-        return cls.from_dict(data, base_uri=base_uri, spec_url=spec_url)
+        return cls.from_dict(
+            data,
+            base_uri=base_uri,
+            spec_url=spec_url,
+            resolved_cache_maxsize=resolved_cache_maxsize,
+        )
 
     def str_keys(self) -> Sequence[str]:
         keys = list(self.keys())

jsonschema_path-0.4.4/jsonschema_path/resolvers.py

@@ -0,0 +1,91 @@
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import cast
+
+from pathable.types import LookupKey
+from pathable.types import LookupNode
+from referencing import Registry
+from referencing._core import Resolved
+from referencing._core import Resolver
+
+from jsonschema_path.caches import PrefixResolvedCache
+from jsonschema_path.nodes import SchemaNode
+from jsonschema_path.typing import Schema
+
+
+@dataclass(frozen=True)
+class ResolveResult:
+    resolved: Resolved[LookupNode]
+    registry_changed: bool
+
+
+class CachedPathResolver:
+    def __init__(self, resolver: Resolver[Schema]):
+        self.resolver = resolver
+        self.prefix_cache = PrefixResolvedCache()
+
+    def resolve(
+        self,
+        node: LookupNode,
+        parts: Sequence[LookupKey],
+    ) -> ResolveResult:
+        resolved = self._resolve_with_prefix_cache(node, parts)
+        registry_changed = self._sync_registry(resolved.resolver._registry)
+        return ResolveResult(
+            resolved=resolved,
+            registry_changed=registry_changed,
+        )
+
+    def _resolve_with_prefix_cache(
+        self,
+        node: LookupNode,
+        parts: Sequence[LookupKey],
+    ) -> Resolved[LookupNode]:
+
+        parts_tuple = tuple(parts)
+        cached_prefix = self.prefix_cache.longest_prefix_hit(parts_tuple)
+        if cached_prefix is None:
+            root_resolved_schema = SchemaNode._resolve_node(
+                node,
+                self.resolver,
+            )
+            resolved = cast(Resolved[LookupNode], root_resolved_schema)
+            current_node = cast(LookupNode, root_resolved_schema.contents)
+            current_resolver: Resolver[Schema] = root_resolved_schema.resolver
+            start = 0
+            self.prefix_cache.seed_root(resolved)
+        else:
+            start, resolved = cached_prefix
+            current_node = resolved.contents
+            current_resolver = cast(Resolver[Schema], resolved.resolver)
+
+        for index in range(start, len(parts_tuple)):
+            part = parts_tuple[index]
+            current_node = SchemaNode._get_subnode(current_node, part)
+            resolved_schema = SchemaNode._resolve_node(
+                current_node,
+                current_resolver,
+            )
+            resolved = cast(Resolved[LookupNode], resolved_schema)
+            current_node, current_resolver = (
+                resolved.contents,
+                resolved_schema.resolver,
+            )
+            self.prefix_cache.store_intermediate(
+                parts_tuple,
+                index,
+                resolved,
+            )
+
+        return resolved
+
+    def _sync_registry(self, registry: Registry[LookupNode]) -> bool:
+        if registry is self.resolver._registry:
+            return False
+
+        self.resolver = self.resolver._evolve(
+            self.resolver._base_uri,
+            registry=registry,
+        )
+        self.prefix_cache.invalidate()
+        return True

{jsonschema_path-0.4.2 → jsonschema_path-0.4.4}/pyproject.toml

@@ -19,7 +19,7 @@ ignore_missing_imports = true
 
 [tool.poetry]
 name = "jsonschema-path"
-version = "0.4.2"
+version = "0.4.4"
 description = "JSONSchema Spec with object-oriented paths"
 authors = ["Artur Maciag <maciag.artur@gmail.com>"]
 license = "Apache-2.0"
@@ -93,7 +93,7 @@ message_template = "Version {new_version}"
 tag_template = "{new_version}"
 
 [tool.tbump.version]
-current = "0.4.2"
+current = "0.4.4"
 regex = '''
   (?P<major>\d+)
   \.