jsonschema-path 0.3.4__tar.gz → 0.4.0__tar.gz

{jsonschema_path-0.3.4 → jsonschema_path-0.4.0}/PKG-INFO

@@ -1,29 +1,30 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: jsonschema-path
-Version: 0.3.4
+Version: 0.4.0
 Summary: JSONSchema Spec with object-oriented paths
 License: Apache-2.0
+License-File: LICENSE
 Keywords: jsonschema,swagger,spec
 Author: Artur Maciag
 Author-email: maciag.artur@gmail.com
-Requires-Python: >=3.8.0,<4.0.0
+Requires-Python: >=3.10,<4.0.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 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
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Provides-Extra: requests
 Requires-Dist: PyYAML (>=5.1)
-Requires-Dist: pathable (>=0.4.1,<0.5.0)
+Requires-Dist: pathable (>=0.5.0,<0.6.0)
 Requires-Dist: referencing (<0.37.0)
-Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0) ; extra == "requests"
 Project-URL: Repository, https://github.com/p1c2u/jsonschema-path
 Description-Content-Type: text/x-rst
 
@@ -119,6 +120,43 @@ Usage
    {'type': 'string', 'default': '1.0'}
 
 
+Benchmarks
+##########
+
+Benchmarks mirror the lightweight (dependency-free) JSON output format used in
+`pathable`.
+
+Run locally with Poetry:
+
+.. code-block:: console
+
+   poetry run python -m tests.benchmarks.bench_parse --output reports/bench-parse.json
+   poetry run python -m tests.benchmarks.bench_lookup --output reports/bench-lookup.json
+
+For a quick smoke run:
+
+.. code-block:: console
+
+   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:
+
+.. code-block:: console
+
+   export JSONSCHEMA_PATH_BENCH_REPEATS=5
+   export JSONSCHEMA_PATH_BENCH_WARMUP=1
+
+Compare two results:
+
+.. code-block:: console
+
+    poetry run python -m tests.benchmarks.compare_results \
+       --baseline reports/bench-lookup-master.json \
+       --candidate reports/bench-lookup.json \
+       --tolerance 0.20
+
+
 Related projects
 ################
 
@@ -132,5 +170,5 @@ Related projects
 License
 #######
 
-Copyright (c) 2017-2022, Artur Maciag, All rights reserved. Apache-2.0
+Copyright (c) 2017-2025, Artur Maciag, All rights reserved. Apache-2.0
 

{jsonschema_path-0.3.4 → jsonschema_path-0.4.0}/README.rst

@@ -90,6 +90,43 @@ Usage
    {'type': 'string', 'default': '1.0'}
 
 
+Benchmarks
+##########
+
+Benchmarks mirror the lightweight (dependency-free) JSON output format used in
+`pathable`.
+
+Run locally with Poetry:
+
+.. code-block:: console
+
+   poetry run python -m tests.benchmarks.bench_parse --output reports/bench-parse.json
+   poetry run python -m tests.benchmarks.bench_lookup --output reports/bench-lookup.json
+
+For a quick smoke run:
+
+.. code-block:: console
+
+   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:
+
+.. code-block:: console
+
+   export JSONSCHEMA_PATH_BENCH_REPEATS=5
+   export JSONSCHEMA_PATH_BENCH_WARMUP=1
+
+Compare two results:
+
+.. code-block:: console
+
+    poetry run python -m tests.benchmarks.compare_results \
+       --baseline reports/bench-lookup-master.json \
+       --candidate reports/bench-lookup.json \
+       --tolerance 0.20
+
+
 Related projects
 ################
 
@@ -103,4 +140,4 @@ Related projects
 License
 #######
 
-Copyright (c) 2017-2022, Artur Maciag, All rights reserved. Apache-2.0
+Copyright (c) 2017-2025, Artur Maciag, All rights reserved. Apache-2.0

{jsonschema_path-0.3.4 → jsonschema_path-0.4.0}/jsonschema_path/__init__.py

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

jsonschema_path-0.4.0/jsonschema_path/accessors.py

