Rust backend

Author: p1c2u

README.rst

@@ -131,6 +131,16 @@ Rules:
 * Set ``0`` to disable the resolved cache.
 * Invalid values (non-integer or negative) fall back to ``128``.
 
+You can also choose schema validator backend:
+
+.. code-block:: bash
+
+    OPENAPI_SPEC_VALIDATOR_SCHEMA_VALIDATOR_BACKEND=auto
+
+Allowed values are ``auto`` (default), ``jsonschema``, and
+``jsonschema-rs``.
+Invalid values raise a warning and fall back to ``auto``.
+
 Related projects
 ################
 

docs/cli.rst

@@ -73,3 +73,7 @@ Performance note:
    You can tune resolved-path caching with
    ``OPENAPI_SPEC_VALIDATOR_RESOLVED_CACHE_MAXSIZE``.
    Default is ``128``; set ``0`` to disable.
+   
+   You can also select schema validator backend with
+   ``OPENAPI_SPEC_VALIDATOR_SCHEMA_VALIDATOR_BACKEND``
+   (``auto``/``jsonschema``/``jsonschema-rs``).

docs/python.rst

@@ -75,3 +75,13 @@ Rules:
 * Default is ``128``.
 * Set ``0`` to disable the resolved cache.
 * Invalid values (non-integer or negative) fall back to ``128``.
+
+Schema validator backend can be selected with:
+
+.. code-block:: bash
+
+   OPENAPI_SPEC_VALIDATOR_SCHEMA_VALIDATOR_BACKEND=auto
+
+Allowed values are ``auto`` (default), ``jsonschema``, and
+``jsonschema-rs``.
+Invalid values raise a warning and fall back to ``auto``.

openapi_spec_validator/schemas/__init__.py

@@ -1,14 +1,61 @@
-"""OpenAIP spec validator schemas module."""
+# openapi_spec_validator/schemas/__init__.py (POC version)
+"""OpenAIP spec validator schemas module - POC with Rust backend support."""
 
 from functools import partial
+from typing import Any
 
 from jsonschema.validators import Draft4Validator
 from jsonschema.validators import Draft202012Validator
 from lazy_object_proxy import Proxy
 
 from openapi_spec_validator.schemas.utils import get_schema_content
+from openapi_spec_validator.settings import get_schema_validator_backend
 
-__all__ = ["schema_v2", "schema_v3", "schema_v30", "schema_v31", "schema_v32"]
+_create_rust_validator_impl: Any = None
+
+# Import Rust adapters
+try:
+    from openapi_spec_validator.schemas.rust_adapters import (
+        create_rust_validator as _create_rust_validator_impl,
+    )
+    from openapi_spec_validator.schemas.rust_adapters import (
+        get_validator_backend,
+    )
+    from openapi_spec_validator.schemas.rust_adapters import (
+        has_rust_validators,
+    )
+
+    _USE_RUST = has_rust_validators()
+except ImportError:
+    _create_rust_validator_impl = None
+    _USE_RUST = False
+
+    def has_rust_validators() -> bool:
+        return False
+
+    def get_validator_backend() -> str:
+        return "python (jsonschema)"
+
+
+_BACKEND_MODE = get_schema_validator_backend()
+
+if _BACKEND_MODE == "jsonschema":
+    _USE_RUST = False
+elif _BACKEND_MODE == "jsonschema-rs" and not _USE_RUST:
+    raise ImportError(
+        "OPENAPI_SPEC_VALIDATOR_SCHEMA_VALIDATOR_BACKEND=jsonschema-rs "
+        "is set but jsonschema-rs is not available. "
+        "Install it with: pip install jsonschema-rs"
+    )
+
+__all__ = [
+    "schema_v2",
+    "schema_v3",
+    "schema_v30",
+    "schema_v31",
+    "schema_v32",
+    "get_validator_backend",
+]
 
 get_schema_content_v2 = partial(get_schema_content, "2.0")
 get_schema_content_v30 = partial(get_schema_content, "3.0")
