StrictModel¶

@classmethod
def get_admin_marshall_config(
    cls: type[Model], *, phase: str, for_schema: bool
) -> dict[str, Any]:
    del for_schema
    return {
        "fields": ["__all__"],
        "exclude_read_only": phase in {"create", "update"},
        "primary_key_read_only": phase != "create",
        "exclude_autoincrement": phase == "create",
    }

@classmethod
def get_admin_marshall_class(
    cls: type[Model], *, phase: str, for_schema: bool = False
) -> type[marshalls.Marshall]:
    config = cls.get_admin_marshall_config(phase=phase, for_schema=for_schema)

    class AdminMarshall(marshalls.Marshall):
        marshall_config = marshalls.ConfigMarshall(model=cls, **config)

    AdminMarshall.__name__ = f"{cls.__name__}{phase.title()}AdminMarshall"
    return AdminMarshall

@classmethod
def get_admin_marshall_for_save(
    cls: type[Model], instance: Model | None = None, /, **kwargs: Any
) -> marshalls.Marshall:
    phase = "update" if instance is not None else "create"
    AdminMarshallClass = cls.get_admin_marshall_class(phase=phase, for_schema=False)
    return cast("marshalls.Marshall", AdminMarshallClass(instance, **kwargs))

@classmethod
def declarative(cls) -> typing.Any:
    """Return the generated SQLAlchemy declarative model class.

    Returns:
        typing.Any: Declarative SQLAlchemy model created from the Saffier
        model definition.
    """
    return cls.generate_model_declarative()

@classmethod
def generate_model_declarative(cls) -> typing.Any:
    """Transform the Saffier table into a SQLAlchemy declarative model.

    Returns:
        typing.Any: Declarative model class bound to the same SQLAlchemy
        table.
    """
    Base = cls.meta.registry.declarative_base

    # Build the original table
    fields = {"__table__": cls.table}

    # Generate base
    model_table = type(cls.__name__, (Base,), fields)

    # Make sure if there are foreignkeys, builds the relationships
    for column in cls.table.columns:
        if not column.foreign_keys:
            continue

        # Maps the relationships with the foreign keys and related names
        field = cls.fields.get(column.name)
        to = field.to.__name__ if inspect.isclass(field.to) else field.to
        mapped_model: Mapped[to] = relationship(to)  # type: ignore

        # Adds to the current model
        model_table.__mapper__.add_property(f"{column.name}_relation", mapped_model)

    return model_table

def _update_auto_now_fields(self, values: Any, fields: Any) -> Any:
    """Refresh `auto_now` date and datetime fields inside a payload.

    Returns:
        Any: Updated payload dictionary.
    """
    for k, v in fields.items():
        if isinstance(v, (DateField, DateTimeField)) and v.auto_now:
            values[k] = v.validator.get_default_value()  # type: ignore
    return values

def _resolve_value(self, value: typing.Any) -> typing.Any:
    """Normalize one value for storage or query generation.

    Dictionaries are JSON-encoded, enums are converted to their member
    names, and every other value is returned unchanged.

    Args:
        value (typing.Any): Raw value supplied by model or queryset code.

    Returns:
        typing.Any: Normalized value suitable for downstream processing.
    """
    if isinstance(value, dict):
        return dumps(
            value,
            option=OPT_SERIALIZE_NUMPY | OPT_OMIT_MICROSECONDS,
        ).decode("utf-8")
    elif isinstance(value, Enum):
        return value.name
    return value

@staticmethod
def _is_model_ref_instance(value: Any) -> bool:
    return (
        hasattr(value, "model_dump")
        and hasattr(value.__class__, "__model_ref_fields__")
        and hasattr(value.__class__, "__related_name__")
    )