@@ -0,0 +1,218 @@
+"""JSONSchema spec accessors module."""
+
+from collections.abc import Hashable
+from collections.abc import Iterator
+from collections.abc import Sequence
+from contextlib import contextmanager
+from typing import Any
+from typing import cast
+
+from pathable.accessors import LookupAccessor
+from pathable.types import LookupKey
+from pathable.types import LookupNode
+from pathable.types import LookupValue
+from referencing import Registry
+from referencing import Specification
+from referencing._core import Resolved
+from referencing._core import Resolver
+from referencing.jsonschema import DRAFT202012
+
+from jsonschema_path.handlers import default_handlers
+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]):
+        super().__init__(cast(LookupNode, schema))
+        self.resolver = resolver
+
+        self._resolver_refs[id(schema)] = resolver
+
+    @classmethod
+    def from_schema(
+        cls,
+        schema: Schema,
+        specification: Specification[Schema] = DRAFT202012,
+        base_uri: str = "",
+        handlers: ResolverHandlers | None = None,
+    ) -> "SchemaAccessor":
+        if handlers is None:
+            handlers = default_handlers
+        retriever = SchemaRetriever(handlers, specification)
+        base_resource = specification.create_resource(schema)
+        registry: Registry[Schema] = Registry(
+            retrieve=retriever,  # type: ignore
+        )
+        registry = registry.with_resource(base_uri, base_resource)
+        resolver = registry.resolver(base_uri=base_uri)
+        return cls(schema, resolver)
+
+    def __getitem__(self, parts: Sequence[LookupKey]) -> LookupNode:
+        return self._get_node(self.node, parts, self.resolver)
+
+    def stat(self, parts: Sequence[Hashable]) -> dict[str, Any] | None:
+        try:
+            resolved = self.get_resolved(cast(Sequence[LookupKey], parts))
+        except (KeyError, IndexError, TypeError):
+            return None
+
+        node = resolved.contents
+
+        if self._is_traversable_node(node):
+            return {
+                "type": type(node).__name__,
+                "length": len(node),
+            }
+        try:
+            length = len(cast(Any, node))
+        except TypeError:
+            length = None
+
+        return {
+            "type": type(node).__name__,
+            "length": length,
+        }
+
+    def keys(self, parts: Sequence[LookupKey]) -> Sequence[LookupKey]:
+        resolved = self.get_resolved(parts)
+        node = resolved.contents
+
+        if isinstance(node, dict):
+            # dict_keys has O(1) membership, no allocation.
+            return cast(Sequence[LookupKey], node.keys())
+        if isinstance(node, list):
+            # range has O(1) membership and supports iteration.
+            return cast(Sequence[LookupKey], range(len(node)))
+
+        # Non-traversable leaf.
+        if parts:
+            raise KeyError(parts[-1])
+        raise KeyError
+
+    def len(self, parts: Sequence[LookupKey]) -> int:
+        resolved = self.get_resolved(parts)
+        node = resolved.contents
+        if isinstance(node, (dict, list)):
+            return len(node)
+        if parts:
+            raise KeyError(parts[-1])
+        raise KeyError
+
+    def contains(self, parts: Sequence[LookupKey], key: LookupKey) -> bool:
+        try:
+            resolved = self.get_resolved(parts)
+        except (KeyError, IndexError, TypeError):
+            return False
+
+        node = resolved.contents
+        if isinstance(node, dict):
+            return key in node
+        if isinstance(node, list):
+            return isinstance(key, int) and 0 <= key < len(node)
+        return False
+
+    def require_child(
+        self, parts: Sequence[LookupKey], key: LookupKey
+    ) -> None:
+        # Validate parent path for intermediate diagnostics.
+        resolved = self.get_resolved(parts)
+        node = resolved.contents
+
+        if isinstance(node, dict):
+            if key not in node:
+                raise KeyError(key)
+            return
+        if isinstance(node, list):
+            if not (isinstance(key, int) and 0 <= key < len(node)):
+                raise KeyError(key)
+            return
+
+        raise KeyError(key)
+
+    def read(self, parts: Sequence[LookupKey]) -> LookupValue:
+        resolved = self.get_resolved(parts)
+        return self._read_node(resolved.contents)
+
+    @contextmanager
+    def resolve(
+        self, parts: Sequence[LookupKey]
+    ) -> Iterator[Resolved[LookupNode]]:
+        try:
+            yield self.get_resolved(parts)
+        finally:
+            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
+
+    @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)
+
+    @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
+
+    @classmethod
+    def _get_node(
+        cls,
+        node: LookupNode,
+        parts: Sequence[LookupKey],
+        resolver: Resolver[Schema] | None = None,
+    ) -> 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)
+        return current_node

