schemez 0.2.2__tar.gz → 0.2.4__tar.gz

{schemez-0.2.2 → schemez-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemez
-Version: 0.2.2
+Version: 0.2.4
 Summary: Pydantic shim for config stuff
 Project-URL: Documentation, https://phil65.github.io/schemez/
 Project-URL: Source, https://github.com/phil65/schemez

{schemez-0.2.2 → schemez-0.2.4}/src/schemez/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.2.2"
+__version__ = "0.2.4"
 
 
 from schemez.schema import Schema

{schemez-0.2.2 → schemez-0.2.4}/src/schemez/pydantic_types.py

@@ -2,9 +2,9 @@
 
 from __future__ import annotations
 
-from typing import Annotated
+from typing import Annotated, Any
 
-from pydantic import Field
+from pydantic import BaseModel, Field
 
 
 ModelIdentifier = Annotated[
@@ -40,3 +40,13 @@ MimeType = Annotated[
         description="Standard MIME type identifying file formats and content types",
     ),
 ]
+
+
+def get_field_type(model: type[BaseModel], field_name: str) -> dict[str, Any]:
+    """Extract field_type metadata from a model field."""
+    field_info = model.model_fields[field_name]
+    metadata = {}
+    if field_info.json_schema_extra and isinstance(field_info.json_schema_extra, dict):
+        metadata.update(field_info.json_schema_extra)
+
+    return metadata

{schemez-0.2.2 → schemez-0.2.4}/src/schemez/schema.py

@@ -216,11 +216,21 @@ class Schema(BaseModel):
 
         return get_ctor_basemodel(target_cls)
 
-    def model_dump_yaml(self) -> str:
+    def model_dump_yaml(
+        self,
+        exclude_none: bool = True,
+        exclude_defaults: bool = False,
+        exclude_unset: bool = False,
+    ) -> str:
         """Dump configuration to YAML string."""
         import yamling
 
-        return yamling.dump_yaml(self.model_dump(exclude_none=True))
+        text = self.model_dump(
+            exclude_none=exclude_none,
+            exclude_defaults=exclude_defaults,
+            exclude_unset=exclude_unset,
+        )
+        return yamling.dump_yaml(text)
 
     def save(self, path: StrPath, overwrite: bool = False) -> None:
         """Save configuration to a YAML file.

schemez-0.2.4/src/schemez/schemadef/schemadef.py

@@ -0,0 +1,260 @@
+"""Models for schema fields and definitions."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Annotated, Any, Literal
+
+from pydantic import BaseModel, Field, create_model
+
+from schemez import Schema, helpers
+
+
+class SchemaField(Schema):
+    """Field definition for inline response types.
+
+    Defines a single field in an inline response definition, including:
+    - Data type specification
+    - Optional description
+    - Validation constraints
+    - Enum values (when type is 'enum')
+
+    Used by InlineSchemaDef to structure response fields.
+    """
+
+    type: str
+    """Data type of the response field"""
+
+    description: str | None = None
+    """Optional description of what this field represents"""
+
+    values: list[Any] | None = None
+    """Values for enum type fields"""
+
+    # Common validation constraints
+    default: Any | None = None
+    """Default value for the field"""
+
+    title: str | None = None
+    """Title for the field in generated JSON Schema"""
+
+    pattern: str | None = None
+    """Regex pattern for string validation"""
+
+    min_length: int | None = None
+    """Minimum length for collections"""
+
+    max_length: int | None = None
+    """Maximum length for collections"""
+
+    gt: float | None = None
+    """Greater than (exclusive) validation for numbers"""
+
+    ge: float | None = None
+    """Greater than or equal (inclusive) validation for numbers"""
+
+    lt: float | None = None
+    """Less than (exclusive) validation for numbers"""
+
+    le: float | None = None
+    """Less than or equal (inclusive) validation for numbers"""
+
+    multiple_of: float | None = None
+    """Number must be a multiple of this value"""
+
+    literal_value: Any | None = None
+    """Value for Literal type constraint, makes field accept only this specific value"""
+
+    examples: list[Any] | None = None
+    """Examples for this field in JSON Schema"""
+
+    optional: bool = False
+    """Whether this field is optional (None value allowed)"""
+
+    json_schema_extra: dict[str, Any] | None = None
+    """Additional JSON Schema information"""
+
+    field_config: dict[str, Any] | None = None
+    """Configuration for Pydantic model fields"""
+
+    # Extensibility for future or custom constraints
+    constraints: dict[str, Any] = Field(default_factory=dict)
+    """Additional constraints not covered by explicit fields"""
+
+
+class BaseSchemaDef(Schema):
+    """Base class for response definitions."""
+
+    type: str = Field(init=False)
+
+    description: str | None = None
+    """A description for this response definition."""
+
+
+class InlineSchemaDef(BaseSchemaDef):
+    """Inline definition of schema.
+
+    Allows defining response types directly in the configuration using:
+    - Field definitions with types and descriptions
+    - Optional validation constraints
+    - Custom field descriptions
+
+    Example:
+        schemas:
+          BasicResult:
+            type: inline
+            fields:
+              success: {type: bool, description: "Operation success"}
+              message: {type: str, description: "Result details"}
+    """
+
+    type: Literal["inline"] = Field("inline", init=False)
+    """Inline response definition."""
+
+    fields: dict[str, SchemaField]
+    """A dictionary containing all fields."""
+
+    def get_schema(self) -> type[BaseModel]:  # type: ignore
+        """Create Pydantic model from inline definition."""
+        fields = {}
+        for name, field in self.fields.items():
+            # Initialize constraint dictionary
+            field_constraints = {}
+
+            # Handle enum type
+            if field.type == "enum":
+                if not field.values:
+                    msg = f"Field '{name}' has type 'enum' but no values defined"
+                    raise ValueError(msg)
+
+                # Create dynamic Enum class
+                enum_name = f"{name.capitalize()}Enum"
+
+                # Create enum members dictionary
+                enum_members = {}
+                for i, value in enumerate(field.values):
+                    if isinstance(value, str) and value.isidentifier():
+                        # If value is a valid Python identifier, use it as is
+                        key = value
+                    else:
+                        # Otherwise, create a synthetic name
+                        key = f"VALUE_{i}"
+                    enum_members[key] = value
+
+                # Create the enum class
+                enum_class = Enum(enum_name, enum_members)
+                python_type: Any = enum_class
+
+                # Handle enum default value specially
+                if field.default is not None:
+                    # Store default value as the enum value string
+                    # Pydantic v2 will convert it to the enum instance
+                    if field.default in list(field.values):
+                        field_constraints["default"] = field.default
+                    else:
+                        msg = (
+                            f"Default value {field.default!r} not found "
+                            f"in enum values for field {name!r}"
+                        )
+                        raise ValueError(msg)
+            else:
+                python_type = helpers.resolve_type_string(field.type)
+                if not python_type:
+                    msg = f"Unsupported field type: {field.type}"
+                    raise ValueError(msg)
+
+            # Handle literal constraint if provided
+            if field.literal_value is not None:
+                from typing import Literal as LiteralType
+
+                python_type = LiteralType[field.literal_value]
+
+            # Handle optional fields (allowing None)
+            if field.optional:
+                python_type = python_type | None  # type: ignore
+
+            # Add standard Pydantic constraints
+            # Collect all constraint values
+            for constraint in [
+                "default",
+                "title",
+                "min_length",
+                "max_length",
+                "pattern",
+                "min_length",
+                "max_length",
+                "gt",
+                "ge",
+                "lt",
+                "le",
+                "multiple_of",
+            ]:
+                value = getattr(field, constraint, None)
+                if value is not None:
+                    field_constraints[constraint] = value
+
+            # Handle examples separately (Pydantic v2 way)
+            if field.examples:
+                if field.json_schema_extra is None:
+                    field.json_schema_extra = {}
+                field.json_schema_extra["examples"] = field.examples
+
+            # Add json_schema_extra if provided
+            if field.json_schema_extra:
+                field_constraints["json_schema_extra"] = field.json_schema_extra
+
+            # Add any additional constraints
+            field_constraints.update(field.constraints)
+
+            field_info = Field(description=field.description, **field_constraints)
+            fields[name] = (python_type, field_info)
+
+        cls_name = self.description or "ResponseType"
+        return create_model(
+            cls_name,
+            **fields,
+            __base__=BaseModel,
+            __doc__=self.description,
+        )  # type: ignore[call-overload]
+
+
+class ImportedSchemaDef(BaseSchemaDef):
+    """Response definition that imports an existing Pydantic model.
+
+    Allows using externally defined Pydantic models as response types.
+    Benefits:
+    - Reuse existing model definitions
+    - Full Python type support
+    - Complex validation logic
+    - IDE support for imported types
+
+    Example:
+        responses:
+          AnalysisResult:
+            type: import
+            import_path: myapp.models.AnalysisResult
+    """
+
+    type: Literal["import"] = Field("import", init=False)
+    """Import-path based response definition."""
+
+    import_path: str
+    """The path to the pydantic model to use as the response type."""
+
+    # mypy is confused about "type"
+    # TODO: convert BaseModel to Schema?
+    def get_schema(self) -> type[BaseModel]:  # type: ignore
+        """Import and return the model class."""
+        try:
+            model_class = helpers.import_class(self.import_path)
+            if not issubclass(model_class, BaseModel):
+                msg = f"{self.import_path} must be a Pydantic model"
+                raise TypeError(msg)  # noqa: TRY301
+        except Exception as e:
+            msg = f"Failed to import response type {self.import_path}"
+            raise ValueError(msg) from e
+        else:
+            return model_class
+
+
+SchemaDef = Annotated[InlineSchemaDef | ImportedSchemaDef, Field(discriminator="type")]

schemez-0.2.4/tests/test_enum_support.py

@@ -0,0 +1,192 @@
+"""Test enum support in SchemaField."""
+
+from __future__ import annotations
+
+from enum import Enum
+
+from pydantic import ValidationError
+import pytest
+
+from schemez.schemadef.schemadef import InlineSchemaDef, SchemaField
+
+
+def test_explicit_constraints():
+    """Test that explicit constraints work correctly."""
+    fields = {
+        "name": SchemaField(
+            type="str",
+            min_length=3,
+            max_length=50,
+            pattern=r"^[a-zA-Z0-9_]+$",
+        ),
+        "age": SchemaField(type="int", description="User age", ge=18, lt=120),
+        "score": SchemaField(
+            type="float",
+            description="Score value",
+            ge=0.0,
+            le=100.0,
+            multiple_of=0.5,
+        ),
+        "tags": SchemaField(type="set[str]", min_length=1, max_length=10),
+    }
+    schema_def = InlineSchemaDef(description="Test Schema Constraints", fields=fields)
+    model = schema_def.get_schema()
+    valid_instance = model(
+        name="user123",  # type: ignore
+        age=30,  # type: ignore
+        score=95.5,  # type: ignore
+        tags=["developer", "python"],  # type: ignore
+    )
+    assert valid_instance.name == "user123"  # type: ignore
+    assert valid_instance.age == 30  # type: ignore  # noqa: PLR2004
+    assert valid_instance.score == 95.5  # type: ignore # noqa: PLR2004
+    assert valid_instance.tags == {"developer", "python"}  # type: ignore
+
+    # Test min_length constraint
+    with pytest.raises(ValidationError):
+        model(
+            name="ab",  # Too short  # type: ignore
+            age=30,  # type: ignore
+            score=95.5,  # type: ignore
+            tags=["developer"],  # type: ignore
+        )
+
+    # Test pattern constraint
+    with pytest.raises(ValidationError):
+        model(
+            name="user-name",  # Invalid character # type: ignore
+            age=30,  # type: ignore
+            score=95.5,  # type: ignore
+            tags=["developer"],  # type: ignore
+        )
+
+    # Test ge constraint
+    with pytest.raises(ValidationError):
+        model(
+            name="user123",  # type: ignore
+            age=17,  # Too young  # type: ignore
+            score=95.5,  # type: ignore
+            tags=["developer"],  # type: ignore
+        )
+
+    # Test multiple_of constraint
+    with pytest.raises(ValidationError):
+        model(
+            name="user123",  # type: ignore
+            age=30,  # type: ignore
+            score=95.7,  # Not a multiple of 0.5  # type: ignore
+            tags=["developer"],  # type: ignore
+        )
+
+    # Test that set automatically enforces uniqueness
+    instance = model(
+        name="user123",  # type: ignore
+        age=30,  # type: ignore
+        score=95.5,  # type: ignore
+        # Duplicates get automatically removed
+        tags=["developer", "developer", "python"],  # type: ignore
+    )
+    assert len(instance.tags) == 2  # type: ignore  # noqa: PLR2004
+    assert "developer" in instance.tags  # type: ignore
+    assert "python" in instance.tags  # type: ignore
+
+
+def test_enum_type():
+    """Test that enum type creates an Enum type."""
+    fields = {
+        "color": SchemaField(
+            type="enum",
+            description="Color selection",
+            values=["red", "green", "blue"],
+        )
+    }
+    schema_def = InlineSchemaDef(description="Test Schema", fields=fields)
+
+    model = schema_def.get_schema()
+
+    # Check that the model has the color field with an Enum type
+    color_field = model.model_fields["color"]
+    assert color_field.description == "Color selection"
+
+    # The field should be an Enum type
+    color_value = model(color="red").color  # type: ignore
+    assert isinstance(color_value, Enum)
+    assert color_value.value == "red"
+
+    # Check all values work
+    assert model(color="green").color.value == "green"  # type: ignore
+    assert model(color="blue").color.value == "blue"  # type: ignore
+
+    # Try with invalid value
+    with pytest.raises(ValidationError):
+        model(color="purple")  # type: ignore
+
+
+def test_enum_with_numeric_values():
+    """Test that enum type works with numeric values."""
+    fields = {
+        "priority": SchemaField(
+            type="enum",
+            description="Task priority",
+            values=[1, 2, 3, 5, 8],
+        )
+    }
+    schema_def = InlineSchemaDef(description="Test Schema", fields=fields)
+    model = schema_def.get_schema()
+
+    # Create a valid instance
+    instance = model(priority=5)  # type: ignore
+    assert instance.priority.value == 5  # type: ignore  # noqa: PLR2004
+    # Try with invalid value
+    with pytest.raises(ValidationError):
+        model(priority=4)  # type: ignore
+
+
+def test_mixed_enum_values():
+    """Test that enum type works with mixed value types."""
+    fields = {
+        "value": SchemaField(
+            type="enum",
+            description="Mixed values",
+            values=[1, "text", True],
+        )
+    }
+    schema_def = InlineSchemaDef(description="Test Schema", fields=fields)
+    model = schema_def.get_schema()
+
+    # Create valid instances
+    assert model(value=1).value.value == 1  # type: ignore
+    assert model(value="text").value.value == "text"  # type: ignore
+    assert model(value=True).value.value  # type: ignore
+
+    # Try with invalid value
+    with pytest.raises(ValidationError):
+        model(value="invalid")  # type: ignore
+
+
+def test_missing_enum_values():
+    """Test that enum type raises error when values are missing."""
+    fields = {"status": SchemaField(type="enum", description="Status with no vals")}
+    schema_def = InlineSchemaDef(description="Test Schema", fields=fields)
+    # Should raise an error when creating the schema
+    with pytest.raises(ValueError, match="has type 'enum' but no values defined"):
+        schema_def.get_schema()
+
+
+def test_enum_with_default():
+    """Test that enum type works with default value."""
+    fields = {
+        "status": SchemaField(
+            type="enum",
+            description="Status with default",
+            values=["pending", "active", "completed"],
+            default="pending",
+        )
+    }
+    schema_def = InlineSchemaDef(description="Test Schema", fields=fields)
+
+    model = schema_def.get_schema()
+
+    # Test default value
+    instance = model()
+    assert instance.status == "pending"  # type: ignore

schemez-0.2.4/tests/test_schema_field.py

@@ -0,0 +1,467 @@
+"""Test SchemaField functionality comprehensively."""
+
+from __future__ import annotations
+
+from enum import Enum
+
+from pydantic import ValidationError
+import pytest
+
+from schemez.schemadef.schemadef import InlineSchemaDef, SchemaField
+
+
+def test_basic_types():
+    """Test that basic types are resolved correctly."""
+    schema_def = InlineSchemaDef(
+        description="Test Schema with Basic Types",
+        fields={
+            "string_field": SchemaField(type="str", description="A string field"),
+            "int_field": SchemaField(type="int", description="An integer field"),
+            "float_field": SchemaField(type="float", description="A float field"),
+            "bool_field": SchemaField(type="bool", description="A boolean field"),
+            "dict_field": SchemaField(type="dict", description="A dictionary field"),
+            "list_field": SchemaField(type="list", description="A list field"),
+        },
+    )
+
+    model = schema_def.get_schema()
+
+    # Check field types
+    assert model.model_fields["string_field"].annotation is str
+    assert model.model_fields["int_field"].annotation is int
+    assert model.model_fields["float_field"].annotation is float
+    assert model.model_fields["bool_field"].annotation is bool
+    assert model.model_fields["dict_field"].annotation is dict
+    assert model.model_fields["list_field"].annotation is list
+
+    # Check descriptions
+    assert model.model_fields["string_field"].description == "A string field"
+
+
+def test_generic_types():
+    """Test that generic types like list[str] are resolved correctly."""
+    schema_def = InlineSchemaDef(
+        description="Test Schema with Generic Types",
+        fields={
+            "str_list": SchemaField(type="list[str]", description="List of strings"),
+            "int_list": SchemaField(type="list[int]", description="List of integers"),
+            "str_dict": SchemaField(
+                type="dict[str, int]", description="String to int mapping"
+            ),
+        },
+    )
+
+    model = schema_def.get_schema()
+
+    # Create valid instances
+    instance = model(
+        str_list=["a", "b", "c"],  # type: ignore
+        int_list=[1, 2, 3],  # type: ignore
+        str_dict={"a": 1, "b": 2},  # type: ignore
+    )
+
+    assert instance.str_list == ["a", "b", "c"]  # type: ignore
+    assert instance.int_list == [1, 2, 3]  # type: ignore
+    assert instance.str_dict == {"a": 1, "b": 2}  # type: ignore
+
+    # Test type validation
+    with pytest.raises(ValidationError):
+        model(str_list=[1, 2, 3])  # type: ignore
+
+    with pytest.raises(ValidationError):
+        model(int_list=["a", "b", "c"])  # type: ignore
+
+    with pytest.raises(ValidationError):
+        model(str_dict={1: "a"})  # type: ignore
+
+
+def test_string_constraints():
+    """Test string validation constraints."""
+    schema_def = InlineSchemaDef(
+        description="Test Schema with String Constraints",
+        fields={
+            "username": SchemaField(
+                type="str",
+                description="Username",
+                min_length=3,
+                max_length=20,
+                pattern=r"^[a-z0-9_]+$",
+            ),
+        },
+    )
+
+    model = schema_def.get_schema()
+
+    # Valid username
+    assert model(username="user_123").username == "user_123"  # type: ignore
+
+    # Too short
+    with pytest.raises(ValidationError):
+        model(username="ab")  # type: ignore
+
+    # Too long
+    with pytest.raises(ValidationError):
+        model(username="a" * 21)  # type: ignore
+
+    # Invalid pattern
+    with pytest.raises(ValidationError):
+        model(username="User-Name")  # type: ignore
+
+
+def test_numeric_constraints():
+    """Test numeric validation constraints."""
+    schema_def = InlineSchemaDef(
+        description="Test Schema with Numeric Constraints",
+        fields={
+            "age": SchemaField(
+                type="int",
+                description="Age",
+                ge=18,
+                lt=120,
+            ),
+            "score": SchemaField(
+                type="float",
+                description="Score",
+                gt=0.0,
+                le=100.0,
+                multiple_of=0.5,
+            ),
+        },
+    )
+
+    model = schema_def.get_schema()
+
+    # Valid values
+    instance = model(age=18, score=99.5)  # type: ignore
+    assert instance.age == 18  # type: ignore  # noqa: PLR2004
+    assert instance.score == 99.5  # type: ignore  # noqa: PLR2004
+
+    # Test ge constraint
+    with pytest.raises(ValidationError):
+        model(age=17, score=50.0)  # type: ignore
+
+    # Test lt constraint
+    with pytest.raises(ValidationError):
+        model(age=120, score=50.0)  # type: ignore
+
+    # Test gt constraint
+    with pytest.raises(ValidationError):
+        model(age=18, score=0.0)  # type: ignore
+
+    # Test le constraint
+    with pytest.raises(ValidationError):
+        model(age=18, score=100.5)  # type: ignore
+
+    # Test multiple_of constraint
+    with pytest.raises(ValidationError):
+        model(age=18, score=50.1)  # type: ignore
+
+
+def test_collection_constraints():
+    """Test collection validation constraints."""
+    schema_def = InlineSchemaDef(
+        description="Test Schema with Collection Constraints",
+        fields={
+            "tags": SchemaField(
+                type="list[str]",
+                description="Tags",
+                min_length=1,
+                max_length=5,
+            ),
+            "unique_tags": SchemaField(
+                type="set[str]",
+                description="Tags with unique values",
+                min_length=1,
+                max_length=5,
+            ),
+        },
+    )
+
+    model = schema_def.get_schema()
+
+    # Valid - provide both required fields
+    instance = model(
+        tags=["one", "two"],  # type: ignore
+        unique_tags={"one", "two"},  # type: ignore
+    )
+    assert instance.tags == ["one", "two"]  # type: ignore
+    assert instance.unique_tags == {"one", "two"}  # type: ignore
+
+    # Too few items - need to provide both fields
+    with pytest.raises(ValidationError):
+        model(
+            tags=[],  # type: ignore
+            unique_tags={"one", "two"},  # type: ignore
+        )
+
+    with pytest.raises(ValidationError):
+        model(
+            tags=["one", "two"],  # type: ignore
+            unique_tags=set(),  # type: ignore
+        )
+
+    # Too many items
+    with pytest.raises(ValidationError):
+        model(
+            tags=["one", "two", "three", "four", "five", "six"],  # type: ignore
+            unique_tags={"one", "two"},  # type: ignore
+        )
+
+    with pytest.raises(ValidationError):
+        model(
+            tags=["one", "two"],  # type: ignore
+            unique_tags={"one", "two", "three", "four", "five", "six"},  # type: ignore
+        )
+
+    # Non-unique items are allowed in list but automatically deduplicated in set
+    instance = model(
+        tags=["one", "one", "two"],  # type: ignore
+        unique_tags={"one", "two"},  # type: ignore
+    )
+    assert instance.tags == ["one", "one", "two"]  # type: ignore
+
+    # Attempting to pass non-unique items to a set field will automatically deduplicate
+    instance = model(
+        tags=["one", "two"],  # type: ignore
+        unique_tags=["one", "one", "two"],  # type: ignore  # Will be converted to set
+    )
+    assert instance.unique_tags == {"one", "two"}  # type: ignore
+
+
+def test_default_values():
+    """Test default values for fields."""
+    schema_def = InlineSchemaDef(
+        description="Test Schema with Default Values",
+        fields={
+            "name": SchemaField(
+                type="str",
+                description="Name",
+                default="Anonymous",
+            ),
+            "active": SchemaField(
+                type="bool",
+                description="Active status",
+                default=True,
+            ),
+            "count": SchemaField(
+                type="int",
+                description="Count",
+                default=0,
+            ),
+        },
+    )
+
+    model = schema_def.get_schema()
+
+    # Test defaults when not provided
+    instance = model()
+    assert instance.name == "Anonymous"  # type: ignore
+    assert instance.active is True  # type: ignore
+    assert instance.count == 0  # type: ignore
+
+    # Test overriding defaults
+    instance = model(name="User", active=False, count=10)  # type: ignore
+    assert instance.name == "User"  # type: ignore
+    assert instance.active is False  # type: ignore
+    assert instance.count == 10  # type: ignore  # noqa: PLR2004
+
+
+def test_const_constraint():
+    """Test const constraint."""
+    schema_def = InlineSchemaDef(
+        description="Test Schema with Const Constraint",
+        fields={
+            "version": SchemaField(
+                type="str",
+                description="API Version",
+                literal_value="1.0",
+            ),
+        },
+    )
+
+    model = schema_def.get_schema()
+
+    # Valid
+    assert model(version="1.0").version == "1.0"  # type: ignore
+
+    # Invalid
+    with pytest.raises(ValidationError):
+        model(version="2.0")  # type: ignore
+
+
+def test_enum_type():
+    """Test enum type field."""
+    schema_def = InlineSchemaDef(
+        description="Test Schema with Enum",
+        fields={
+            "status": SchemaField(
+                type="enum",
+                description="Status",
+                values=["pending", "active", "completed"],
+            ),
+        },
+    )
+
+    model = schema_def.get_schema()
+
+    # The field should use an Enum type
+    status_field = model.model_fields["status"]
+    assert issubclass(status_field.annotation, Enum)  # type: ignore
+
+    # Valid values
+    status = model(status="pending").status  # type: ignore
+    assert isinstance(status, Enum)
+    assert status.value == "pending"
+
+    # Invalid value
+    with pytest.raises(ValidationError):
+        model(status="invalid")  # type: ignore
+
+
+def test_enum_with_default():
+    """Test enum with default value."""
+    schema_def = InlineSchemaDef(
+        description="Test Schema with Enum Default",
+        fields={
+            "role": SchemaField(
+                type="enum",
+                description="User Role",
+                values=["admin", "user", "guest"],
+                default="user",
+            ),
+        },
+    )
+
+    model = schema_def.get_schema()
+
+    # Test default
+    instance = model()
+    assert instance.role == "user"  # type: ignore
+
+    # Override default
+    instance = model(role="admin")  # type: ignore
+    assert instance.role.value == "admin"  # type: ignore
+
+
+def test_nullable_constraint():
+    """Test nullable constraint."""
+    schema_def = InlineSchemaDef(
+        description="Test Schema with Nullable Fields",
+        fields={
+            "name": SchemaField(
+                type="str",
+                description="Optional name",
+                optional=True,
+            ),
+        },
+    )
+
+    model = schema_def.get_schema()
+
+    # Test null value
+    instance = model(name=None)  # type: ignore
+    assert instance.name is None  # type: ignore
+
+
+def test_additional_constraints():
+    """Test additional constraints via the constraints dict."""
+    schema_def = InlineSchemaDef(
+        description="Test Schema with Additional Constraints",
+        fields={
+            "custom_field": SchemaField(
+                type="str",
+                description="Field with custom constraint",
+                examples=["example1", "example2"],
+            ),
+        },
+    )
+
+    model = schema_def.get_schema()
+    assert model(custom_field="test").custom_field == "test"  # type: ignore
+
+
+def test_title_constraint():
+    """Test title constraint for JSON Schema generation."""
+    schema_def = InlineSchemaDef(
+        description="Test Schema with Title",
+        fields={
+            "user_id": SchemaField(
+                type="str",
+                description="User ID",
+                title="User Identifier",
+            ),
+        },
+    )
+
+    model = schema_def.get_schema()
+
+    # Check that the title was set
+    field = model.model_fields["user_id"]
+    assert field.title == "User Identifier"
+
+
+def test_complex_nested_structure():
+    """Test complex nested structure with various constraints."""
+    schema_def = InlineSchemaDef(
+        description="Complex Nested Schema",
+        fields={
+            "user": SchemaField(
+                type="dict[str, Any]",
+                description="User information",
+                json_schema_extra={
+                    "required": ["name", "email"],
+                },
+            ),
+            "settings": SchemaField(
+                type="dict[str, bool]",
+                description="User settings",
+                default={},
+            ),
+            "metadata": SchemaField(
+                type="dict",
+                description="Additional metadata",
+                optional=True,
+            ),
+        },
+    )
+
+    model = schema_def.get_schema()
+
+    # Test valid complex structure
+    instance = model(
+        user={"name": "Test User", "email": "test@example.com", "age": 30},  # type: ignore
+        settings={"notifications": True, "darkMode": False},  # type: ignore
+        metadata={"created": "2023-01-01", "source": "API"},  # type: ignore
+    )
+
+    assert instance.user["name"] == "Test User"  # type: ignore
+    assert instance.settings["notifications"] is True  # type: ignore
+    assert instance.metadata["source"] == "API"  # type: ignore
+
+    # Test with null metadata
+    instance = model(
+        user={"name": "Test User", "email": "test@example.com"},  # type: ignore
+        settings={"notifications": True},  # type: ignore
+        metadata=None,  # type: ignore
+    )
+    # Test optional field with None value
+    assert instance.metadata is None  # type: ignore
+
+    # Test with default empty settings
+    instance = model(
+        user={"name": "Test User", "email": "test@example.com"},  # type: ignore
+        metadata=None,  # type: ignore
+    )
+    assert instance.settings == {}  # type: ignore
+
+
+if __name__ == "__main__":
+    test_basic_types()
+    test_generic_types()
+    test_string_constraints()
+    test_numeric_constraints()
+    test_collection_constraints()
+    test_default_values()
+    test_const_constraint()
+    test_enum_type()
+    test_enum_with_default()

schemez-0.2.2/src/schemez/schemadef/schemadef.py

@@ -1,120 +0,0 @@
-"""Models for schema fields and definitions."""
-
-from __future__ import annotations
-
-from typing import Annotated, Any, Literal
-
-from pydantic import BaseModel, Field, create_model
-
-from schemez import Schema, helpers
-
-
-class SchemaField(Schema):
-    """Field definition for inline response types.
-
-    Defines a single field in an inline response definition, including:
-    - Data type specification
-    - Optional description
-    - Validation constraints
-
-    Used by InlineSchemaDef to structure response fields.
-    """
-
-    type: str
-    """Data type of the response field"""
-
-    description: str | None = None
-    """Optional description of what this field represents"""
-
-    constraints: dict[str, Any] = Field(default_factory=dict)
-    """Optional validation constraints for the field"""
-
-
-class BaseSchemaDef(Schema):
-    """Base class for response definitions."""
-
-    type: str = Field(init=False)
-
-    description: str | None = None
-    """A description for this response definition."""
-
-
-class InlineSchemaDef(BaseSchemaDef):
-    """Inline definition of schema.
-
-    Allows defining response types directly in the configuration using:
-    - Field definitions with types and descriptions
-    - Optional validation constraints
-    - Custom field descriptions
-
-    Example:
-        schemas:
-          BasicResult:
-            type: inline
-            fields:
-              success: {type: bool, description: "Operation success"}
-              message: {type: str, description: "Result details"}
-    """
-
-    type: Literal["inline"] = Field("inline", init=False)
-    """Inline response definition."""
-
-    fields: dict[str, SchemaField]
-    """A dictionary containing all fields."""
-
-    def get_schema(self) -> type[Schema]:  # type: ignore
-        """Create Pydantic model from inline definition."""
-        fields = {}
-        for name, field in self.fields.items():
-            python_type = helpers.resolve_type_string(field.type)
-            if not python_type:
-                msg = f"Unsupported field type: {field.type}"
-                raise ValueError(msg)
-
-            field_info = Field(description=field.description, **(field.constraints))
-            fields[name] = (python_type, field_info)
-
-        cls_name = self.description or "ResponseType"
-        return create_model(cls_name, **fields, __base__=Schema, __doc__=self.description)  # type: ignore[call-overload]
-
-
-class ImportedSchemaDef(BaseSchemaDef):
-    """Response definition that imports an existing Pydantic model.
-
-    Allows using externally defined Pydantic models as response types.
-    Benefits:
-    - Reuse existing model definitions
-    - Full Python type support
-    - Complex validation logic
-    - IDE support for imported types
-
-    Example:
-        responses:
-          AnalysisResult:
-            type: import
-            import_path: myapp.models.AnalysisResult
-    """
-
-    type: Literal["import"] = Field("import", init=False)
-    """Import-path based response definition."""
-
-    import_path: str
-    """The path to the pydantic model to use as the response type."""
-
-    # mypy is confused about "type"
-    # TODO: convert BaseModel to Schema?
-    def get_schema(self) -> type[BaseModel]:  # type: ignore
-        """Import and return the model class."""
-        try:
-            model_class = helpers.import_class(self.import_path)
-            if not issubclass(model_class, BaseModel):
-                msg = f"{self.import_path} must be a Pydantic model"
-                raise TypeError(msg)  # noqa: TRY301
-        except Exception as e:
-            msg = f"Failed to import response type {self.import_path}"
-            raise ValueError(msg) from e
-        else:
-            return model_class
-
-
-SchemaDef = Annotated[InlineSchemaDef | ImportedSchemaDef, Field(discriminator="type")]