overture-schema-system 0.1.1.dev0__py3-none-any.whl

overture/schema/system/__init__.py

@@ -0,0 +1,180 @@
+r"""
+Foundational types at the base of the Overture schema system.
+
+A set of numeric and geometric types, constraint rules, and Pydantic model classes, and annotations
+that can be used to create strongly-typed, predictably validated, data.
+
+Subpackages
+-----------
+- :mod:`doc <overture.schema.system.doc>`. Documentation support for things that are hard to
+  document in Python, such as enumeration members.
+- :mod:`feature <overture.schema.system.feature>` The `Feature` type, a Pydantic model type for
+  geospatial data whose JSON Schema and serialized JSON representation are compatible with GeoJSON.
+- :mod:`field_constraint <overture.schema.system.field_constraint>` Constraints that can be
+  annotated onto Pydantic model fields to force them to conform to well-known rules, for example "a
+  collection that contains unique items" or "a string that is a valid country code".
+- :mod:`geometric <overture.schema.system.geometric>` Geometric types, including `Geometry` and
+  `BBox`.
+- :mod:`json_schema <overture.schema.system.json_schema>` Overture-flavored JSON Schema generation
+  for Pydantic models.
+- :mod:`model_constraint <overture.schema.system.model_constraint>` Constraints that can be
+  decorated onto Pydantic model classes to add cross-field validation rules, for example "these two
+  fields are mutually-exclusive" or "if this field is set, then that field must also be set".
+- :mod:`numeric <overture.schema.system.numeric>` Portable numeric types with specific bit widths,
+  for example `int32` and `float64`.
+- :mod:`optionality` <overture.schema.system.optionality>` The `Omitable` type hint, syntax sugar to
+  help a Pydantic model's optional fields behave closer to JSON Schema semantics.
+- :mod:`ref <overture.schema.system.ref>` Unique IDs and annotations to describe relationships
+  between models based on unique IDs. (*i.e.*, foreign key relationships).
+- :mod:`string <overture.schema.system.string>` String types with built-in validation to conform to
+  well-known patterns, for example a country code, a hexadecimal color code, a language tag, or just
+  a string that doesn't contain whitespace.
+
+
+Features
+--------
+- Integrates with Overture code generation tools, making Pydantic models built using these types
+  portable across different programming languages (*e.g.*, Java) and serialization formats (*e.g.*,
+  Parquet.)
+- Tightly integrated with Pydantic's JSON Schema system, providing rich JSON Schemas and maximum
+  parity between Pydantic, generated JSON Schemas, and Overture's code generation tools.
+- First-class support for geospatial data using the geometry types and the
+  `overture.schema.system.feature.Feature` class.
+- Conditional fields and validation on relationships between fields (*e.g.*, if the type field
+  contains "region", then region code field must also be set).
+- Constraint rules produce detailed and consistent error messages with useful domain knowledge.
+- Reference annotations allow foreign key relationships between models to be described.
+
+Examples
+--------
+Make a simple Pydantic model using the fundamental types from this package and verify that it
+rejects invalid input:
+
+>>> from pydantic import BaseModel, ValidationError
+>>> from overture.schema.system.numeric import uint32;
+>>> from overture.schema.system.string import SnakeCaseString;
+>>> class MyModel(BaseModel):
+...     index: uint32
+...     id: SnakeCaseString
+>>> try:
+...     MyModel(index=-1, id="FooBar")  # Index is not a valid uint32 (negative), "FooBar" is not snake_case
+... except ValidationError:
+...    print("Validation failed")
+Validation failed
+
+Valid inputs to the same model are accepted:
+
+>>> from pydantic import BaseModel, ValidationError
+>>> from overture.schema.system.numeric import uint32;
+>>> from overture.schema.system.string import SnakeCaseString;
+>>> class MyModel(BaseModel):
+...     index: uint32
+...     id: SnakeCaseString
+>>> my_model = MyModel(index=42, id="foo_bar")
+>>> assert my_model.index == 42
+>>> assert my_model.id == "foo_bar"
+
+Combine Overture and Pydantic constraints on a single field:
+
+>>> from typing import Annotated
+>>> from pydantic import BaseModel, Field
+>>> from overture.schema.system.field_constraint import UniqueItemsConstraint
+>>> class MyModel(BaseModel):
+...    # Unique tags: at least one is required, at most 10 are allowed.
+...    tags: Annotated[
+...             list[str],
+...             UniqueItemsConstraint()
+...          ] = Field(..., min_length=1, max_length=10, description="Unique tags")
+
+Create a custom regular expression pattern constraint:
+
+>>> from overture.schema.system.field_constraint import PatternConstraint
+>>> OsmIdConstraint = PatternConstraint(
+...     pattern=r"^[nwr]\d+$",
+...     error_message="invalid OSM ID format: {value}. Must be n123, w123, or r123."
+... )
+>>>
+>>> from pydantic import BaseModel, Field
+>>> class MyModel(BaseModel):
+...     osm_id: Annotated[str, OsmIdConstraint] = Field(..., description="OSM entity ID")
+>>>
+>>> from pydantic import ValidationError
+>>> try:
+...    MyModel(**{"osm_id": "foo"})
+... except ValidationError as e:
+...    assert "invalid OSM ID format: foo. Must be n123, w123, or r123." in str(e)
+...    print("Validation failed")
+Validation failed
+
+Use decorators to add complex multi-field constraints. In this example, a validation rule is added
+saying that at least one of the two optional fields is required to have an explicit value, but
+they aren't both required to:
+
+>>> from pydantic import BaseModel, ValidationError
+>>> from overture.schema.system.model_constraint import require_any_of
+>>>
+>>> @require_any_of("foo", "bar")
+... class MyModel(BaseModel):
+...     foo: int | None = None
+...     bar: str | None = None
+...
+>>> MyModel(foo=42, bar="hello")    # validates OK
+MyModel(foo=42, bar='hello')
+>>> MyModel(foo=42)                 # validates OK
+MyModel(foo=42, bar=None)
+>>> MyModel(bar="hello")            # validates OK
+MyModel(foo=None, bar='hello')
+>>>
+>>> try:
+...     MyModel()
+... except ValidationError as e:
+...    assert "at least one of these fields must be set to a value other than None, but none are: foo, bar" in str(e)
+...    print("Validation failed (no fields set)")
+Validation failed (no fields set)
+>>> try:
+...     MyModel(foo=None, bar=None)
+... except ValidationError as e:
+...    assert "at least one of these fields must be set to a value other than None, but none are: foo, bar" in str(e)
+...    print("Validation failed (all fields None)")
+Validation failed (all fields None)
+
+Describe a foreign key relationship between two models where one model has a field that contains the
+unique identifier of another model.
+
+>>> from typing import Annotated
+>>> from overture.schema.system.ref import Id, Identified, Reference, Relationship
+>>> class Park(Identified):
+...     pass
+>>> class ParkBench(Identified):
+...    park_id: Annotated[Id, Reference(Relationship.COMPOSITION, Park, role="located_in")]
+"""
+
+from . import (
+    doc,
+    feature,
+    field_constraint,
+    geometric,
+    json_schema,
+    metadata,
+    model_constraint,
+    numeric,
+    optionality,
+    ref,
+    string,
+)
+from .create_model import create_model
+
+__all__ = [
+    "create_model",
+    "doc",
+    "feature",
+    "field_constraint",
+    "geometric",
+    "json_schema",
+    "metadata",
+    "model_constraint",
+    "numeric",
+    "optionality",
+    "ref",
+    "string",
+]