{jsonschema_path-0.3.4 → jsonschema_path-0.4.0}/jsonschema_path/handlers/file.py

@@ -4,8 +4,6 @@ from json import dumps
 from json import loads
 from typing import Any
 from typing import ContextManager
-from typing import Optional
-from typing import Tuple
 from urllib.parse import urlparse
 
 from yaml import load
@@ -32,10 +30,10 @@ class FileHandler:
 class BaseFilePathHandler:
     """Base file path handler."""
 
-    allowed_schemes: Tuple[str, ...] = NotImplemented
+    allowed_schemes: tuple[str, ...] = NotImplemented
 
     def __init__(
-        self, *allowed_schemes: str, file_handler: Optional[FileHandler] = None
+        self, *allowed_schemes: str, file_handler: FileHandler | None = None
     ):
         self.allowed_schemes = allowed_schemes or self.allowed_schemes
         self.file_handler = file_handler or FileHandler()
@@ -60,7 +58,7 @@ class FilePathHandler(BaseFilePathHandler):
     def __init__(
         self,
         *allowed_schemes: str,
-        file_handler: Optional[FileHandler] = None,
+        file_handler: FileHandler | None = None,
         encoding: str = "utf-8",
     ):
         super().__init__(*allowed_schemes, file_handler=file_handler)

jsonschema_path-0.4.0/jsonschema_path/handlers/protocols.py

@@ -0,0 +1,5 @@
+from typing import Protocol
+
+
+class SupportsRead(Protocol):
+    def read(self, amount: int | None = 0) -> str: ...

{jsonschema_path-0.3.4 → jsonschema_path-0.4.0}/jsonschema_path/handlers/requests.py

@@ -3,8 +3,6 @@
 from contextlib import closing
 from io import StringIO
 from typing import ContextManager
-from typing import Optional
-from typing import Union
 
 import requests
 
@@ -19,9 +17,9 @@ class UrlRequestsHandler(BaseFilePathHandler):
     def __init__(
         self,
         *allowed_schemes: str,
-        file_handler: Optional[FileHandler] = None,
+        file_handler: FileHandler | None = None,
         timeout: int = 10,
-        verify: Optional[Union[bool, str]] = True,
+        verify: bool | str | None = True,
     ):
         super().__init__(*allowed_schemes, file_handler=file_handler)
         self.timeout = timeout

{jsonschema_path-0.3.4 → jsonschema_path-0.4.0}/jsonschema_path/handlers/urllib.py

@@ -2,7 +2,6 @@
 
 from contextlib import closing
 from typing import ContextManager
-from typing import Optional
 from urllib.request import urlopen
 
 from jsonschema_path.handlers.file import BaseFilePathHandler
@@ -16,7 +15,7 @@ class UrllibHandler(BaseFilePathHandler):
     def __init__(
         self,
         *allowed_schemes: str,
-        file_handler: Optional[FileHandler] = None,
+        file_handler: FileHandler | None = None,
         timeout: int = 10
     ):
         super().__init__(*allowed_schemes, file_handler=file_handler)

{jsonschema_path-0.3.4 → jsonschema_path-0.4.0}/jsonschema_path/loaders.py

@@ -1,9 +1,7 @@
 # Use CSafeFile if available
+from collections.abc import Iterable
 from typing import TYPE_CHECKING
 from typing import Any
-from typing import Dict
-from typing import Iterable
-from typing import Tuple
 
 if TYPE_CHECKING:
     from yaml import SafeLoader
@@ -25,8 +23,8 @@ class LimitedSafeLoader(type):
     def __new__(
         cls,
         name: str,
-        bases: Tuple[type, ...],
-        namespace: Dict[str, Any],
+        bases: tuple[type, ...],
+        namespace: dict[str, Any],
         exclude_resolvers: Iterable[str],
     ) -> "LimitedSafeLoader":
         exclude_resolvers = set(exclude_resolvers)

jsonschema_path-0.4.0/jsonschema_path/paths.py