@classmethod
def resolve_model_ref_field_name(cls, ref_type: type[Any]) -> str:
    """Return the `RefForeignKey` field that accepts `ref_type` references.

    Args:
        ref_type: Concrete `ModelRef` subclass being supplied positionally.

    Returns:
        str: Name of the field that can store references of this type.

    Raises:
        ModelReferenceError: If no `RefForeignKey` on the model accepts the
            provided reference type.
    """
    for field_name, field in cls.fields.items():
        model_ref = getattr(field, "model_ref", None)
        if model_ref is not None and issubclass(ref_type, model_ref):
            return field_name
    raise saffier.ModelReferenceError(
        detail=(
            f"No RefForeignKey on '{cls.__name__}' accepts model references of type "
            f"'{ref_type.__name__}'."
        )
    )

@classmethod
def merge_model_refs(
    cls,
    model_refs: Sequence[Any],
    kwargs: dict[str, Any] | None = None,
) -> dict[str, Any]:
    """Merge positional `ModelRef` objects into a keyword payload.

    Saffier reserves positional constructor arguments for model reference
    objects so callers can write `Article(tag_ref, author_ref, title="...")`
    and still end up with a normal keyword payload keyed by the owning
    `RefForeignKey` fields.

    Args:
        model_refs: Positional constructor arguments.
        kwargs: Existing keyword payload.

    Returns:
        dict[str, Any]: Normalized keyword payload including merged model
        references.

    Raises:
        TypeError: If any positional argument is not a model reference
            instance.
    """
    payload = dict(kwargs or {})
    if not model_refs:
        return payload

    for model_ref in model_refs:
        if not cls._is_model_ref_instance(model_ref):
            raise TypeError("Positional arguments are reserved for ModelRef instances.")

        field_name = cls.resolve_model_ref_field_name(model_ref.__class__)
        existing = payload.get(field_name)
        if existing is None:
            payload[field_name] = [model_ref]
        elif isinstance(existing, Sequence) and not isinstance(
            existing, (str, bytes, bytearray)
        ):
            payload[field_name] = [*existing, model_ref]
        else:
            payload[field_name] = [existing, model_ref]
    return payload

def setup_model_fields_from_kwargs(
    self,
    model_refs: Sequence[Any],
    kwargs: dict[str, Any],
) -> Any:
    """Normalize constructor input and assign values onto the instance.

    Positional `ModelRef` arguments are merged into the keyword payload,
    composite or virtual inputs are expanded through field hooks, and each
    resulting value is assigned using normal model attribute semantics so
    relation-aware setters still run.

    Args:
        model_refs: Positional model-reference objects.
        kwargs: Raw keyword payload supplied to the constructor.

    Returns:
        Any: Normalized payload after assignment.

    Raises:
        ValueError: If the payload contains unknown public attributes.
    """
    kwargs = self.__class__.merge_model_refs(model_refs, kwargs)
    kwargs = self.__class__.normalize_field_kwargs(kwargs)

    if "pk" in kwargs:
        self.pk = kwargs.pop("pk")

    for key, value in kwargs.items():
        if key not in self.fields and not hasattr(self, key):
            raise ValueError(f"Invalid keyword {key} for class {self.__class__.__name__}")

        if key in self.get_plain_model_fields():
            value = self.validate_plain_field_value(key, value)

        # Set model field and add to the kwargs dict
        setattr(self, key, value)
        kwargs[key] = value
    return kwargs

@classmethod
def get_plain_model_fields(cls) -> dict[str, dict[str, Any]]:
    return cast("dict[str, dict[str, Any]]", getattr(cls, "__plain_model_fields__", {}))

@classmethod
def _matches_plain_annotation(cls, annotation: Any, value: Any) -> bool:
    del cls
    if annotation in (Any, None):
        return True

    origin = get_origin(annotation)
    if origin is None:
        if annotation is type(None):
            return value is None
        if isinstance(annotation, type):
            if annotation is int and isinstance(value, bool):
                return False
            return isinstance(value, annotation)
        return True

    if str(origin) in {"typing.Union", "types.UnionType"}:
        return any(
            SaffierBaseModel._matches_plain_annotation(arg, value)
            for arg in get_args(annotation)
        )

    if origin in (list, set, tuple, dict):
        return isinstance(value, origin)

    if origin in (Sequence,):
        return isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray))

    if isinstance(origin, type):
        return isinstance(value, origin)
    return True

