pydantic-core 2.46.4: pydantic_core.SchemaSerializer, pydantic_core.SchemaValidator, pydantic_core.ValidationError

# Pydantic Core Schema Validation, Serialization, and Error Handling

## Prior Solution Found
`search_known_solution` returned `NO_SAFE_MATCH` for `pkg:pypi/pydantic-core@2.46.4`.

This sample proves core validation and serialization mechanisms of `pydantic-core`:
- `pydantic_core.SchemaValidator`: Schema-driven data validation with lax type coercion and strict type enforcement (`strict=True`).
- Direct JSON parsing and validation in Rust via `validate_json(bytes)` without intermediate Python dict conversion.
- Runtime validation context injection (`info.context`) and custom domain errors via `PydanticCustomError`.
- `pydantic_core.ValidationError`: Multi-error aggregation, location paths, error counts, and formatted diagnostics.
- `pydantic_core.SchemaSerializer`: Model exporting to Python dictionaries and UTF-8 JSON bytes with field exclusions.
- Standalone Rust-accelerated JSON encoding/decoding utilities (`to_json` / `from_json`).

## What a Model Would Have Written
A model attempting to use `pydantic_core` directly might try instantiating Pydantic V2 BaseModel classes (which live in `pydantic`, not `pydantic_core`), pass invalid signature arguments to `with_info_plain_validator_function` or `core_schema` helpers, or assume `validate_python` always enforces strict type checking by default.

## How the Wrong Version Fails
Fails at runtime with `TypeError` when passing unexpected arguments to `core_schema` functions, `ValidationError` when strict mode isn't explicitly configured for exact type checking, or `AttributeError` when expecting high-level Pydantic BaseModel interfaces instead of the underlying `SchemaValidator` and `SchemaSerializer` primitives.

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify pkg:pypi/pydantic-core@2.46.4
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:pypi/pydantic-core@2.46.4
Demonstrate these symbols/APIs:
  - pydantic_core.SchemaSerializer
  - pydantic_core.SchemaValidator
  - pydantic_core.ValidationError

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:2603af02bb2c606e92c8a3ed0bca016aa4ca813bc01663e395580b7492dd955d","contract":["assert SchemaValidator validates structured python dicts against typed_dict core schema","assert SchemaValidator coerces lax types and enforces strict type checking when strict=True","assert SchemaValidator validates raw JSON bytes directly via Rust engine","assert SchemaValidator passes runtime validation context and raises PydanticCustomError","assert ValidationError aggregates multi-field failures with structured error locations and types","assert SchemaSerializer exports validated records to python dicts and JSON bytes with field exclusions","assert SchemaSerializer formats output with indentation","assert to_json and from_json perform direct Rust-accelerated JSON encoding and decoding"],"goal":"verify pkg:pypi/pydantic-core@2.46.4","kind":"HOW","packages":["pkg:pypi/pydantic-core@2.46.4"],"schemaVersion":1,"symbols":["pydantic_core.SchemaSerializer","pydantic_core.SchemaValidator","pydantic_core.ValidationError"]},"contractCommand":["python","test/contract.py"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"pypi","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"pip","schemaVersion":1},"license":"MIT-0","packages":["pkg:pypi/pydantic-core@2.46.4"],"schemaVersion":1,"subject":"pkg:pypi/pydantic-core@2.46.4","symbols":["pydantic_core.SchemaSerializer","pydantic_core.SchemaValidator","pydantic_core.ValidationError"],"verifierAdapter":"python@1"}

pydantic-core==2.46.4
typing-extensions==4.16.0

{
  "schemaVersion": 1,
  "goal": "verify pkg:pypi/pydantic-core@2.46.4",
  "kind": "HOW",
  "packages": [
    "pkg:pypi/pydantic-core@2.46.4"
  ],
  "symbols": [
    "pydantic_core.SchemaSerializer",
    "pydantic_core.SchemaValidator",
    "pydantic_core.ValidationError"
  ]
}

# src package

"""Domain schema definitions and helpers using pydantic_core."""

from typing import Any
from pydantic_core import (
    PydanticCustomError,
    SchemaSerializer,
    SchemaValidator,
    core_schema,
)


def validate_min_age(v: Any, info: core_schema.ValidationInfo) -> int:
    """Validator function checking minimum age based on validation context."""
    min_age = 0
    if info.context and isinstance(info.context, dict) and "min_age" in info.context:
        min_age = info.context["min_age"]

    if v < min_age:
        raise PydanticCustomError(
            "underage",
            "Age {age} is below minimum {min_age}",
            {"age": v, "min_age": min_age},
        )
    return v


def create_user_schema() -> core_schema.CoreSchema:
    """Builds a core schema representing a user profile."""
    age_schema = core_schema.with_info_after_validator_function(
        validate_min_age,
        core_schema.int_schema(),
    )

    return core_schema.typed_dict_schema({
        "id": core_schema.typed_dict_field(core_schema.int_schema()),
        "name": core_schema.typed_dict_field(core_schema.str_schema()),
        "age": core_schema.typed_dict_field(age_schema),
        "email": core_schema.typed_dict_field(core_schema.str_schema(), required=False),
        "secret_token": core_schema.typed_dict_field(core_schema.str_schema(), required=False),
        "tags": core_schema.typed_dict_field(
            core_schema.list_schema(core_schema.str_schema()), required=False
        ),
    })


def create_user_validator() -> SchemaValidator:
    """Creates a SchemaValidator for user profiles."""
    return SchemaValidator(create_user_schema())


def create_user_serializer() -> SchemaSerializer:
    """Creates a SchemaSerializer for user profiles."""
    return SchemaSerializer(create_user_schema())