@@ -0,0 +1,254 @@
+"""JSONSchema spec paths module."""
+
+from __future__ import annotations
+
+import os
+import warnings
+from collections.abc import Iterator
+from collections.abc import Sequence
+from contextlib import contextmanager
+from functools import cached_property
+from pathlib import Path
+from typing import Any
+from typing import TypeVar
+from typing import overload
+
+from pathable import AccessorPath
+from referencing import Specification
+from referencing._core import Resolved
+from referencing.jsonschema import DRAFT202012
+
+from jsonschema_path.accessors import SchemaAccessor
+from jsonschema_path.handlers import default_handlers
+from jsonschema_path.handlers.protocols import SupportsRead
+from jsonschema_path.readers import FilePathReader
+from jsonschema_path.readers import FileReader
+from jsonschema_path.readers import PathReader
+from jsonschema_path.typing import ResolverHandlers
+from jsonschema_path.typing import Schema
+from jsonschema_path.typing import SchemaKey
+from jsonschema_path.typing import SchemaNode
+from jsonschema_path.typing import SchemaValue
+from jsonschema_path.typing import is_str_sequence
+
+TDefault = TypeVar("TDefault")
+# Python 3.11+ shortcut: typing.Self
+TSchemaPath = TypeVar("TSchemaPath", bound="SchemaPath")
+
+SPEC_SEPARATOR = "#"
+NOTSET = object()
+
+
+class SchemaPath(AccessorPath[SchemaNode, SchemaKey, SchemaValue]):
+
+    @classmethod
+    def _parse_args(
+        cls,
+        args: Sequence[Any],
+        sep: str = SPEC_SEPARATOR,
+    ) -> tuple[SchemaKey, ...]:
+        parts: list[SchemaKey] = []
+        append = parts.append
+        extend = parts.extend
+
+        for a in args:
+            if isinstance(a, cls):
+                extend(a.parts)
+                continue
+
+            # Fast-path: benchmarks overwhelmingly pass `str`/`int` parts.
+            if isinstance(a, int):
+                append(a)
+                continue
+
+            if isinstance(a, bytes):
+                a = a.decode("ascii")
+
+            if isinstance(a, str):
+                if a and a != ".":
+                    if sep in a:
+                        for x in a.split(sep):
+                            if x and x != ".":
+                                append(x)
+                    else:
+                        append(a)
+                continue
+
+            # PathLike is relatively expensive to check; keep it after common types.
+            if isinstance(a, os.PathLike):
+                a = os.fspath(a)
+                if isinstance(a, bytes):
+                    a = a.decode("ascii")
+                if isinstance(a, str):
+                    if a and a != ".":
+                        if sep in a:
+                            for x in a.split(sep):
+                                if x and x != ".":
+                                    append(x)
+                        else:
+                            append(a)
+                    continue
+
+            raise TypeError(
+                "argument must be str, int, bytes, os.PathLike, or SchemaPath; got %r"
+                % (type(a),)
+            )
+
+        return tuple(parts)
+
+    @classmethod
+    def from_dict(
+        cls: type[TSchemaPath],
+        data: Schema,
+        *args: Any,
+        separator: str = SPEC_SEPARATOR,
+        specification: Specification[Schema] = DRAFT202012,
+        base_uri: str = "",
+        handlers: ResolverHandlers = default_handlers,
+        spec_url: str | None = None,
+        ref_resolver_handlers: ResolverHandlers | None = None,
+    ) -> TSchemaPath:
+        if spec_url is not None:
+            warnings.warn(
+                "spec_url parameter is deprecated. " "Use base_uri instead.",
+                DeprecationWarning,
+            )
+            base_uri = spec_url
+        if ref_resolver_handlers is not None:
+            warnings.warn(
+                "ref_resolver_handlers parameter is deprecated. "
+                "Use handlers instead.",
+                DeprecationWarning,
+            )
+            handlers = ref_resolver_handlers
+
+        accessor: SchemaAccessor = SchemaAccessor.from_schema(
+            data,
+            specification=specification,
+            base_uri=base_uri,
+            handlers=handlers,
+        )
+
+        return cls(accessor, *args, separator=separator)
+
+    @classmethod
+    def from_path(
+        cls: type[TSchemaPath],
+        path: Path,
+    ) -> TSchemaPath:
+        reader = PathReader(path)
+        data, base_uri = reader.read()
+        return cls.from_dict(data, base_uri=base_uri)
+
+    @classmethod
+    def from_file_path(
+        cls: type[TSchemaPath],
+        file_path: str,
+    ) -> TSchemaPath:
+        reader = FilePathReader(file_path)
+        data, base_uri = reader.read()
+        return cls.from_dict(data, base_uri=base_uri)
+
+    @classmethod
+    def from_file(
+        cls: type[TSchemaPath],
+        fileobj: SupportsRead,
+        base_uri: str = "",
+        spec_url: str | None = None,
+    ) -> TSchemaPath:
+        reader = FileReader(fileobj)
+        data, _ = reader.read()
+        return cls.from_dict(data, base_uri=base_uri, spec_url=spec_url)
+
+    def str_keys(self) -> Sequence[str]:
+        keys = list(self.keys())
+        if not is_str_sequence(keys):
+            raise TypeError(
+                f"Expected string keys, got {[type(x) for x in keys]}"
+            )
+        return keys
+
+    def str_items(self) -> Iterator[tuple[str, SchemaPath]]:
+        for key, value in self.items():
+            if not isinstance(key, str):
+                raise TypeError(f"Expected string keys, got {type(key)}")
+            yield key, value
+
+    @overload
+    def read_str(self) -> str: ...
+
+    @overload
+    def read_str(self, default: TDefault) -> str | TDefault: ...
+
+    def read_str(self, default: object = NOTSET) -> object:
+        try:
+            value = self.read_value()
+        except KeyError:
+            if default is not NOTSET:
+                return default
+            raise
+        if not isinstance(value, str):
+            raise TypeError(f"Expected a string value, got {type(value)}")
+        return value
+
+    @overload
+    def read_str_or_list(self) -> str | list[str]: ...
+
+    @overload
+    def read_str_or_list(
+        self, default: TDefault
+    ) -> str | list[str] | TDefault: ...
+
+    def read_str_or_list(self, default: object = NOTSET) -> object:
+        try:
+            value = self.read_value()
+        except KeyError:
+            if default is not NOTSET:
+                return default
+            raise
+        if not isinstance(value, (str, list)):
+            raise TypeError(
+                f"Expected a string or a list of strings, got {type(value)}"
+            )
+        return value
+
+    @overload
+    def read_bool(self) -> bool: ...
+
+    @overload
+    def read_bool(self, default: TDefault) -> bool | TDefault: ...
+
+    def read_bool(self, default: object = NOTSET) -> object:
+        try:
+            value = self.read_value()
+        except KeyError:
+            if default is not NOTSET:
+                return default
+            raise
+        if not isinstance(value, bool):
+            if default is not NOTSET:
+                return default
+            raise TypeError(f"Expected a bool value, got {type(value)}")
+        return value
+
+    def as_uri(self) -> str:
+        return f"#/{str(self)}"
+
+    @contextmanager
+    def open(self) -> Any:
+        """Open the path."""
+        # Cached path content
+        with self.resolve() as resolved:
+            yield resolved.contents
+
+    @contextmanager
+    def resolve(self) -> Iterator[Resolved[SchemaNode]]:
+        """Resolve the path."""
+        # Cached path content
+        yield self._get_resolved
+
+    @cached_property
+    def _get_resolved(self) -> Resolved[SchemaNode]:
+        assert isinstance(self.accessor, SchemaAccessor)
+        with self.accessor.resolve(self.parts) as resolved:
+            return resolved

