Expose resolved cache

Author: p1c2u

openapi_spec_validator/config.py

@@ -0,0 +1,43 @@
+from pydantic import field_validator
+from pydantic_settings import BaseSettings
+from pydantic_settings import SettingsConfigDict
+
+ENV_PREFIX = "OPENAPI_SPEC_VALIDATOR_"
+RESOLVED_CACHE_MAXSIZE_DEFAULT = 128
+
+
+class OpenAPISpecValidatorSettings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_prefix=ENV_PREFIX,
+        extra="ignore",
+    )
+
+    resolved_cache_maxsize: int = RESOLVED_CACHE_MAXSIZE_DEFAULT
+
+    @field_validator("resolved_cache_maxsize", mode="before")
+    @classmethod
+    def normalize_resolved_cache_maxsize(
+        cls, value: int | str | None
+    ) -> int:
+        if value is None:
+            return RESOLVED_CACHE_MAXSIZE_DEFAULT
+
+        if isinstance(value, int):
+            parsed_value = value
+        elif isinstance(value, str):
+            try:
+                parsed_value = int(value)
+            except ValueError:
+                return RESOLVED_CACHE_MAXSIZE_DEFAULT
+        else:
+            return RESOLVED_CACHE_MAXSIZE_DEFAULT
+
+        if parsed_value < 0:
+            return RESOLVED_CACHE_MAXSIZE_DEFAULT
+
+        return parsed_value
+
+
+def get_resolved_cache_maxsize() -> int:
+    settings = OpenAPISpecValidatorSettings()
+    return settings.resolved_cache_maxsize

openapi_spec_validator/shortcuts.py

@@ -7,6 +7,7 @@
 from jsonschema_path.handlers import all_urls_handler
 from jsonschema_path.typing import Schema
 
+from openapi_spec_validator.config import get_resolved_cache_maxsize
 from openapi_spec_validator.validation import OpenAPIV2SpecValidator
 from openapi_spec_validator.validation import OpenAPIV30SpecValidator
 from openapi_spec_validator.validation import OpenAPIV31SpecValidator
@@ -44,7 +45,11 @@ def validate(
 ) -> None:
     if cls is None:
         cls = get_validator_cls(spec)
-    sp = SchemaPath.from_dict(spec, base_uri=base_uri)
+    sp = SchemaPath.from_dict(
+        spec,
+        base_uri=base_uri,
+        resolved_cache_maxsize=get_resolved_cache_maxsize(),
+    )
     v = cls(sp)
     return v.validate()
 

openapi_spec_validator/validation/validators.py

@@ -12,6 +12,7 @@
 from jsonschema_path.handlers import default_handlers
 from jsonschema_path.paths import SchemaPath
 
+from openapi_spec_validator.config import get_resolved_cache_maxsize
 from openapi_spec_validator.schemas import openapi_v2_schema_validator
 from openapi_spec_validator.schemas import openapi_v30_schema_validator
 from openapi_spec_validator.schemas import openapi_v31_schema_validator