@classmethod
def validate_plain_field_value(cls, key: str, value: Any) -> Any:
    plain_field = cls.get_plain_model_fields().get(key)
    if plain_field is None:
        return value
    annotation = plain_field.get("annotation")
    if cls._matches_plain_annotation(annotation, value):
        return value
    raise ValidationError(text=f"Invalid value for '{key}'.", code="type")

@classmethod
def normalize_field_kwargs(cls, kwargs: dict[str, Any] | None = None) -> dict[str, Any]:
    """Normalize constructor or persistence payloads through field hooks.

    Every field may rewrite or expand incoming values before validation. This
    is how composite fields, foreign keys, and other virtual helpers expose a
    convenient high-level API while still producing a concrete payload.

    Args:
        kwargs: Input payload keyed by logical field name.

    Returns:
        dict[str, Any]: Normalized payload.
    """
    payload = dict(kwargs or {})
    for field_name, field in cls.fields.items():
        field.modify_input(field_name, payload)
    return payload

@classmethod
def get_model_engine_name(cls) -> str | None:
    """Return the configured engine name for the model, if any.

    Returns:
        str | None: Explicit model engine name, inherited registry default,
            or `None` when engine support is disabled.
    """
    configured = getattr(cls.meta, "model_engine", None)
    if configured is False:
        return None
    if configured is None:
        configured = getattr(getattr(cls.meta, "registry", None), "model_engine", None)
    if configured in (None, False):
        return None
    if isinstance(configured, str):
        return configured
    return cast("str", getattr(configured, "name", None))

@classmethod
def get_model_engine(cls) -> "ModelEngine | None":
    """Resolve and return the configured engine adapter for the model."""
    configured = getattr(cls.meta, "model_engine", None)
    if configured is False:
        return None
    if configured is None:
        configured = getattr(getattr(cls.meta, "registry", None), "model_engine", None)
    return resolve_model_engine(configured)

@classmethod
def require_model_engine(cls) -> "ModelEngine":
    """Return the model engine or raise when none is configured."""
    engine = cls.get_model_engine()
    if engine is None:
        raise ImproperlyConfigured(f"Model '{cls.__name__}' has no model engine configured.")
    return engine

@classmethod
def get_engine_model_class(cls, *, mode: str = "projection") -> type[Any]:
    """Return the engine-backed class for the model."""
    return cls.require_model_engine().get_model_class(cls, mode=mode)

@classmethod
def engine_validate(cls, value: Any, *, mode: str = "validation") -> Any:
    """Validate external data through the configured engine adapter."""
    return cls.require_model_engine().validate_model(cls, value, mode=mode)

@classmethod
def from_engine(cls, value: Any, *, exclude_unset: bool = True) -> "Self":
    """Build a Saffier model instance from an engine-backed value.

    Args:
        value: Engine-backed object or input payload accepted by the engine.
        exclude_unset: Whether engine defaults absent from the original
            input should be omitted from the Saffier constructor payload.

    Returns:
        Self: New Saffier model instance.
    """
    payload = cls.require_model_engine().to_saffier_data(
        cls,
        value,
        exclude_unset=exclude_unset,
    )
    return cls(**payload)

@classmethod
def engine_json_schema(cls, *, mode: str = "projection", **kwargs: Any) -> dict[str, Any]:
    """Return the engine-generated JSON schema for the model."""
    return cls.require_model_engine().json_schema(cls, mode=mode, **kwargs)