{jsonschema_path-0.3.4 → jsonschema_path-0.4.0}/jsonschema_path/readers.py

@@ -1,18 +1,15 @@
 """JSONSchema spec readers module."""
 
 from pathlib import Path
-from typing import Any
-from typing import Hashable
-from typing import Mapping
-from typing import Tuple
 
 from jsonschema_path.handlers import all_urls_handler
 from jsonschema_path.handlers import file_handler
 from jsonschema_path.handlers.protocols import SupportsRead
+from jsonschema_path.typing import Schema
 
 
 class BaseReader:
-    def read(self) -> Tuple[Mapping[Hashable, Any], str]:
+    def read(self) -> tuple[Schema, str]:
         raise NotImplementedError
 
 
@@ -20,7 +17,7 @@ class FileReader(BaseReader):
     def __init__(self, fileobj: SupportsRead):
         self.fileobj = fileobj
 
-    def read(self) -> Tuple[Mapping[Hashable, Any], str]:
+    def read(self) -> tuple[Schema, str]:
         return file_handler(self.fileobj), ""
 
 
@@ -28,7 +25,7 @@ class PathReader(BaseReader):
     def __init__(self, path: Path):
         self.path = path
 
-    def read(self) -> Tuple[Mapping[Hashable, Any], str]:
+    def read(self) -> tuple[Schema, str]:
         if not self.path.is_file():
             raise OSError(f"No such file: {self.path}")
 