@@ -59,6 +60,7 @@ def __init__(
                 self.schema,
                 base_uri=self.base_uri,
                 handlers=self.resolver_handlers,
+                resolved_cache_maxsize=get_resolved_cache_maxsize(),
             )
 
         self.keyword_validators_registry = KeywordValidatorRegistry(

poetry.lock

@@ -28,6 +28,7 @@ dependencies = [
     "openapi-schema-validator >=0.7.3,<0.9.0",
     "jsonschema-path >=0.4.3,<0.5.0",
     "lazy-object-proxy >=1.7.1,<2.0",
+    "pydantic-settings (>=2.10.1,<3.0.0)",
 ]
 
 [project.urls]

pyproject.toml

@@ -21,13 +21,11 @@
 from pathlib import Path
 from typing import Any
 
-from jsonschema_path import SchemaPath
 from jsonschema_path.typing import Schema
 
 from openapi_spec_validator import schemas
 from openapi_spec_validator import validate
 from openapi_spec_validator.readers import read_from_filename
-from openapi_spec_validator.shortcuts import get_validator_cls
 
 
 @dataclass
@@ -110,11 +108,7 @@ def get_spec_version(spec: Schema) -> str:
 def run_once(spec: Schema) -> float:
     """Run validation once and return elapsed time."""
     t0 = time.perf_counter()
-    cls = get_validator_cls(spec)
-    sp = SchemaPath.from_dict(spec)
-    v = cls(sp)
-    v.validate()
-    # validate(spec)
+    validate(spec)
     return time.perf_counter() - t0
 
 
@@ -271,8 +265,8 @@ def get_synthetic_specs_iterator(
     configs: list[tuple[int, int, str]],
 ) -> Iterator[tuple[dict[str, Any], str, float]]:
     """Iterator over synthetic specs based on provided configurations."""
-    for paths, schemas, size in configs:
-        spec = generate_synthetic_spec(paths, schemas)
+    for paths, schema_count, size in configs:
+        spec = generate_synthetic_spec(paths, schema_count)
         yield spec, f"synthetic_{size}", 0
 
 
@@ -348,7 +342,10 @@ def main():
         results.append(result.as_dict())
         if result.success:
             print(
-                f"   ✅ {result.median_s:.4f}s, {result.validations_per_sec:.2f} val/s"
+                "   ✅ {:.4f}s, {:.2f} val/s".format(
+                    result.median_s,
+                    result.validations_per_sec,
+                )
             )
         else:
             print(f"   ❌ Error: {result.error}")

tests/bench/runner.py

@@ -7,10 +7,12 @@
 from openapi_spec_validator import openapi_v2_spec_validator
 from openapi_spec_validator import openapi_v30_spec_validator
 from openapi_spec_validator import openapi_v32_spec_validator
+from openapi_spec_validator import shortcuts as shortcuts_module
 from openapi_spec_validator import validate
 from openapi_spec_validator import validate_spec
 from openapi_spec_validator import validate_spec_url
 from openapi_spec_validator import validate_url
+from openapi_spec_validator.config import RESOLVED_CACHE_MAXSIZE_DEFAULT
 from openapi_spec_validator.validation.exceptions import OpenAPIValidationError
 from openapi_spec_validator.validation.exceptions import ValidatorDetectError
 
@@ -23,6 +25,56 @@ def test_spec_schema_version_not_detected(self):
             validate(spec)
 
 
+def test_validate_uses_resolved_cache_maxsize_env(monkeypatch):
+    captured: dict[str, int] = {}
+    original_from_dict = shortcuts_module.SchemaPath.from_dict
+    spec = {
+        "openapi": "3.0.0",
+        "info": {"title": "Test API", "version": "0.0.1"},
+        "paths": {},
+    }
+
+    def fake_from_dict(cls, *args, **kwargs):
+        captured["resolved_cache_maxsize"] = kwargs["resolved_cache_maxsize"]
+        return original_from_dict(*args, **kwargs)
+
+    monkeypatch.setenv("OPENAPI_SPEC_VALIDATOR_RESOLVED_CACHE_MAXSIZE", "256")
+    monkeypatch.setattr(
+        shortcuts_module.SchemaPath,
+        "from_dict",
+        classmethod(fake_from_dict),
+    )
+
+    validate(spec, cls=OpenAPIV30SpecValidator)
+
+    assert captured["resolved_cache_maxsize"] == 256
+
+
+def test_validate_uses_default_resolved_cache_on_invalid_env(monkeypatch):
+    captured: dict[str, int] = {}
+    original_from_dict = shortcuts_module.SchemaPath.from_dict
+    spec = {
+        "openapi": "3.0.0",
+        "info": {"title": "Test API", "version": "0.0.1"},
+        "paths": {},
+    }
+
+    def fake_from_dict(cls, *args, **kwargs):
+        captured["resolved_cache_maxsize"] = kwargs["resolved_cache_maxsize"]
+        return original_from_dict(*args, **kwargs)
+
+    monkeypatch.setenv("OPENAPI_SPEC_VALIDATOR_RESOLVED_CACHE_MAXSIZE", "-1")
+    monkeypatch.setattr(
+        shortcuts_module.SchemaPath,
+        "from_dict",
+        classmethod(fake_from_dict),
+    )
+
+    validate(spec, cls=OpenAPIV30SpecValidator)
+
+    assert captured["resolved_cache_maxsize"] == RESOLVED_CACHE_MAXSIZE_DEFAULT
+
+
 class TestLocalValidateSpecUrl:
     def test_spec_schema_version_not_detected(self, factory):
         spec_path = "data/empty.yaml"

tests/integration/test_shortcuts.py

@@ -6,6 +6,8 @@
 from openapi_spec_validator import OpenAPIV30SpecValidator
 from openapi_spec_validator import OpenAPIV31SpecValidator
 from openapi_spec_validator import OpenAPIV32SpecValidator
+from openapi_spec_validator.config import RESOLVED_CACHE_MAXSIZE_DEFAULT
+from openapi_spec_validator.validation import validators as validators_module
 from openapi_spec_validator.validation.exceptions import OpenAPIValidationError
 
 
@@ -67,6 +69,60 @@ def test_ref_failed(self, factory, spec_file):
             OpenAPIV2SpecValidator(spec, base_uri=spec_url).validate()
 
 
+def test_spec_validator_uses_resolved_cache_maxsize_env(monkeypatch):
+    captured: dict[str, int] = {}
+    original_from_dict = validators_module.SchemaPath.from_dict
+
+    def fake_from_dict(cls, *args, **kwargs):
+        captured["resolved_cache_maxsize"] = kwargs["resolved_cache_maxsize"]
+        return original_from_dict(*args, **kwargs)
+
+    monkeypatch.setenv("OPENAPI_SPEC_VALIDATOR_RESOLVED_CACHE_MAXSIZE", "64")
+    monkeypatch.setattr(
+        validators_module.SchemaPath,
+        "from_dict",
+        classmethod(fake_from_dict),
+    )
+
+    OpenAPIV30SpecValidator(
+        {
+            "openapi": "3.0.0",
+            "info": {"title": "Test API", "version": "0.0.1"},
+            "paths": {},
+        }
+    )
+
+    assert captured["resolved_cache_maxsize"] == 64
+
+
+def test_spec_validator_uses_default_resolved_cache_on_invalid_env(
+    monkeypatch,
+):
+    captured: dict[str, int] = {}
+    original_from_dict = validators_module.SchemaPath.from_dict
+
+    def fake_from_dict(cls, *args, **kwargs):
+        captured["resolved_cache_maxsize"] = kwargs["resolved_cache_maxsize"]
+        return original_from_dict(*args, **kwargs)
+
+    monkeypatch.setenv("OPENAPI_SPEC_VALIDATOR_RESOLVED_CACHE_MAXSIZE", "bad")
+    monkeypatch.setattr(
+        validators_module.SchemaPath,
+        "from_dict",
+        classmethod(fake_from_dict),
+    )
+
+    OpenAPIV30SpecValidator(
+        {
+            "openapi": "3.0.0",
+            "info": {"title": "Test API", "version": "0.0.1"},
+            "paths": {},
+        }
+    )
+
+    assert captured["resolved_cache_maxsize"] == RESOLVED_CACHE_MAXSIZE_DEFAULT
+
+
 class TestLocalOpenAPIv30Validator:
     LOCAL_SOURCE_DIRECTORY = "data/v3.0/"