def to_engine_model(
    self,
    *,
    include: EngineIncludeExclude = None,
    exclude: EngineIncludeExclude = None,
    exclude_none: bool = False,
) -> Any:
    """Project the current instance into the configured engine model."""
    return (
        type(self)
        .require_model_engine()
        .project_model(
            self,
            include=include,
            exclude=exclude,
            exclude_none=exclude_none,
        )
    )

def engine_dump(
    self,
    *,
    include: EngineIncludeExclude = None,
    exclude: EngineIncludeExclude = None,
    exclude_none: bool = False,
) -> dict[str, Any]:
    """Serialize the engine-backed projection of the current instance."""
    return (
        type(self)
        .require_model_engine()
        .dump_model(
            self,
            include=include,
            exclude=exclude,
            exclude_none=exclude_none,
        )
    )

def engine_dump_json(
    self,
    *,
    include: EngineIncludeExclude = None,
    exclude: EngineIncludeExclude = None,
    exclude_none: bool = False,
) -> str:
    """Serialize the engine-backed projection of the current instance to JSON."""
    return (
        type(self)
        .require_model_engine()
        .dump_model_json(
            self,
            include=include,
            exclude=exclude,
            exclude_none=exclude_none,
        )
    )

async def _persist_model_references(self, field_names: set[str] | None = None) -> None:
    """Persist staged `RefForeignKey` values after a successful save.

    Args:
        field_names: Optional subset of reference fields to persist.
    """
    for field_name, field in self.fields.items():
        if not getattr(field, "is_model_reference", False):
            continue
        if field_names is not None and field_name not in field_names:
            continue
        if field_name not in self.__dict__:
            continue
        await field.persist_references(self, self.__dict__[field_name])

async def _persist_related_fields(self, field_names: set[str] | None = None) -> None:
    """Persist staged reverse-relation values after the model is saved.

    Args:
        field_names: Optional subset of reverse relation names to flush.
    """
    for field_name in self.meta.related_fields:
        if field_names is not None and field_name not in field_names:
            continue
        if field_name not in self.__dict__:
            continue
        value = self.__dict__[field_name]
        save_related = getattr(value, "save_related", None)
        if callable(save_related):
            await save_related()

@staticmethod
def _normalize_identifier_value(value: Any) -> Any:
    if hasattr(value, "__db_model__"):
        return getattr(value, "pk", None)
    return value

def _pk_values(self) -> dict[str, Any]:
    return {
        field_name: self._normalize_identifier_value(getattr(self, field_name, None))
        for field_name in type(self).pknames
    }

def _instance_transaction(self, *, force_rollback: bool = False, **kwargs: Any) -> Any:
    return self.database.transaction(force_rollback=force_rollback, **kwargs)

def join_identifiers_to_string(self, *, sep: str = ", ", sep_inner: str = "=") -> str:
    pairs = [
        f"{field_name}{sep_inner}{self._normalize_identifier_value(getattr(self, field_name, None))}"
        for field_name in self.identifying_db_fields
    ]
    return sep.join(pairs)

@classmethod
def get_real_class(cls) -> type["Model"]:
    if getattr(cls, "is_proxy_model", False):
        return cast("type[Model]", cls.parent)
    return cast("type[Model]", cls)

def create_model_key(self) -> tuple[Any, ...]:
    """Create a stable identity tuple for recursion guards.

    Returns:
        tuple[Any, ...]: Tuple containing the model class and identifying
        values.
    """
    return (
        self.__class__,
        *(
            self._normalize_identifier_value(getattr(self, field_name, None))
            for field_name in self.identifying_db_fields
        ),
    )