@@ -23,10 +70,53 @@
 # alias to the latest v3 version
 schema_v3 = schema_v32
 
-get_openapi_v2_schema_validator = partial(Draft4Validator, schema_v2)
-get_openapi_v30_schema_validator = partial(Draft4Validator, schema_v30)
-get_openapi_v31_schema_validator = partial(Draft202012Validator, schema_v31)
-get_openapi_v32_schema_validator = partial(Draft202012Validator, schema_v32)
+
+def _create_rust_schema_validator(
+    schema: dict[str, Any],
+    draft: str,
+) -> Any:
+    if _create_rust_validator_impl is None:
+        raise ImportError(
+            "jsonschema-rs is not available. "
+            "Install it with: pip install jsonschema-rs"
+        )
+    return _create_rust_validator_impl(schema, draft)
+
+
+# Validator factory functions with Rust/Python selection
+def get_openapi_v2_schema_validator() -> Any:
+    """Create OpenAPI 2.0 schema validator (Draft4)."""
+    if _USE_RUST:
+        return _create_rust_schema_validator(dict(schema_v2), draft="draft4")
+    return Draft4Validator(schema_v2)
+
+
+def get_openapi_v30_schema_validator() -> Any:
+    """Create OpenAPI 3.0 schema validator (Draft4)."""
+    if _USE_RUST:
+        return _create_rust_schema_validator(dict(schema_v30), draft="draft4")
+    return Draft4Validator(schema_v30)
+
+
+def get_openapi_v31_schema_validator() -> Any:
+    """Create OpenAPI 3.1 schema validator (Draft 2020-12)."""
+    if _USE_RUST:
+        return _create_rust_schema_validator(
+            dict(schema_v31),
+            draft="draft202012",
+        )
+    return Draft202012Validator(schema_v31)
+
+
+def get_openapi_v32_schema_validator() -> Any:
+    """Create OpenAPI 3.2 schema validator (Draft 2020-12)."""
+    if _USE_RUST:
+        return _create_rust_schema_validator(
+            dict(schema_v32),
+            draft="draft202012",
+        )
+    return Draft202012Validator(schema_v32)
+
 
 openapi_v2_schema_validator = Proxy(get_openapi_v2_schema_validator)
 openapi_v30_schema_validator = Proxy(get_openapi_v30_schema_validator)

openapi_spec_validator/schemas/rust_adapters.py

