schemez 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

schemez/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.2.1"
+__version__ = "0.2.3"
 
 
 from schemez.schema import Schema
@@ -9,11 +9,15 @@ from schemez.schemadef.schemadef import (
     ImportedSchemaDef,
     InlineSchemaDef,
 )
+from schemez.pydantic_types import ModelIdentifier, ModelTemperature, MimeType
 
 __all__ = [
     "ImportedSchemaDef",
     "InlineSchemaDef",
     "JSONCode",
+    "MimeType",
+    "ModelIdentifier",
+    "ModelTemperature",
     "PythonCode",
     "Schema",
     "SchemaDef",

schemez/pydantic_types.py

@@ -0,0 +1,52 @@
+"""Custom field types with 'field_type' metadata for UI rendering hints."""
+
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+from pydantic import BaseModel, Field
+
+
+ModelIdentifier = Annotated[
+    str,
+    Field(
+        json_schema_extra={"field_type": "model_identifier"},
+        pattern=r"^[a-zA-Z0-9\-]+(/[a-zA-Z0-9\-]+)*(:[\w\-\.]+)?$",
+        examples=["openai:gpt-o1-mini", "anthropic/claude-3-opus"],
+        description="Identifier for an AI model, optionally including provider.",
+    ),
+]
+
+ModelTemperature = Annotated[
+    float,
+    Field(
+        json_schema_extra={"field_type": "temperature", "step": 0.1},
+        ge=0.0,
+        le=2.0,
+        description=(
+            "Controls randomness in model responses.\n"
+            "Lower values are more deterministic, higher values more creative"
+        ),
+        examples=[0.0, 0.7, 1.0],
+    ),
+]
+
+MimeType = Annotated[
+    str,
+    Field(
+        json_schema_extra={"field_type": "mime_type"},
+        pattern=r"^[a-z]+/[a-z0-9\-+.]+$",
+        examples=["text/plain", "application/pdf", "image/jpeg", "application/json"],
+        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/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/schemadef/schemadef.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from enum import Enum
 from typing import Annotated, Any, Literal
 
 from pydantic import BaseModel, Field, create_model
@@ -16,6 +17,7 @@ class SchemaField(Schema):
     - Data type specification
     - Optional description
     - Validation constraints
+    - Enum values (when type is 'enum')
 
     Used by InlineSchemaDef to structure response fields.
     """
@@ -26,8 +28,58 @@ class SchemaField(Schema):
     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)
-    """Optional validation constraints for the field"""
+    """Additional constraints not covered by explicit fields"""
 
 
 class BaseSchemaDef(Schema):
@@ -66,12 +118,95 @@ class InlineSchemaDef(BaseSchemaDef):
         """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))
+            # 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"

{schemez-0.2.1.dist-info → schemez-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schemez
-Version: 0.2.1
+Version: 0.2.3
 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.3.dist-info/RECORD

@@ -0,0 +1,14 @@
+schemez/__init__.py,sha256=QrVN-zXLiAwYYdMbCxin08TTcks9QkRXZt4FyS5XwLw,565
+schemez/code.py,sha256=usZLov9i5KpK1W2VJxngUzeetgrINtodiooG_AxN-y4,2072
+schemez/convert.py,sha256=b6Sz11lq0HvpXfMREOqnnw8rcVg2XzTKhjjPNc4YIoE,4403
+schemez/docstrings.py,sha256=kmd660wcomXzKac0SSNYxPRNbVCUovrpmE9jwnVRS6c,4115
+schemez/helpers.py,sha256=Ee3wvFbt65ljhWDFdb6ACVUJK4KLjJFVzl4Le75pOBQ,5159
+schemez/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schemez/pydantic_types.py,sha256=iiaHqVkWVd1TZry933aDYJnyzMD0HJIABfROR9txxhA,1581
+schemez/schema.py,sha256=VeNSFec6aCR9GgqXLBE3t4TZeUoS9BDmIoofe9nbqVI,8804
+schemez/schemadef/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schemez/schemadef/schemadef.py,sha256=43GQ8puUBByiSMaDbR6sJ0B-AjRSYQhEvX2Rx4gmjHI,8609
+schemez-0.2.3.dist-info/METADATA,sha256=hI62AloXcRv4SKKeiSmdycBJOuIZWdWfLGeIueu8ss0,5891
+schemez-0.2.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+schemez-0.2.3.dist-info/licenses/LICENSE,sha256=AteGCH9r177TxxrOFEiOARrastASsf7yW6MQxlAHdwA,1078
+schemez-0.2.3.dist-info/RECORD,,

schemez-0.2.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-schemez/__init__.py,sha256=gniCM7yfehxd93fGd154YFF-4suRuZtRbQwJVg-63cU,423
-schemez/code.py,sha256=usZLov9i5KpK1W2VJxngUzeetgrINtodiooG_AxN-y4,2072
-schemez/convert.py,sha256=b6Sz11lq0HvpXfMREOqnnw8rcVg2XzTKhjjPNc4YIoE,4403
-schemez/docstrings.py,sha256=kmd660wcomXzKac0SSNYxPRNbVCUovrpmE9jwnVRS6c,4115
-schemez/helpers.py,sha256=Ee3wvFbt65ljhWDFdb6ACVUJK4KLjJFVzl4Le75pOBQ,5159
-schemez/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schemez/schema.py,sha256=8nwLYW6J-RIMbKjt0BZK3zlktZZzBYXabGFlaQsecCQ,8538
-schemez/schemadef/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schemez/schemadef/schemadef.py,sha256=TLfcmCxPLZEvScxuIMlss0QDRWtQNhxLQ8z2i0Linoc,3794
-schemez-0.2.1.dist-info/METADATA,sha256=sd3YrOY6JfwDjhkO9sidYWd8BhqhQDLxW0pmxrwG3_4,5891
-schemez-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-schemez-0.2.1.dist-info/licenses/LICENSE,sha256=AteGCH9r177TxxrOFEiOARrastASsf7yW6MQxlAHdwA,1078
-schemez-0.2.1.dist-info/RECORD,,