def identifying_clauses(
    self,
    *,
    table: sqlalchemy.Table | None = None,
    fields: Sequence[str] | None = None,
) -> list[Any]:
    """Build equality clauses that uniquely identify the current instance.

    Args:
        table: Optional table object to target instead of the active instance
            table.
        fields: Optional subset of identifying fields to include.

    Returns:
        list[Any]: SQLAlchemy boolean expressions suitable for `WHERE`.
    """
    active_table = table or self.table
    clauses = []
    for field_name in tuple(fields or self.identifying_db_fields):
        column = getattr(active_table.c, field_name, None)
        if column is None:
            continue
        clauses.append(
            column == self._normalize_identifier_value(getattr(self, field_name, None))
        )
    return clauses

def _has_loaded_db_fields(self) -> bool:
    return all(
        field_name in self.__dict__
        for field_name, field in self.fields.items()
        if field.has_column()
    )

@classmethod
def get_active_class_schema(cls) -> str | None:
    """Return the schema pinned directly on the model class.

    Returns:
        str | None: Class-level schema override, if present.
    """
    return cast("str | None", getattr(cls, "__using_schema__", None))

def get_active_instance_schema(self) -> str | None:
    """Return the schema currently active for this instance.

    Instance-level overrides win over cached table schema, which in turn wins
    over the class-level override.

    Returns:
        str | None: Active schema for this instance.
    """
    explicit = self.__dict__.get("__using_schema__", None)
    if explicit is not None:
        return cast("str | None", explicit)
    table = self.__dict__.get("_table", None)
    if table is not None:
        return cast("str | None", getattr(table, "schema", None))
    return self.__class__.get_active_class_schema()

async def load_recursive(
    self,
    only_needed: bool = False,
    only_needed_nest: bool = False,
    _seen: set[tuple[Any, ...]] | None = None,
) -> None:
    """Load the instance and recurse through already-linked FK relations.

    The method is careful to avoid infinite loops by tracking visited model
    identities while traversing the object graph.

    Args:
        only_needed: Whether to skip reloading when DB-backed fields are
            already populated.
        only_needed_nest: Whether nested relations should stop after the
            current object was already fully loaded.
        _seen: Internal recursion guard keyed by model identity.
    """
    model_key = self.create_model_key()
    if _seen is None:
        _seen = {model_key}
    elif model_key in _seen:
        return
    else:
        _seen.add(model_key)

    was_loaded = self._has_loaded_db_fields()
    if self.can_load:
        await self.load(only_needed=only_needed)

    if only_needed_nest and was_loaded:
        return

    for field_name in self.meta.foreign_key_fields:
        value = getattr(self, field_name, None)
        if value is not None and hasattr(value, "load_recursive"):
            await value.load_recursive(
                only_needed=only_needed,
                only_needed_nest=True,
                _seen=_seen,
            )

def get_instance_name(self) -> str:
    """Return the lowercase class name used by relation helpers.

    Returns:
        str: Lowercase model class name.
    """
    return self.__class__.__name__.lower()

@classmethod
def _copy_model_definitions(
    cls,
    *,
    registry: "saffier.Registry | None" = None,
    unlink_same_registry: bool = True,
) -> dict[str, Any]:
    """Copy fields and managers for dynamic model cloning.

    Relation fields may be rewritten as string references when the target
    registry is still under construction so copied models do not retain live
    references back into the source registry.

    Args:
        registry: Optional destination registry receiving the copy.
        unlink_same_registry: Whether relations inside the same source
            registry should be rewritten as string references.

    Returns:
        dict[str, Any]: Definitions suitable for dynamic model creation.
    """
    from saffier.core.db.fields.base import ForeignKey, ManyToManyField

    definitions: dict[str, Any] = {}
    source_registry = getattr(cls.meta, "registry", None)
    existing_annotations = dict(getattr(cls, "__annotations__", {}))
    manager_annotations: dict[str, Any] = {}

    for field_name, field in cls.fields.items():
        if getattr(field, "no_copy", False):
            continue
        field_copy = copy.copy(field)
        if hasattr(field_copy, "_target"):
            delattr(field_copy, "_target")

        if source_registry not in (None, False):
            if isinstance(field_copy, ForeignKey):
                target = field.target
                if getattr(target.meta, "registry", None) is source_registry:
                    if unlink_same_registry:
                        field_copy.to = target.__name__
                    elif registry is not None:
                        field_copy.related_name = False
            elif isinstance(field_copy, ManyToManyField):
                target = field.target
                if (
                    getattr(target.meta, "registry", None) is source_registry
                    and unlink_same_registry
                ):
                    field_copy.to = target.__name__
                through = getattr(field_copy, "through", None)
                if (
                    isinstance(through, type)
                    and getattr(through.meta, "registry", None) is source_registry
                    and unlink_same_registry
                ):
                    field_copy.through = through.__name__

        definitions[field_name] = field_copy

    for manager_name in getattr(cls.meta, "managers", []):
        manager = getattr(cls, manager_name, None)
        if isinstance(manager, Manager):
            definitions[manager_name] = copy.copy(manager)
            manager_annotations[manager_name] = existing_annotations.get(
                manager_name,
                ClassVar[Any],
            )

    if manager_annotations:
        definitions["__annotations__"] = {
            **existing_annotations,
            **manager_annotations,
        }

    return definitions