jsonschema_path-0.4.0/jsonschema_path/typing.py

@@ -0,0 +1,24 @@
+from collections.abc import Mapping
+from collections.abc import Sequence
+from typing import Any
+from typing import TypeGuard
+
+from pathable.types import LookupKey as SchemaKey
+from pathable.types import LookupNode as SchemaNode
+from pathable.types import LookupValue as SchemaValue
+
+__all__ = [
+    "ResolverHandlers",
+    "Schema",
+    "SchemaNode",
+    "SchemaKey",
+    "SchemaValue",
+]
+
+ResolverHandlers = Mapping[str, Any]
+Schema = Mapping[str, Any]
+
+
+def is_str_sequence(val: Sequence[object]) -> TypeGuard[Sequence[str]]:
+    """Determines whether all objects in the list are strings"""
+    return all(isinstance(x, str) for x in val)

jsonschema_path-0.4.0/jsonschema_path/utils.py

@@ -0,0 +1,9 @@
+from typing import Any
+
+
+def is_ref(item: Any) -> bool:
+    return (
+        isinstance(item, dict)
+        and "$ref" in item
+        and isinstance(item["$ref"], str)
+    )

{jsonschema_path-0.3.4 → jsonschema_path-0.4.0}/pyproject.toml

@@ -19,7 +19,7 @@ ignore_missing_imports = true
 
 [tool.poetry]
 name = "jsonschema-path"
-version = "0.3.4"
+version = "0.4.0"
 description = "JSONSchema Spec with object-oriented paths"
 authors = ["Artur Maciag <maciag.artur@gmail.com>"]
 license = "Apache-2.0"
@@ -32,37 +32,40 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
     "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",
     "Topic :: Software Development :: Libraries",
 ]
 
 [tool.poetry.dependencies]
-pathable = "^0.4.1"
-python = "^3.8.0"
+pathable = "^0.5.0"
+python = ">=3.10,<4.0.0"
 PyYAML = ">=5.1"
 requests = {version = "^2.31.0", optional = true}
 referencing = "<0.37.0"
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
+tbump = "^6.11.0"
 pre-commit = "*"
 pytest = "^8.2.1"
-pytest-flake8 = "=1.1.1"
-pytest-cov = "^5.0.0"
-isort = "^5.13.2"
-black = "^24.4.0"
-flynt = "1.0.1"
-mypy = "^1.9.0"
+pytest-flake8 = "=1.3.0"
+pytest-cov = ">=5,<7"
+isort = ">=5.13.2,<7.0.0"
+black = "^25.1.0"
+flynt = "1.0.6"
+mypy = "^1.14.1"
 types-PyYAML = "^6.0.12"
 types-requests = "^2.31.0"
-typing-extensions = "^4.10.0"  # required by responses. See https://github.com/p1c2u/jsonschema-path/issues/44
 responses = "^0.25.0"
