json-repair 0.55.2__py3-none-any.whl → 0.56.0__py3-none-any.whl

json_repair/parse_object.py

@@ -1,16 +1,63 @@
-from typing import TYPE_CHECKING
+import re
+from typing import TYPE_CHECKING, Any
 
-from .utils.constants import STRING_DELIMITERS, JSONReturnType
+from .utils.constants import MISSING_VALUE, STRING_DELIMITERS, JSONReturnType
 from .utils.json_context import ContextValues
 
 if TYPE_CHECKING:
     from .json_parser import JSONParser
+    from .schema_repair import SchemaRepairer
 
 
-def parse_object(self: "JSONParser") -> JSONReturnType:
+def parse_object(
+    self: "JSONParser",
+    schema: dict[str, Any] | bool | None = None,
+    path: str = "$",
+) -> JSONReturnType:
     # <object> ::= '{' [ <member> *(', ' <member>) ] '}' ; A sequence of 'members'
     obj: dict[str, JSONReturnType] = {}
     start_index = self.index
+
+    # Only activate schema-guided parsing if a repairer is available and schema looks object-like.
+    schema_repairer: SchemaRepairer | None = None
+    properties: dict[str, Any] = {}
+    pattern_properties: dict[str, Any] = {}
+    additional_properties: object | None = None
+    required: set[str] = set()
+
+    if schema is not None and schema is not True:
+        repairer = self.schema_repairer
+        if repairer is not None:
+            schema = repairer.resolve_schema(schema)
+            if schema is False:
+                raise ValueError("Schema does not allow any values.")
+            if schema is not True and repairer.is_object_schema(schema):
+                schema_repairer = repairer
+                properties = schema.get("properties", {})
+                if not isinstance(properties, dict):
+                    properties = {}
+                pattern_properties = schema.get("patternProperties", {})
+                if not isinstance(pattern_properties, dict):
+                    pattern_properties = {}
+                additional_properties = schema.get("additionalProperties", None)
+                required = set(schema.get("required", []))
+
+    def finalize_obj() -> dict[str, JSONReturnType]:
+        if schema_repairer is None:
+            return obj
+        schema_repairer_local = schema_repairer
+        # Enforce required fields and insert defaults for optional properties.
+        missing_required = [key for key in required if key not in obj]
+        if missing_required:
+            raise ValueError(f"Missing required properties at {path}: {', '.join(missing_required)}")
+        for key, prop_schema in properties.items():
+            if key in obj or key in required:
+                continue
+            if isinstance(prop_schema, dict) and "default" in prop_schema:
+                obj[key] = schema_repairer_local._copy_json_value(prop_schema["default"], f"{path}.{key}", "default")
+                schema_repairer_local._log("Inserted default value for missing property", f"{path}.{key}")
+        return obj
+
     # Stop when you either find the closing parentheses or you have iterated over the entire string
     while (self.get_char_at() or "}") != "}":
         # This is what we expect to find:
@@ -145,21 +192,71 @@ def parse_object(self: "JSONParser") -> JSONReturnType:
         self.skip_whitespaces()
         # Corner case, a lone comma
         value: JSONReturnType = ""
+        prop_schema: dict[str, Any] | bool | None = None
+        extra_schemas: list[dict[str, Any] | bool | None] = []
+        drop_property = False
+
+        if schema_repairer is not None:
+            if key in properties:
+                schema_value = properties[key]
+                # Schema entries must be dict/bool; reject invalid metadata early.
+                if schema_value is not None and not isinstance(schema_value, (dict, bool)):
+                    raise ValueError("Schema must be an object.")
+                prop_schema = schema_value
+            else:
+                matched = [
+                    schema_value for pattern, schema_value in pattern_properties.items() if re.search(pattern, key)
+                ]
+                if matched:
+                    # patternProperties can stack: apply the first schema, then any extras in order.
+                    primary_schema = matched[0]
+                    if primary_schema is not None and not isinstance(primary_schema, (dict, bool)):
+                        raise ValueError("Schema must be an object.")
+                    prop_schema = primary_schema
+                    for extra_schema in matched[1:]:
+                        if extra_schema is not None and not isinstance(extra_schema, (dict, bool)):
+                            raise ValueError("Schema must be an object.")
+                        extra_schemas.append(extra_schema)
+                else:
+                    if additional_properties is False:
+                        # Schema forbids unknown keys: parse but drop this property.
+                        drop_property = True
+                    elif isinstance(additional_properties, dict):
+                        prop_schema = additional_properties
+                    else:
+                        prop_schema = True
+
         char = self.get_char_at()