@classmethod
def copy_saffier_model(
    cls,
    registry: "saffier.Registry | None" = None,
    name: str = "",
    unlink_same_registry: bool = True,
    on_conflict: str = "error",
) -> type["Model"]:
    """Create a detached copy of the model class with copied field state.

    The copy is used by migration preparation, proxy generation, and tests
    that need to attach the same logical model definition to another
    registry. Field instances are copied so later mutations on the copied
    model do not leak back into the original model definition.

    Args:
        registry: Optional registry to immediately attach the copied model
            to.
        name: Optional replacement class name.
        unlink_same_registry: Whether same-registry relations should be
            rewritten as string references during the copy.
        on_conflict: Conflict strategy used if `registry` already contains a
            model with the target name.

    Returns:
        type[Model]: The detached or newly attached copied model class.
    """
    existing_annotations = dict(getattr(cls, "__annotations__", {}))
    definitions = {
        key: value
        for key, value in cls.__dict__.items()
        if key not in _MODEL_COPY_EXCLUDED_ATTRS and not key.startswith("__")
    }
    definitions.update(
        cls._copy_model_definitions(
            registry=registry, unlink_same_registry=unlink_same_registry
        )
    )
    manager_annotations = dict(definitions.get("__annotations__", {}))
    for manager_name, value in definitions.items():
        if isinstance(value, Manager):
            manager_annotations.setdefault(
                manager_name,
                existing_annotations.get(manager_name, ClassVar[Any]),
            )
    if manager_annotations:
        definitions["__annotations__"] = {
            **existing_annotations,
            **manager_annotations,
        }
    definitions["__skip_registry__"] = True

    meta = type(
        "Meta",
        (),
        {
            "registry": False,
            "tablename": getattr(cls.meta, "tablename", None),
            "table_prefix": getattr(cls.meta, "table_prefix", None),
            "unique_together": list(getattr(cls.meta, "unique_together", []) or []),
            "indexes": list(getattr(cls.meta, "indexes", []) or []),
            "constraints": list(getattr(cls.meta, "constraints", []) or []),
            "reflect": getattr(cls.meta, "reflect", False),
            "abstract": getattr(cls.meta, "abstract", False),
            "model_engine": getattr(cls.meta, "model_engine", None),
            "is_tenant": getattr(cls.meta, "is_tenant", None),
            "register_default": getattr(cls.meta, "register_default", None),
        },
    )

    copied_model = create_saffier_model(
        name or cls.__name__,
        cls.__module__,
        __definitions__=definitions,
        __metadata__=meta,
        __qualname__=cls.__qualname__,
        __bases__=cls.__bases__,
    )
    copied_model.database = getattr(cls, "database", None)
    copied_model.__using_schema__ = getattr(cls, "__using_schema__", None)

    if registry is None:
        copied_model.meta.registry = False
        return copied_model
    return copied_model.add_to_registry(registry, on_conflict=on_conflict)