import sys
from pathlib import Path

# Add project root to sys.path
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))

import pydantic_core
from pydantic_core import (
    SchemaSerializer,
    SchemaValidator,
    ValidationError,
    from_json,
    to_json,
)
from src.models import (
    create_user_schema,
    create_user_serializer,
    create_user_validator,
)

# Base sanity check
assert pydantic_core.__version__ == "2.46.4"

# ============================================================================
# 1. SchemaValidator validates python dictionary with lax coercion & strict mode
# ============================================================================
validator = create_user_validator()
serializer = create_user_serializer()

valid_user = {
    "id": 101,
    "name": "Alice Developer",
    "age": 28,
    "email": "alice@example.com",
    "secret_token": "tok_secret_123",
    "tags": ["admin", "core"],
}

validated = validator.validate_python(valid_user)
assert validated["id"] == 101
assert validated["name"] == "Alice Developer"
assert validated["age"] == 28
assert validated["email"] == "alice@example.com"
assert validated["secret_token"] == "tok_secret_123"
assert validated["tags"] == ["admin", "core"]

# Lax coercion: string numeric age '42' is coerced to integer 42
lax_result = validator.validate_python({"id": 1, "name": "Bob", "age": "42"})
assert lax_result["age"] == 42
assert isinstance(lax_result["age"], int)

# Strict mode: string age '42' is rejected when strict=True
try:
    validator.validate_python({"id": 1, "name": "Bob", "age": "42"}, strict=True)
    raise AssertionError("Strict validation should have failed on string age")
except ValidationError as e:
    assert e.error_count() == 1
    err = e.errors()[0]
    assert err["type"] == "int_type"
    assert err["loc"] == ("age",)

# ============================================================================
# 2. SchemaValidator validates direct UTF-8 JSON bytes via Rust engine
# ============================================================================
json_bytes = b'{"id": 202, "name": "Charlie", "age": 35, "tags": ["rust", "python"]}'
json_result = validator.validate_json(json_bytes)
assert json_result["id"] == 202
assert json_result["name"] == "Charlie"
assert json_result["age"] == 35
assert json_result["tags"] == ["rust", "python"]

# Malformed JSON payload raises ValidationError with json_invalid error type
try:
    validator.validate_json(b'{"id": 202, "name": invalid_json_syntax}')
    raise AssertionError("Malformed JSON should raise ValidationError")
except ValidationError as e:
    assert e.errors()[0]["type"] == "json_invalid"

# ============================================================================
# 3. Validation context passing and custom PydanticCustomError enforcement
# ============================================================================
# Custom underage error raised when age < context['min_age']
try:
    validator.validate_python(
        {"id": 303, "name": "Teen", "age": 16},
        context={"min_age": 21},
    )
    raise AssertionError("Underage payload should fail context validation")
except ValidationError as e:
    assert e.error_count() == 1
    err = e.errors()[0]
    assert err["type"] == "underage"
    assert err["loc"] == ("age",)
    assert err["msg"] == "Age 16 is below minimum 21"
    assert err["ctx"] == {"age": 16, "min_age": 21}

# Passes when age meets or exceeds context threshold
passed_ctx = validator.validate_python(
    {"id": 303, "name": "Adult", "age": 22},
    context={"min_age": 21},
)
assert passed_ctx["age"] == 22

# ============================================================================
# 4. ValidationError multi-field aggregation and structured inspection
# ============================================================================
try:
    validator.validate_python(
        {
            "id": "not_an_int",
            "name": 12345,
            "age": -1,
            "tags": "not_a_list",
        },
        strict=True,
    )
    raise AssertionError("Multiple invalid fields must raise ValidationError")
except ValidationError as e:
    assert e.error_count() >= 3
    errors = e.errors(include_url=False)
    loc_fields = [err["loc"][0] for err in errors]
    assert "id" in loc_fields
    assert "name" in loc_fields
    assert "tags" in loc_fields
    assert "validation error" in str(e).lower()

# ============================================================================
# 5. SchemaSerializer exports data with field exclusions and formatted JSON
# ============================================================================
record = {
    "id": 505,
    "name": "Dana Public",
    "age": 40,
    "email": "dana@example.com",
    "secret_token": "sensitive_api_key",
    "tags": ["lead"],
}

# Python serialization excluding secret_token
py_serialized = serializer.to_python(record, exclude={"secret_token"})
assert "secret_token" not in py_serialized
assert py_serialized["id"] == 505
assert py_serialized["name"] == "Dana Public"
assert py_serialized["email"] == "dana@example.com"

# JSON serialization excluding secret_token produces UTF-8 bytes
json_output = serializer.to_json(record, exclude={"secret_token"})
assert isinstance(json_output, bytes)
assert b"secret_token" not in json_output
assert b"Dana Public" in json_output

# JSON serialization with custom indentation
json_pretty = serializer.to_json(record, indent=2, exclude={"secret_token"})
assert b"\n  " in json_pretty

# ============================================================================
# 6. Standalone to_json and from_json Rust-accelerated utility functions
# ============================================================================
payload = {"status": "ok", "items": [1, 2, 3], "enabled": True}
encoded = to_json(payload)
assert isinstance(encoded, bytes)
assert encoded == b'{"status":"ok","items":[1,2,3],"enabled":true}'

decoded = from_json(encoded)
assert decoded == payload

print(
    "CONTRACT PASS: pydantic_core",
    pydantic_core.__version__,
    "SchemaValidator, SchemaSerializer, and ValidationError verified on python",
    ".".join(str(part) for part in sys.version_info[:2]),
)