+        key_path = f"{path}.{key}"
         if char in [",", "}"]:
             self.log(
                 f"While parsing an object value we found a stray {char}, ignoring it",
             )
+            if schema_repairer is not None:
+                # Missing value: fill according to schema (defaults/const/enum/type).
+                value = schema_repairer.repair_value(MISSING_VALUE, prop_schema, key_path)
         else:
-            value = self.parse_json()
-        if value == "" and self.strict and self.get_char_at(-1) not in STRING_DELIMITERS:
+            # Schema-aware parsing guides repairs inside nested values.
+            value = self.parse_json(prop_schema, key_path) if schema_repairer is not None else self.parse_json()
+
+        if schema_repairer is not None and extra_schemas:
+            # Apply any additional pattern schemas in order.
+            for extra_schema in extra_schemas:
+                value = schema_repairer.repair_value(value, extra_schema, key_path)
+
+        if schema_repairer is None and value == "" and self.strict and self.get_char_at(-1) not in STRING_DELIMITERS:
             self.log(
                 "Parsed value is empty in strict mode while parsing object, raising an error",
             )
             raise ValueError("Parsed value is empty in strict mode while parsing object.")
+
         # Reset context since our job is done
         self.context.reset()
-        obj[key] = value
+        if schema_repairer is None or not drop_property:
+            obj[key] = value
+        else:
+            # Keep parsing but omit forbidden properties to respect the schema.
+            schema_repairer._log("Dropped extra property not covered by schema", key_path)
 
         if self.get_char_at() in [",", "'", '"']:
             self.index += 1
@@ -204,17 +301,17 @@ def parse_object(self: "JSONParser") -> JSONReturnType:
 
     self.skip_whitespaces()
     if self.get_char_at() != ",":
-        return obj
+        return finalize_obj()
     self.index += 1
     self.skip_whitespaces()
     if self.get_char_at() not in STRING_DELIMITERS:
-        return obj
+        return finalize_obj()
     if not self.strict:
         self.log(
             "Found a comma and string delimiter after object closing brace, checking for additional key-value pairs",
         )
-        additional_obj = self.parse_object()
+        additional_obj = self.parse_object(schema, path)
         if isinstance(additional_obj, dict):
             obj.update(additional_obj)
 
-    return obj
+    return finalize_obj()

json_repair/schema_repair.py