@classmethod
def real_add_to_registry(
    cls,
    *,
    registry: "saffier.Registry",
    name: str = "",
    database: bool | Any | str = "keep",
    on_conflict: str = "error",
) -> type["Model"]:
    """Attach a copied model class to another registry.

    This is the internal implementation behind `add_to_registry()`. It
    resolves naming conflicts, rebinds fields and managers to the target
    registry, rebuilds relation descriptors, and regenerates the proxy model
    so the attached class behaves like a first-class registered model.

    Args:
        registry: Target registry.
        name: Optional replacement model name.
        database: Database binding strategy or explicit database object.
        on_conflict: Conflict strategy for duplicate model names.

    Returns:
        type[Model]: The attached model class.

    Raises:
        ImproperlyConfigured: If a conflicting model already exists and the
            conflict strategy is `"error"`.
    """
    if getattr(cls.meta, "registry", None) not in (None, False, registry):
        return cls.copy_saffier_model(
            registry=registry,
            name=name or cls.__name__,
            on_conflict=on_conflict,
        )

    model_name = name or cls.__name__
    if model_name in registry.models:
        if on_conflict == "keep":
            return cast("type[Model]", registry.models[model_name])
        if on_conflict == "replace":
            registry.delete_model(model_name)
        else:
            raise ImproperlyConfigured(
                f'A model with the same name is already registered: "{model_name}".'
            )

    cls.meta.registry = registry
    cls.__name__ = model_name

    if database is True:
        cls.database = registry.database
    elif database not in (False, "keep"):
        cls.database = database
    elif getattr(cls, "database", None) is None:
        cls.database = registry.database

    registry.models[model_name] = cls
    cls.__db_model__ = True
    cls.meta.model = cls
    cls.fields = cls.meta.fields
    cls._table = None
    cls._db_schemas = {}

    for field_name, field in cls.fields.items():
        field.owner = cls
        field.registry = registry
        if field.primary_key and field_name == cls.meta.pk_attribute:
            cls.pkname = field_name

    for manager_name in getattr(cls.meta, "managers", []):
        manager = getattr(cls, manager_name, None)
        if isinstance(manager, Manager):
            manager.name = manager_name
            manager.model_class = cls

    if getattr(cls.meta, "foreign_key_fields", None) and not cls.is_proxy_model:
        related_names = _set_related_name_for_foreign_keys(cls.meta.foreign_key_fields, cls)
        cls.meta.related_names.update(related_names)

    for field_name, field in list(cls.fields.items()):
        if isinstance(field, saffier.ManyToManyField):
            _set_many_to_many_relation(field, cls, field_name)

    _register_model_signals(cls)
    cls.__proxy_model__ = None
    if not cls.is_proxy_model and not cls.meta.abstract:
        proxy_model = cls.generate_proxy_model()
        cls.__proxy_model__ = proxy_model
        cls.__proxy_model__.parent = cls
        registry.models[model_name] = cls

    if hasattr(registry, "_handle_model_registration"):
        registry._handle_model_registration(cls)
    registry.execute_model_callbacks(cls)
    return cast("type[Model]", cls)

@classmethod
def add_to_registry(
    cls,
    registry: "saffier.Registry",
    name: str = "",
    database: bool | Any | str = "keep",
    *,
    on_conflict: str = "error",
) -> type["Model"]:
    """Attach the model to another registry, copying if required.

    Args:
        registry: Destination registry.
        name: Optional replacement model name.
        database: Database rebinding strategy.
        on_conflict: Conflict strategy for duplicate model names.

    Returns:
        type[Model]: Registered model class.
    """
    return cls.real_add_to_registry(
        registry=registry,
        name=name,
        database=database,
        on_conflict=on_conflict,
    )