overture/schema/system/_json_schema.py

@@ -0,0 +1,404 @@
+from collections.abc import Callable
+from typing import Any, TypeVar, cast, get_origin
+
+from pydantic import ConfigDict
+from pydantic.json_schema import JsonSchemaValue, JsonValue
+
+
+def get_static_json_schema_extra(config: ConfigDict) -> JsonSchemaValue:
+    """
+    Get the static *extra* JSON Schema from a Pydantic model config dictionary.
+
+    Parameters
+    ----------
+    config : ConfigDict
+        Config dictionary
+
+    Returns
+    -------
+    JsonSchemaValue
+        Extra JSON Schema from `config`, or `{}` if `config` has no extra JSON Schema
+
+    Raises
+    ------
+    ValueError
+        If `config` contains dynamic extra JSON Schema (`JsonSchemaExtraCallable`)
+    """
+    json_schema: (
+        JsonSchemaValue
+        | Callable[[JsonSchemaValue], None]
+        | Callable[[JsonSchemaValue, type[Any]], None]
+        | None
+    ) = config.get("json_schema_extra", None)
+    if json_schema is None:
+        json_schema = {}
+        config["json_schema_extra"] = json_schema
+    else:
+        origin = cast(type, get_origin(JsonSchemaValue))
+        if isinstance(json_schema, origin):
+            return cast(JsonSchemaValue, json_schema)
+        else:
+            raise ValueError(
+                f'expected value of config\'s "json_schema_extra" key to be a `{origin.__name__}`, but it is a `{type(json_schema).__name__}`'
+            )
+    return json_schema
+
+
+def put_all_of(json_schema: JsonSchemaValue, operands: list[JsonSchemaValue]) -> None:
+    """
+    Insert an `"allOf"` schema composition clause into a JSON Schema.
+
+    If the target JSON Schema already contains an `"allOf"` clause, the `operands` are added to the
+    existing `"allOf"` clause.
+
+    Parameters
+    ----------
+    json_schema : JsonSchemaValue
+        Target JSON Schema
+    operands : list[JsonSchemaValue]
+        Non-empty list of operands for the `"allOf"` clause
+    """
+    _verify_json_schema_value(("json_schema", json_schema))
+    _verify_operands_not_empty(JsonSchemaValue, operands)
+    if "allOf" not in json_schema:
+        json_schema["allOf"] = cast(JsonValue, operands)
+    else:
+        maybe_list = json_schema["allOf"]
+        if isinstance(maybe_list, list):
+            maybe_list += operands
+        else:
+            raise ValueError(
+                f'expected value of "allOf" key to be a `list`, but it is a `{type(maybe_list).__name__}` in the JSON Schema {json_schema}'
+            )
+
+
+def put_any_of(json_schema: JsonSchemaValue, operands: list[JsonSchemaValue]) -> None:
+    """
+    Insert an `"anyOf"` schema composition clause into a JSON Schema.
+
+    If the target JSON Schema already contains an `"anyOf"` clause, the existing clause is retained
+    and the new one is added by adding both new and existing `"anyOf"` clauses to an `"allOf"`
+    clause using `put_all_of`.
+
+    Parameters
+    ----------
+    json_schema : JsonSchemaValue
+        Target JSON Schema
+    operands : list[JsonSchemaValue]
+        Non-empty list of operands for the `"anyOf"` clause
+    """
+    _verify_json_schema_value(("json_schema", json_schema))
+    _verify_operands_not_empty(JsonSchemaValue, operands)
+    prev: JsonSchemaValue = {}
+    try_move("anyOf", json_schema, prev)
+    if not prev:
+        json_schema["anyOf"] = cast(JsonValue, operands)
+    else:
+        put_all_of(json_schema, [prev, {"anyOf": cast(JsonValue, operands)}])
+
+
+def put_one_of(json_schema: JsonSchemaValue, operands: list[JsonSchemaValue]) -> None:
+    """
+    Insert a `"oneOf"` schema composition clause into a JSON Schema.
+
+    If the target JSON Schema already contains a `"oneOf"` clause, the existing clause is retained
+    and the new one is added by adding both new and existing `"oneOf"` clauses to an `"allOf"`
+    clause using `put_all_of`.
+
+    Parameters
+    ----------
+    json_schema : JsonSchemaValue
+        Target JSON Schema
+    operands : list[JsonSchemaValue]
+        Non-empty list of operands for the `"allOf"` clause
+    """
+    _verify_json_schema_value(("json_schema", json_schema))
+    _verify_operands_not_empty(JsonSchemaValue, operands)
+    prev: JsonSchemaValue = {}
+    try_move("oneOf", json_schema, prev)
+    if not prev:
+        json_schema["oneOf"] = cast(JsonValue, operands)
+    else:
+        put_all_of(json_schema, [prev, {"oneOf": cast(JsonValue, operands)}])
+
+
+def put_not(json_schema: JsonSchemaValue, operand: JsonSchemaValue) -> None:
+    """
+    Insert a `"not"` schema composition clause into a JSON Schema.
+
+    If the target JSON Schema already contains a `"not"` clause, the existing clause is retained
+    and the new one is added by refactoring the schema. Several refactorings are possible but in
+    all cases the `"not"` clause will remain and will contain an `"anyOf"` clause as its direct
+    child, and `operand` as a child of the `"anyOf"` clause.
+
+    Parameters
+    ----------
+    json_schema : JsonSchemaValue
+        Target JSON Schema
+    operand : JsonSchemaValue
+        Operand for the `"not"` clause
+    """
+    _verify_json_schema_value(("json_schema", json_schema), ("operand", operand))
+    prev: JsonSchemaValue = {}
+    try_move("not", json_schema, prev)
+
+    # Simple case: if the JSON didn't already have a "not", we just add it.
+    if not prev:
+        json_schema["not"] = operand
+        return
+
+    not_schema = prev["not"]
+    if not isinstance(not_schema, cast(type, get_origin(JsonSchemaValue))):
+        raise TypeError(
+            f'expected value of "not" key to be a `JsonSchemaValue`, but {repr(not_schema)} has type `{type(not_schema).__name__}` in the JSON Schema {json_schema}'
+        )
+    not_schema = cast(JsonSchemaValue, not_schema)
+
+    # Next simplest case: the only child of the "not" is "anyOf".
+    if len(not_schema) == 1 and "anyOf" in not_schema:
+        not_any_of_schema = not_schema["anyOf"]
+        if not isinstance(not_any_of_schema, list):
+            raise ValueError(
+                f'expected value of "anyOf" key under "not" to be a `list`, but is a {type(not_any_of_schema).__name__} in the JSON Schema {json_schema}'
+            )
+        not_any_of_schema.append(operand)
+        json_schema["not"] = not_schema
+        return
+
+    # Most complex case: "not" either contains multiple keys, or a key that's not "anyOf".
+    json_schema["not"] = {
+        "anyOf": [
+            not_schema,
+            operand,
+        ]
+    }
+
+
+def put_if(
+    json_schema: JsonSchemaValue,
+    condition: JsonSchemaValue | None,
+    when_true: JsonSchemaValue | None,
+    when_false: JsonSchemaValue | None = None,
+) -> None:
+    """
+    Insert `"if"`/`"then"` conditional schema application elements with an optional `"else"` clause
+    into a JSON Schema.
+
+    If the target JSON Schema does not already contain an `"if"`/`"then"`/`"else"` elements, the new
+    elements are added directly into the JSON Schema. If it does already contain them, then the
+    existing `"if"`/`"then"`/`"else"` elements are moved into a separate object, the new ones are
+    inserted into a second separate object, and both of these objects are added into the JSON
+    Schema using `put_all_of`.
+
+    Parameters
+    ----------
+    json_schema : JsonSchemaValue
+        Target JSON Schema
+    condition : JsonSchemaValue | None
+        Operand for the `"if"` clause
+    when_true : JsonSchemaValue | None
+        Operand for the `"then"` clause
+    when_false : JsonSchemaValue | None
+        Operand for the `"else"` clause
+    """
+    _verify_json_schema_value(("json_schema", json_schema))
+    if condition is not None:
+        _verify_json_schema_value(("condition", condition))
+    if when_true is not None:
+        _verify_json_schema_value(("when_true", when_true))
+    if when_false is not None:
+        _verify_json_schema_value(("when_false", when_false))
+
+    prev: JsonSchemaValue = {}
+    try_move("if", json_schema, prev)
+    try_move("then", json_schema, prev)
+    try_move("else", json_schema, prev)
+
+    def _put(dst: JsonSchemaValue) -> JsonSchemaValue:
+        if condition:
+            dst["if"] = condition
+        if when_true:
+            dst["then"] = when_true
+        if when_false:
+            dst["else"] = when_false
+        return dst
+
+    if not prev:
+        _put(json_schema)
+    else:
+        put_all_of(json_schema, [prev, _put({})])
+
+
+def put_required(json_schema: JsonSchemaValue, operands: list[str]) -> None:
+    """
+    Insert a `"required"` validation clause into a JSON Schema.
+
+    If the target JSON Schema already contains a `"required"` clause, the existing clause is
+    retained and `operands` is merged into it by appending the items that aren't already in the
+    `"required"` clause to the end of it, in the order in which they appear in `operands`.
+
+    Parameters
+    ----------
+    json_schema : JsonSchemaValue
+        Target JSON Schema
+    operands : list[str]
+        Operands for the `"required"` clause
+    """
+    _verify_json_schema_value(("json_schema", json_schema))
+    _verify_operands_not_empty(str, operands)
+    if "required" in json_schema:
+        required = json_schema["required"]
+    else:
+        required = []
+        json_schema["required"] = required
+    required += [p for p in operands if p not in required]
+
+
+def put_properties(
+    json_schema: JsonSchemaValue,
+    new_properties: JsonSchemaValue,
+) -> None:
+    """
+    Insert members into the `"properties"` applicator keyword within the schema for a value of type
+    `"object"`.
+
+    If the target JSON Schema already contains a `"properties"` clause, the new properties from
+    `new_properties` are merged into it. Otherwise, a new `"properties"` clause is inserted into
+    `json_schema` and all properties from `new_properties` are inserted into it.
+
+    Parameters
+    ----------
+    json_schema : JsonSchemaValue
+        Target JSON Schema
+    new_properties : JsonSchemaValue
+        New properties to add to the `"properties"` clause within `json_schema`
+
+    Raises
+    ------
+    ValueError
+        If a property entry in `new_properties` can't be merged into the `"properties"` clause of
+        `json_schema` because there's an existing `"properties"` clause that contains a property
+        with the same name but a different value
+    """
+    _verify_json_schema_value(
+        ("json_schema", json_schema), ("new_properties", new_properties)
+    )
+    origin = cast(type, get_origin(JsonSchemaValue))
+    if "properties" in json_schema:
+        properties = json_schema["properties"]
+        if not isinstance(properties, origin):
+            raise TypeError(
+                f'expected value of "properties" key to be a `JsonSchemaValue`, but {repr(properties)} has type `{type(properties).__name__}` in the JSON Schema {json_schema}'
+            )
+        already_in = True
+    else:
+        properties = {}
+        already_in = False
+    for k, v in new_properties.items():
+        if not isinstance(v, origin):
+            raise TypeError(
+                f"expected property value for {repr(k)} key to be a `JsonSchemaValue`, but {repr(v)} has type `{type(v).__name__}` in the new properties {repr(new_properties)}"
+            )
+        elif k not in properties:
+            properties[k] = v
+        else:
+            _merge(cast(JsonSchemaValue, v), properties[k], k)
+    if not already_in and properties:
+        json_schema["properties"] = properties
+
+
+def try_move(key: str, src: JsonSchemaValue, dst: JsonSchemaValue) -> None:
+    """
+    Move a key (that may not exist) from one JSON Schema to another one.
+
+    Removes the key `key` and its value from `src` and inserts them into `dst`. If `src` does not
+    contain the key `key`, nothing happens.
+
+    Parameters
+    ----------
+    key : str
+        Key to move from `src` to `dst`
+    src : JsonSchemaValue
+        Source JSON Schema from which to move `key` and its value
+    dst : JsonSchemaValue
+        Destination JSON Schema into which to move `key` and its value
+    """
+    try:
+        value = src[key]
+        dst[key] = value
+        del src[key]
+    except KeyError:
+        pass
+
+
+def required_non_null(aliases: list[str]) -> JsonSchemaValue:
+    """
+    Build a JSON Schema requiring listed properties to be present and non-null.
+
+    Combines `"required"` (property must exist) with a per-property
+    constraint `{"not": {"type": "null"}}` (value must not be null).
+
+    Parameters
+    ----------
+    aliases : list[str]
+        Non-empty list of JSON Schema property names to constrain
+
+    Returns
+    -------
+    JsonSchemaValue
+        Schema requiring each property to be present and non-null
+    """
+    _verify_operands_not_empty(str, aliases)
+    return {
+        "required": aliases,
+        "properties": {a: {"not": {"type": "null"}} for a in aliases},
+    }
+
+
+T = TypeVar("T", JsonSchemaValue, str)
+
+
+def _verify_json_schema_value(*candidates: tuple[str, JsonSchemaValue]) -> None:
+    origin = cast(type, get_origin(JsonSchemaValue))
+    for target in candidates:
+        if not isinstance(target[1], origin):
+            raise TypeError(
+                f"`{target[0]}` must be a `JsonSchemaValue` value, but {repr(target[1])} has type `{type(target[1]).__name__}`"
+            )
+
+
+def _verify_operands_not_empty(tp: type[T], operands: list[T]) -> None:
+    if not isinstance(operands, list):
+        raise TypeError(
+            f"`operands` must be a `list`, but {operands} has type `{type(operands).__name__}`"
+        )
+    if len(operands) == 0:
+        raise ValueError("`operands` cannot be empty, but it is")
+    origin = get_origin(tp)
+    if origin:
+        target = cast(type, origin)
+    else:
+        target = tp
+    mismatches = [a for a in operands if not isinstance(a, target)]
+    if mismatches:
+        raise TypeError(
+            "`operands` items must be `{target.__name__}` values, but these items are not: {mismatches}"
+        )
+
+
+def _merge(src: JsonSchemaValue, dst: JsonValue, *loc: str) -> None:
+    origin = cast(type, get_origin(JsonSchemaValue))
+    if not isinstance(dst, origin):
+        raise TypeError(
+            f"`put_properties` merge conflict: `dst` exists but `src` cannot be merged in because `dst` is not a `JsonSchemaValue` (full path: {repr(loc)}) (`dst` value {repr(dst)} has type `{type(dst).__name__}`)"
+        )
+    dst = cast(JsonSchemaValue, dst)
+    for k, v in src.items():
+        if k not in dst:
+            dst[k] = v
+        elif isinstance(v, origin):
+            _merge(cast(JsonSchemaValue, v), dst[k], *loc, k)
+        elif dst[k] != v:
+            raise ValueError(
+                f"`put_properties` merge conflict: `dst[{repr(k)}]={repr(dst[k])}` exists and does not equal `src[{repr(k)}]={repr(v)}` (full path: {repr(loc)})"
+            )