-deptry = "^0.19.1"
-pyflakes = "^2.5.0"
-bump2version = "^1.0.1"
+deptry = ">=0.19.1,<0.24.0"
+pyflakes = ">=2.5,<4.0"
+ipdb = "^0.13.13"
+
+[tool.poetry.extras]
+requests = ["requests"]
 
 [tool.pytest.ini_options]
 addopts = """
@@ -82,3 +85,27 @@ line-length = 79
 profile = "black"
 line_length = 79
 force_single_line = true
+
+[tool.tbump]
+
+[tool.tbump.git]
+message_template = "Version {new_version}"
+tag_template = "{new_version}"
+
+[tool.tbump.version]
+current = "0.4.0"
+regex = '''
+  (?P<major>\d+)
+  \.
+  (?P<minor>\d+)
+  \.
+  (?P<patch>\d+)
+  (?P<prerelease>[a-z]+\d+)?
+'''
+
+[[tool.tbump.file]]
+src = "jsonschema_path/__init__.py"
+
+[[tool.tbump.file]]
+src = "pyproject.toml"
+search = 'version = "{current_version}"'

jsonschema_path-0.3.4/jsonschema_path/accessors.py

@@ -1,95 +0,0 @@
-"""JSONSchema spec accessors module."""
-
-from collections import deque
-from contextlib import contextmanager
-from typing import Any
-from typing import Deque
-from typing import Hashable
-from typing import Iterator
-from typing import List
-from typing import Optional
-from typing import Union
-
-from pathable.accessors import LookupAccessor
-from referencing import Registry
-from referencing import Specification
-from referencing._core import Resolved
-from referencing._core import Resolver
-from referencing.jsonschema import DRAFT202012
-
-from jsonschema_path.handlers import default_handlers
-from jsonschema_path.retrievers import SchemaRetriever
-from jsonschema_path.typing import Lookup
-from jsonschema_path.typing import ResolverHandlers
-from jsonschema_path.typing import Schema
-from jsonschema_path.utils import is_ref
-
-
-class ResolverAccessor(LookupAccessor):
-    def __init__(self, lookup: Lookup, resolver: Resolver[Lookup]):
-        super().__init__(lookup)
-        self.resolver = resolver
-
-
-class SchemaAccessor(ResolverAccessor):
-    @classmethod
-    def from_schema(
-        cls,
-        schema: Schema,
-        specification: Specification[Schema] = DRAFT202012,
-        base_uri: str = "",
-        handlers: ResolverHandlers = default_handlers,
-    ) -> "SchemaAccessor":
-        retriever = SchemaRetriever(handlers, specification)
-        base_resource = specification.create_resource(schema)
-        registry: Registry[Schema] = Registry(
-            retrieve=retriever,  # type: ignore
-        )
-        registry = registry.with_resource(base_uri, base_resource)
-        resolver = registry.resolver(base_uri=base_uri)
-        return cls(schema, resolver)
-
-    @contextmanager
-    def open(self, parts: List[Hashable]) -> Iterator[Union[Schema, Any]]:
-        parts_deque = deque(parts)
-        try:
-            resolved = self._resolve(self.lookup, parts_deque)
-            yield resolved.contents
-        finally:
-            pass
-
-    @contextmanager
-    def resolve(self, parts: List[Hashable]) -> Iterator[Resolved[Any]]:
-        parts_deque = deque(parts)
-        try:
-            yield self._resolve(self.lookup, parts_deque)
-        finally:
-            pass
-
-    def _resolve(
-        self,
-        contents: Schema,
-        parts_deque: Deque[Hashable],
-        resolver: Optional[Resolver[Schema]] = None,
-    ) -> Resolved[Any]:
-        resolver = resolver or self.resolver
-        if is_ref(contents):
-            ref = contents["$ref"]
-            resolved = resolver.lookup(ref)
-            self.resolver = self.resolver._evolve(
-                self.resolver._base_uri,
-                registry=resolved.resolver._registry,
-            )
-            return self._resolve(
-                resolved.contents,
-                parts_deque,
-                resolver=resolved.resolver,
-            )
-
-        try:
-            part = parts_deque.popleft()
-        except IndexError:
-            return Resolved(contents=contents, resolver=resolver)  # type: ignore
-        else:
-            target = contents[part]
-            return self._resolve(target, parts_deque, resolver=resolver)

jsonschema_path-0.3.4/jsonschema_path/handlers/protocols.py

@@ -1,6 +0,0 @@
-from typing import Optional
-from typing import Protocol
-
-
-class SupportsRead(Protocol):
-    def read(self, amount: Optional[int] = 0) -> str: ...

jsonschema_path-0.3.4/jsonschema_path/paths.py

@@ -1,133 +0,0 @@
-"""JSONSchema spec paths module."""
-
-import warnings
-from contextlib import contextmanager
-from pathlib import Path
-from typing import Any
-from typing import Iterator
-from typing import Optional
-from typing import Type
-from typing import TypeVar
-
-from pathable.paths import AccessorPath
-from referencing import Specification
-from referencing._core import Resolved
-from referencing.jsonschema import DRAFT202012
-
-from jsonschema_path.accessors import SchemaAccessor
-from jsonschema_path.handlers import default_handlers
-from jsonschema_path.handlers.protocols import SupportsRead
-from jsonschema_path.readers import FilePathReader
-from jsonschema_path.readers import FileReader
-from jsonschema_path.readers import PathReader
-from jsonschema_path.typing import ResolverHandlers
-from jsonschema_path.typing import Schema
-
-TSpec = TypeVar("TSpec", bound="SchemaPath")
-
-SPEC_SEPARATOR = "#"
-
-
-class SchemaPath(AccessorPath):
-    def __init__(self, accessor: SchemaAccessor, *args: Any, **kwargs: Any):
-        super().__init__(accessor, *args, **kwargs)
-        self._resolved_cached: Optional[Resolved[Any]] = None
-
-    @classmethod
-    def from_dict(
-        cls: Type[TSpec],
-        data: Schema,
-        *args: Any,
-        separator: str = SPEC_SEPARATOR,
-        specification: Specification[Schema] = DRAFT202012,
-        base_uri: str = "",
-        handlers: ResolverHandlers = default_handlers,
-        spec_url: Optional[str] = None,
-        ref_resolver_handlers: Optional[ResolverHandlers] = None,
-    ) -> TSpec:
-        if spec_url is not None:
-            warnings.warn(
-                "spec_url parameter is deprecated. " "Use base_uri instead.",
-                DeprecationWarning,
-            )
-            base_uri = spec_url
-        if ref_resolver_handlers is not None:
-            warnings.warn(
-                "ref_resolver_handlers parameter is deprecated. "
-                "Use handlers instead.",
-                DeprecationWarning,
-            )
-            handlers = ref_resolver_handlers
-
-        accessor: SchemaAccessor = SchemaAccessor.from_schema(
-            data,
-            specification=specification,
-            base_uri=base_uri,
-            handlers=handlers,
-        )
-
-        return cls(accessor, *args, separator=separator)
-
-    @classmethod
-    def from_path(
-        cls: Type[TSpec],
-        path: Path,
-    ) -> TSpec:
-        reader = PathReader(path)
-        data, base_uri = reader.read()
-        return cls.from_dict(data, base_uri=base_uri)
-
-    @classmethod
-    def from_file_path(
-        cls: Type[TSpec],
-        file_path: str,
-    ) -> TSpec:
-        reader = FilePathReader(file_path)
-        data, base_uri = reader.read()
-        return cls.from_dict(data, base_uri=base_uri)
-
-    @classmethod
-    def from_file(
-        cls: Type[TSpec],
-        fileobj: SupportsRead,
-        base_uri: str = "",
-        spec_url: Optional[str] = None,
-    ) -> TSpec:
-        reader = FileReader(fileobj)
-        data, _ = reader.read()
-        return cls.from_dict(data, base_uri=base_uri, spec_url=spec_url)
-
-    def contents(self) -> Any:
-        with self.open() as d:
-            return d
-
-    def exists(self) -> bool:
-        try:
-            self.contents()
-        except KeyError:
-            return False
-        else:
-            return True
-
-    def as_uri(self) -> str:
-        return f"#/{str(self)}"
-
-    @contextmanager
-    def open(self) -> Any:
-        """Open the path."""
-        # Cached path content
-        with self.resolve() as resolved:
-            yield resolved.contents
-
-    @contextmanager
-    def resolve(self) -> Iterator[Resolved[Any]]:
-        """Resolve the path."""
-        # Cached path content
-        if self._resolved_cached is None:
-            self._resolved_cached = self._get_resolved()
-        yield self._resolved_cached
-
-    def _get_resolved(self) -> Resolved[Any]:
-        assert isinstance(self.accessor, SchemaAccessor)
-        with self.accessor.resolve(self.parts) as resolved:
-            return resolved

jsonschema_path-0.3.4/jsonschema_path/typing.py

@@ -1,8 +0,0 @@
-from typing import Any
-from typing import Hashable
-from typing import Mapping
-
-Lookup = Mapping[Hashable, Any]
-
-ResolverHandlers = Mapping[str, Any]
-Schema = Mapping[Hashable, Any]

jsonschema_path-0.3.4/jsonschema_path/utils.py

@@ -1,8 +0,0 @@
-from typing import Any
-from typing import Hashable
-from typing import Mapping
-from typing import Optional
-
-
-def is_ref(item: Optional[Mapping[Hashable, Any]]) -> bool:
-    return isinstance(item, dict) and "$ref" in item and item["$ref"].__hash__