@@ -0,0 +1,165 @@
+# openapi_spec_validator/schemas/rust_adapters.py
+"""
+Proof-of-Concept: jsonschema-rs adapter for openapi-spec-validator.
+
+This module provides a compatibility layer between jsonschema-rs (Rust)
+and the existing jsonschema (Python) validator interface.
+"""
+
+from typing import Any
+from typing import Iterator
+
+from jsonschema.exceptions import ValidationError as PyValidationError
+
+# Try to import jsonschema-rs
+try:
+    import jsonschema_rs
+
+    HAS_JSONSCHEMA_RS = True
+except ImportError:
+    HAS_JSONSCHEMA_RS = False
+    jsonschema_rs = None  # type: ignore
+
+
+class RustValidatorError(PyValidationError):
+    """ValidationError compatible with jsonschema, but originating from Rust validator."""
+
+    pass
+
+
+class RustValidatorWrapper:
+    """
+    Wrapper that makes jsonschema-rs validator compatible with jsonschema interface.
+
+    This allows drop-in replacement while maintaining the same API surface.
+    """
+
+    def __init__(self, schema: dict[str, Any], validator: Any):
+        """
+        Initialize Rust validator wrapper.
+
+        Args:
+            schema: JSON Schema to validate against
+            cls: JSON Schema validator
+        """
+        if not HAS_JSONSCHEMA_RS:
+            raise ImportError(
+                "jsonschema-rs is not installed. Install it with: "
+                "pip install jsonschema-rs"
+            )
+
+        self.schema = schema
+        self._rs_validator = validator
+
+    def iter_errors(self, instance: Any) -> Iterator[PyValidationError]:
+        """
+        Validate instance and yield errors in jsonschema format.
+
+        This method converts jsonschema-rs errors to jsonschema ValidationError
+        format for compatibility with existing code.
+        """
+        # Try to validate - jsonschema-rs returns ValidationError on failure
+        result = self._rs_validator.validate(instance)
+
+        if result is not None:
+            # result contains validation errors
+            # jsonschema-rs returns an iterator of errors
+            for error in self._rs_validator.iter_errors(instance):
+                yield self._convert_rust_error(error, instance)
+
+    def validate(self, instance: Any) -> None:
+        """
+        Validate instance and raise ValidationError if invalid.
+
+        Compatible with jsonschema Validator.validate() method.
+        """
+        try:
+            self._rs_validator.validate(instance)
+        except jsonschema_rs.ValidationError as e:
+            # Convert and raise as Python ValidationError
+            py_error = self._convert_rust_error_exception(e, instance)
+            raise py_error from e
+
+    def is_valid(self, instance: Any) -> bool:
+        """Check if instance is valid against schema."""
+        return self._rs_validator.is_valid(instance)
+
+    def _convert_rust_error(
+        self, rust_error: Any, instance: Any
+    ) -> PyValidationError:
+        """
+        Convert jsonschema-rs error format to jsonschema ValidationError.
+
+        jsonschema-rs error structure:
+        - message: str
+        - instance_path: list
+        - schema_path: list (if available)
+        """
+        message = str(rust_error)
+
+        # Extract path information if available
+        # Note: jsonschema-rs error format may differ - adjust as needed
+        instance_path = getattr(rust_error, "instance_path", [])
+        schema_path = getattr(rust_error, "schema_path", [])
+
+        return RustValidatorError(
+            message=message,
+            path=list(instance_path) if instance_path else [],
+            schema_path=list(schema_path) if schema_path else [],
+            instance=instance,
+            schema=self.schema,
+        )
+
+    def _convert_rust_error_exception(
+        self, rust_error: "jsonschema_rs.ValidationError", instance: Any
+    ) -> PyValidationError:
+        """Convert jsonschema-rs ValidationError exception to Python format."""
+        message = str(rust_error)
+
+        return RustValidatorError(
+            message=message,
+            instance=instance,
+            schema=self.schema,
+        )
+
+
+def create_rust_validator(
+    schema: dict[str, Any], draft: str = "draft202012"
+) -> RustValidatorWrapper:
+    """
+    Factory function to create Rust-backed validator.
+
+    Args:
+        schema: JSON Schema to validate against
+        draft: JSON Schema draft version
+
+    Returns:
+        RustValidatorWrapper instance
+    """
+
+    # Create appropriate Rust validator based on draft
+    if draft == "draft4":
+        validator = jsonschema_rs.Draft4Validator(schema)
+    elif draft == "draft7":
+        validator = jsonschema_rs.Draft7Validator(schema)
+    elif draft == "draft201909":
+        validator = jsonschema_rs.Draft201909Validator(schema)
+    elif draft == "draft202012":
+        validator = jsonschema_rs.Draft202012Validator(schema)
+    else:
+        raise ValueError(f"Unsupported draft: {draft}")
+
+    return RustValidatorWrapper(schema, validator=validator)
+
+
+# Convenience function to check if Rust validators are available
+def has_rust_validators() -> bool:
+    """Check if jsonschema-rs is available."""
+    return HAS_JSONSCHEMA_RS
+
+
+def get_validator_backend() -> str:
+    """Get current validator backend (rust or python)."""
+    if HAS_JSONSCHEMA_RS:
+        return "rust (jsonschema-rs)"
+    return "python (jsonschema)"