overture/schema/system/case.py

@@ -0,0 +1,26 @@
+"""PascalCase to snake_case conversion."""
+
+import re
+
+__all__ = ["to_snake_case"]
+
+_ACRONYM_BOUNDARY = re.compile(r"([A-Z]+)([A-Z][a-z])")
+_CAMEL_BOUNDARY = re.compile(r"([a-z0-9])([A-Z])")
+
+
+def to_snake_case(name: str) -> str:
+    """Convert PascalCase to snake_case.
+
+    Handles acronym runs correctly: "HTMLParser" becomes "html_parser",
+    not "h_t_m_l_parser".
+
+    >>> to_snake_case("HTMLParser")
+    'html_parser'
+    >>> to_snake_case("BuildingPart")
+    'building_part'
+    >>> to_snake_case("simple")
+    'simple'
+    """
+    name = _ACRONYM_BOUNDARY.sub(r"\1_\2", name)
+    name = _CAMEL_BOUNDARY.sub(r"\1_\2", name)
+    return name.lower()

overture/schema/system/create_model.py

@@ -0,0 +1,60 @@
+"""
+Dynamic Pydantic model creation with preservation of Overture metadata.
+"""
+
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+import pydantic
+
+from .metadata import Metadata
+
+ModelT = TypeVar("ModelT", bound=pydantic.BaseModel)
+
+
+def create_model(
+    model_name: str,
+    /,
+    *,
+    __config__: pydantic.ConfigDict | None = None,
+    __doc__: str | None = None,
+    __base__: type[ModelT] | tuple[type[ModelT], ...] | None = None,
+    __module__: str | None = None,
+    __validators__: dict[str, Callable[..., Any]] | None = None,
+    __cls_kwargs__: dict[str, Any] | None = None,
+    __qualname__: str | None = None,
+    __metadata__: Metadata | None = None,
+    **field_definitions: Any | tuple[str, Any],
+) -> type[ModelT]:
+    """
+    Dynamically create and return a new Pydantic model, preserving Overture metadata.
+
+    Use `create_model` to dynamically create a subclass of any `BaseModel` while preserving Overture
+    `Metadata`.
+
+    ⚠️ Use this function instead of `pydantic.create_model`, as the Pydantic version will not
+    preserve the metadata, which may result in your models not behaving as expected with Overture
+    schema tooling. ⚠️
+
+    If `__metadata__` is omitted or `None`, the metadata on the base model, if any, is propagated to
+    the new model. If a non-`None` value is provided for `__metadata__`, the new model receives the
+    new metadata and the metadata on the base model is not propagated.
+    """
+    model_class = pydantic.create_model(  # type: ignore[misc]
+        model_name,
+        __config__=__config__,
+        __doc__=__doc__,
+        __base__=__base__,  # type: ignore[arg-type]
+        __module__=__module__,  # type: ignore[arg-type]
+        __validators__=__validators__,
+        __cls_kwargs__=__cls_kwargs__,
+        __qualname__=__qualname__,
+        **field_definitions,
+    )
+    if __metadata__ is not None:
+        __metadata__.attach_to(model_class)
+    elif __base__ is not None:
+        prev = Metadata.retrieve_from(__base__, None)
+        if prev is not None:
+            prev.attach_to(model_class)
+    return model_class  # type: ignore[return-value]