@@ -0,0 +1,508 @@
+from __future__ import annotations
+
+import copy
+import importlib
+import re
+from types import ModuleType
+from typing import Any
+
+from .utils.constants import MISSING_VALUE, JSONReturnType, MissingValueType
+
+
+def _require_jsonschema() -> Any:
+    try:
+        return importlib.import_module("jsonschema")
+    except ImportError as exc:  # pragma: no cover - optional dependency
+        raise ValueError("jsonschema is required when using schema-aware repair.") from exc
+
+
+def _require_pydantic() -> Any:
+    try:
+        return importlib.import_module("pydantic")
+    except ImportError as exc:  # pragma: no cover - optional dependency
+        raise ValueError("pydantic is required when using schema models.") from exc
+
+
+def load_schema_model(path: str) -> type[Any]:
+    if ":" not in path:
+        raise ValueError("Schema model must be in the form 'module:ClassName'.")
+    module_name, class_name = path.split(":", 1)
+    module: ModuleType = importlib.import_module(module_name)
+    model: object | None = module.__dict__.get(class_name)
+    if model is None or not isinstance(model, type):
+        raise ValueError(f"Schema model '{class_name}' not found in module '{module_name}'.")
+    return model
+
+
+def normalize_missing_values(value: object) -> JSONReturnType:
+    if value is MISSING_VALUE or isinstance(value, MissingValueType):
+        return ""
+    if isinstance(value, dict):
+        normalized: dict[str, JSONReturnType] = {}
+        for key, item in value.items():
+            if not isinstance(key, str):
+                raise ValueError("Object keys must be strings.")
+            normalized[key] = normalize_missing_values(item)
+        return normalized
+    if isinstance(value, list):
+        return [normalize_missing_values(item) for item in value]
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    raise ValueError("Value is not JSON compatible.")
+
+
+def schema_from_input(schema: Any) -> dict[str, Any] | bool:
+    if isinstance(schema, dict):
+        return schema
+    if schema is True or schema is False:
+        return schema
+    if hasattr(schema, "model_json_schema"):
+        pydantic = _require_pydantic()
+        version = getattr(pydantic, "VERSION", getattr(pydantic, "__version__", "0"))
+        if int(version.split(".")[0]) < 2:
+            raise ValueError("pydantic v2 is required for schema models.")
+        schema_dict: dict[str, Any] = schema.model_json_schema()
+        if hasattr(schema, "model_fields"):
+            properties = schema_dict.setdefault("properties", {})
+            if not isinstance(properties, dict):
+                properties = {}
+                schema_dict["properties"] = properties
+            for name, field in schema.model_fields.items():
+                if field.is_required():
+                    continue
+                property_schema = properties.setdefault(name, {})
+                if not isinstance(property_schema, dict):
+                    property_schema = {}
+                    properties[name] = property_schema
+                if "default" in property_schema:
+                    continue
+                if field.default_factory is not None:
+                    property_schema["default"] = field.default_factory()
+                else:
+                    property_schema["default"] = field.default
+        return schema_dict
+    raise ValueError("Schema must be a JSON Schema dict, boolean schema, or pydantic v2 model.")
+
+
+class SchemaRepairer:
+    def __init__(self, schema: dict[str, Any] | bool, log: list[dict[str, str]] | None) -> None:
+        self.root_schema = schema
+        self.log = log
+
+    def _log(self, text: str, path: str) -> None:
+        if self.log is not None:
+            self.log.append({"text": text, "context": path})
+
+    def validate(self, value: JSONReturnType, schema: dict[str, Any] | bool) -> None:
+        schema = self.resolve_schema(schema)
+        if schema is True:
+            return
+        if schema is False:
+            raise ValueError("Schema does not allow any values.")
+        schema_for_validation = self._prepare_schema_for_validation(schema)
+        jsonschema = _require_jsonschema()
+        validator_cls = jsonschema.validators.validator_for(schema_for_validation)
+        validator = validator_cls(schema_for_validation)
+        errors = sorted(validator.iter_errors(value), key=lambda e: e.path)
+        if errors:
+            raise ValueError(errors[0].message)
+
+    def resolve_schema(self, schema: object | None) -> dict[str, Any] | bool:
+        if schema is None:
+            return True
+        if isinstance(schema, bool):
+            return schema
+        if not isinstance(schema, dict):
+            raise ValueError("Schema must be an object.")
+        schema_dict: dict[str, Any] = {}
+        for key, value in schema.items():
+            if not isinstance(key, str):
+                raise ValueError("Schema keys must be strings.")
+            schema_dict[key] = value
+        while "$ref" in schema_dict:
+            ref = schema_dict["$ref"]
+            resolved = self._resolve_ref(ref)
+            if isinstance(resolved, bool):
+                return resolved
+            schema_dict = resolved
+        return schema_dict
+
+    def is_object_schema(self, schema: dict[str, Any] | bool | None) -> bool:
+        schema = self.resolve_schema(schema)
+        if not isinstance(schema, dict):
+            return False
+        schema_type = schema.get("type")
+        if schema_type == "object":
+            return True
+        if isinstance(schema_type, list) and "object" in schema_type:
+            return True
+        return any(key in schema for key in ("properties", "patternProperties", "additionalProperties", "required"))
+
+    def is_array_schema(self, schema: dict[str, Any] | bool | None) -> bool:
+        schema = self.resolve_schema(schema)
+        if not isinstance(schema, dict):
+            return False
+        schema_type = schema.get("type")
+        if schema_type == "array":
+            return True
+        if isinstance(schema_type, list) and "array" in schema_type:
+            return True
+        return "items" in schema
+
+    def repair_value(self, value: Any, schema: dict[str, Any] | bool | None, path: str) -> JSONReturnType:
+        """Apply schema rules to a parsed value, including unions, coercions, and defaults."""
+        schema = self.resolve_schema(schema)
+        if schema is True:
+            return normalize_missing_values(value)
+        if schema is False:
+            raise ValueError("Schema does not allow any values.")
+        if not schema:
+            return normalize_missing_values(value)
+
+        if value is MISSING_VALUE:
+            return self._fill_missing(schema, path)
+
+        if "allOf" in schema:
+            subschemas = schema["allOf"]
+            if not subschemas:
+                return normalize_missing_values(value)
+            repaired = self.repair_value(value, subschemas[0], path)
+            for subschema in subschemas[1:]:
+                repaired = self.repair_value(repaired, subschema, path)
+            return repaired
+
+        if "oneOf" in schema:
+            return self._repair_union(value, schema["oneOf"], path)
+        if "anyOf" in schema:
+            return self._repair_union(value, schema["anyOf"], path)
+
+        expected_type = schema.get("type")
+        if expected_type is None:
+            if self.is_object_schema(schema):
+                expected_type = "object"
+            elif self.is_array_schema(schema):
+                expected_type = "array"
+
+        if isinstance(expected_type, list):
+            return self._repair_type_union(value, expected_type, schema, path)
+
+        if expected_type == "object":
+            repaired = self._repair_object(value, schema, path)
+        elif expected_type == "array":
+            repaired = self._repair_array(value, schema, path)
+        elif isinstance(expected_type, str):
+            repaired = self._coerce_scalar(value, expected_type, path)
+        else:
+            repaired = normalize_missing_values(value)
+
+        return self._apply_enum_const(repaired, schema, path)
+
+    def _repair_union(self, value: Any, schemas: list[dict[str, Any] | bool], path: str) -> JSONReturnType:
+        last_error: Exception | None = None
+        for subschema in schemas:
+            try:
+                candidate = self.repair_value(copy.deepcopy(value), subschema, path)
+                self.validate(candidate, subschema)
+                return candidate
+            except ValueError as exc:
+                last_error = exc
+        if last_error:
+            raise ValueError(str(last_error)) from last_error
+        raise ValueError("No schema matched the value.")
+
+    def _repair_type_union(
+        self,
+        value: Any,
+        types: list[str],
+        schema: dict[str, Any],
+        path: str,
+    ) -> JSONReturnType:
+        last_error: Exception | None = None
+        for schema_type in types:
+            try:
+                candidate = self._repair_by_type(value, schema_type, schema, path)
+                return self._apply_enum_const(candidate, schema, path)
+            except ValueError as exc:
+                last_error = exc
+        if last_error:
+            raise ValueError(str(last_error)) from last_error
+        raise ValueError("No schema type matched the value.")
+
+    def _repair_by_type(self, value: Any, schema_type: str, schema: dict[str, Any], path: str) -> JSONReturnType:
+        if schema_type == "array":
+            return self._repair_array(value, schema, path)
+        if schema_type == "object":
+            return self._repair_object(value, schema, path)
+        return self._coerce_scalar(value, schema_type, path)
+
+    def _repair_array(self, value: Any, schema: dict[str, Any], path: str) -> JSONReturnType:
+        if isinstance(value, list):
+            items: list[JSONReturnType] = value
+        else:
+            self._log("Wrapped value in array to match schema", path)
+            items = [normalize_missing_values(value)]
+        items_schema = schema.get("items")
+        if items_schema is not None:
+            if isinstance(items_schema, list):
+                repaired_items: list[JSONReturnType] = []
+                for idx, item_schema in enumerate(items_schema):
+                    if idx >= len(items):
+                        break
+                    repaired_items.append(self.repair_value(items[idx], item_schema, f"{path}[{idx}]"))
+                additional_items = schema.get("additionalItems")
+                if len(items) > len(items_schema):
+                    tail = items[len(items_schema) :]
+                    if isinstance(additional_items, dict):
+                        for offset, item in enumerate(tail, start=len(items_schema)):
+                            repaired_items.append(self.repair_value(item, additional_items, f"{path}[{offset}]"))
+                    elif additional_items is True or additional_items is None:
+                        repaired_items.extend(normalize_missing_values(item) for item in tail)
+                    else:
+                        for offset, _item in enumerate(tail, start=len(items_schema)):
+                            self._log("Dropped extra array item not covered by schema", f"{path}[{offset}]")
+                items = repaired_items
+            else:
+                items = [self.repair_value(item, items_schema, f"{path}[{idx}]") for idx, item in enumerate(items)]
+        min_items = schema.get("minItems")
+        if min_items is not None and len(items) < min_items:
+            raise ValueError(f"Array at {path} does not meet minItems.")
+        return items
+
+    def _repair_object(self, value: Any, schema: dict[str, Any], path: str) -> JSONReturnType:
+        if not isinstance(value, dict):
+            raise ValueError(f"Expected object at {path}, got {type(value).__name__}.")
+
+        properties = schema.get("properties", {})
+        if not isinstance(properties, dict):
+            properties = {}
+        required = set(schema.get("required", []))
+        pattern_properties = schema.get("patternProperties", {})
+        if not isinstance(pattern_properties, dict):
+            pattern_properties = {}
+        additional_properties = schema.get("additionalProperties")
+
+        missing_required = [key for key in required if key not in value]
+        if missing_required:
+            raise ValueError(f"Missing required properties at {path}: {', '.join(missing_required)}")
+
+        repaired: dict[str, JSONReturnType] = {}
+
+        for key, prop_schema in properties.items():
+            key_path = f"{path}.{key}"
+            if key in value:
+                repaired[key] = self.repair_value(value[key], prop_schema, key_path)
+            elif isinstance(prop_schema, dict) and "default" in prop_schema and key not in required:
+                repaired[key] = self._copy_json_value(prop_schema["default"], key_path, "default")
+                self._log("Inserted default value for missing property", key_path)
+
+        for key, raw_value in value.items():
+            if key in properties:
+                continue
+            key_path = f"{path}.{key}"
+            matched = [prop_schema for pattern, prop_schema in pattern_properties.items() if re.search(pattern, key)]
+            if matched:
+                repaired_value = self.repair_value(raw_value, matched[0], key_path)
+                for prop_schema in matched[1:]:
+                    repaired_value = self.repair_value(repaired_value, prop_schema, key_path)
+                repaired[key] = repaired_value
+                continue
+            if isinstance(additional_properties, dict):
+                repaired[key] = self.repair_value(raw_value, additional_properties, key_path)
+                continue
+            if additional_properties is True or additional_properties is None:
+                repaired[key] = normalize_missing_values(raw_value)
+                continue
+            self._log("Dropped extra property not covered by schema", key_path)
+
+        min_properties = schema.get("minProperties")
+        if min_properties is not None and len(repaired) < min_properties:
+            raise ValueError(f"Object at {path} does not meet minProperties.")
+        return repaired
+
+    def _fill_missing(self, schema: dict[str, Any], path: str) -> JSONReturnType:
+        if "const" in schema:
+            # Const/enum/default have priority over type inference.
+            self._log("Filled missing value with const", path)
+            return self._copy_json_value(schema["const"], path, "const")
+        if "enum" in schema:
+            enum_values = schema["enum"]
+            if not enum_values:
+                raise ValueError(f"Enum at {path} has no values.")
+            self._log("Filled missing value with first enum value", path)
+            return self._copy_json_value(enum_values[0], path, "enum")
+        if "default" in schema:
+            self._log("Filled missing value with default", path)
+            return self._copy_json_value(schema["default"], path, "default")
+
+        expected_type = schema.get("type")
+        if isinstance(expected_type, list):
+            for schema_type in expected_type:
+                try:
+                    return self._fill_missing({**schema, "type": schema_type}, path)
+                except ValueError:
+                    continue
+            raise ValueError(f"Cannot infer missing value at {path}.")
+
+        if expected_type is None:
+            # Infer container types based on schema shape if type is omitted.
+            if self.is_object_schema(schema):
+                expected_type = "object"
+            elif self.is_array_schema(schema):
+                expected_type = "array"
+
+        if expected_type == "string":
+            self._log("Filled missing value with empty string", path)
+            return ""
+        if expected_type in ("integer", "number"):
+            self._log("Filled missing value with 0", path)
+            return 0
+        if expected_type == "boolean":
+            self._log("Filled missing value with false", path)
+            return False
+        if expected_type == "array":
+            min_items = schema.get("minItems")
+            if min_items:
+                raise ValueError(f"Array at {path} requires at least {min_items} items.")
+            self._log("Filled missing value with empty array", path)
+            return []
+        if expected_type == "object":
+            min_properties = schema.get("minProperties")
+            if min_properties:
+                raise ValueError(f"Object at {path} requires at least {min_properties} properties.")
+            self._log("Filled missing value with empty object", path)
+            return {}
+        if expected_type == "null":
+            self._log("Filled missing value with null", path)
+            return None
+
+        raise ValueError(f"Cannot infer missing value at {path}.")
+
+    def _coerce_scalar(self, value: Any, schema_type: str, path: str) -> JSONReturnType:
+        if schema_type == "string":
+            if isinstance(value, str):
+                return value
+            if isinstance(value, (int, float)) and not isinstance(value, bool):
+                self._log("Coerced number to string", path)
+                return str(value)
+            raise ValueError(f"Expected string at {path}.")
+
+        if schema_type == "integer":
+            if isinstance(value, bool):
+                raise ValueError(f"Expected integer at {path}.")
+            if isinstance(value, int):
+                return value
+            if isinstance(value, float):
+                if value.is_integer():
+                    self._log("Coerced number to integer", path)
+                    return int(value)
+                raise ValueError(f"Expected integer at {path}.")
+            if isinstance(value, str):
+                try:
+                    int_value = int(value)
+                except ValueError:
+                    int_value = None
+                if int_value is not None:
+                    self._log("Coerced string to integer", path)
+                    return int_value
+                try:
+                    num = float(value)
+                except ValueError as exc:
+                    raise ValueError(f"Expected integer at {path}.") from exc
+                if not num.is_integer():
+                    raise ValueError(f"Expected integer at {path}.")
+                self._log("Coerced number to integer", path)
+                return int(num)
+            raise ValueError(f"Expected integer at {path}.")
+
+        if schema_type == "number":
+            if isinstance(value, bool):
+                raise ValueError(f"Expected number at {path}.")
+            if isinstance(value, (int, float)):
+                return value
+            if isinstance(value, str):
+                try:
+                    float_value = float(value)
+                except ValueError as exc:
+                    raise ValueError(f"Expected number at {path}.") from exc
+                self._log("Coerced string to number", path)
+                return float_value
+            raise ValueError(f"Expected number at {path}.")
+
+        if schema_type == "boolean":
+            if isinstance(value, bool):
+                return value
+            if isinstance(value, str):
+                lowered = value.lower()
+                if lowered in ("true", "false"):
+                    self._log("Coerced string to boolean", path)
+                    return lowered == "true"
+            raise ValueError(f"Expected boolean at {path}.")
+
+        if schema_type == "null":
+            if value is None:
+                return None
+            raise ValueError(f"Expected null at {path}.")
+
+        raise ValueError(f"Unsupported schema type {schema_type} at {path}.")
+
+    def _apply_enum_const(self, value: JSONReturnType, schema: dict[str, Any], path: str) -> JSONReturnType:
+        if "const" in schema and value != schema["const"]:
+            raise ValueError(f"Value at {path} does not match const.")
+        if "enum" in schema and value not in schema["enum"]:
+            raise ValueError(f"Value at {path} does not match enum.")
+        return value
+
+    def _resolve_ref(self, ref: str) -> dict[str, Any] | bool:
+        if not ref.startswith("#/"):
+            raise ValueError(f"Unsupported $ref: {ref}")
+        parts = ref.lstrip("#/").split("/")
+        current: Any = self.root_schema
+        for part in parts:
+            resolved_part = part.replace("~1", "/").replace("~0", "~")
+            if not isinstance(current, dict) or resolved_part not in current:
+                raise ValueError(f"Unresolvable $ref: {ref}")
+            current = current[resolved_part]
+        if isinstance(current, dict):
+            return current
+        if current is True:
+            return True
+        if current is False:
+            return False
+        raise ValueError(f"Unresolvable $ref: {ref}")
+
+    def _copy_json_value(self, value: Any, path: str, label: str) -> JSONReturnType:
+        if value is None or isinstance(value, (str, int, float, bool)):
+            return value
+        if isinstance(value, list):
+            return [self._copy_json_value(item, f"{path}[{idx}]", label) for idx, item in enumerate(value)]
+        if isinstance(value, dict):
+            copied: dict[str, JSONReturnType] = {}
+            for key, item in value.items():
+                if not isinstance(key, str):
+                    raise ValueError(f"{label.capitalize()} value at {path} contains a non-string key.")
+                copied[key] = self._copy_json_value(item, f"{path}.{key}", label)
+            return copied
+        raise ValueError(f"{label.capitalize()} value at {path} is not JSON compatible.")
+
+    def _prepare_schema_for_validation(self, schema: object) -> dict[str, Any]:
+        def normalize(node: Any) -> Any:
+            if isinstance(node, dict):
+                normalized = {key: normalize(value) for key, value in node.items()}
+                items = normalized.get("items")
+                if isinstance(items, list):
+                    normalized.pop("items", None)
+                    normalized["prefixItems"] = items
+                    additional_items = normalized.pop("additionalItems", None)
+                    if additional_items is False:
+                        normalized["items"] = False
+                    elif isinstance(additional_items, dict):
+                        normalized["items"] = additional_items
+                return normalized
+            if isinstance(node, list):
+                return [normalize(item) for item in node]
+            return node
+
+        normalized = normalize(schema)
+        if not isinstance(normalized, dict):
+            raise ValueError("Schema must be an object.")
+        return normalized

json_repair/utils/constants.py

@@ -1,4 +1,15 @@
 from typing import Any
 
+
+class MissingValueType:
+    def __repr__(self) -> str:
+        return "<MISSING_VALUE>"
+
+    def __deepcopy__(self, memo: dict[int, Any]) -> "MissingValueType":
+        return self
+
+
+MISSING_VALUE = MissingValueType()
+
 JSONReturnType = dict[str, Any] | list[Any] | str | float | int | bool | None
 STRING_DELIMITERS: list[str] = ['"', "'", "“", "”"]