Class Model

tortoise/models.py:720–1792

Base class for all Tortoise ORM Models.

class Model(metaclass=ModelMeta):
    """
    Base class for all Tortoise ORM Models.
    """

    # I don' like this here, but it makes auto completion and static analysis much happier
    _meta = MetaInfo(None)  # type: ignore
    _listeners: dict[Signals, dict[type[MODEL], list[Callable]]] = {  # type: ignore
        Signals.pre_save: {},
        Signals.post_save: {},
        Signals.pre_delete: {},
        Signals.post_delete: {},
    }

    def __init__(self, **kwargs: Any) -> None:
        # self._meta is a very common attribute lookup, lets cache it.
        meta = self._meta
        self._partial = False
        self._saved_in_db = False
        self._custom_generated_pk = False
        self._await_when_save: dict[str, Callable[[], Awaitable[Any]]] = {}

        # Assign defaults for missing fields
        for key in meta.fields.difference(self._set_kwargs(kwargs)):
            field_object = meta.fields_map[key]
            field_default = field_object.default
            if inspect.iscoroutinefunction(field_default):
                self._await_when_save[key] = field_default
            elif callable(field_default):
                setattr(self, key, field_default())
            else:
                default = field_object.default
                if default is not None:
                    if isinstance(default, (int, float, str, bool, bytes)):
                        setattr(self, key, default)
                    else:
                        setattr(self, key, deepcopy(default))
                elif field_object.has_db_default():
                    setattr(self, key, field_object.get_db_default_value())
                else:
                    setattr(self, key, None)

    def __setattr__(self, key, value) -> None:
        # set field value override async default function
        if hasattr(self, "_await_when_save"):
            self._await_when_save.pop(key, None)
        if key in self._meta.fk_fields or key in self._meta.o2o_fields:
            self._validate_relation_type(key, value)
        super().__setattr__(key, value)

    def _set_kwargs(self, kwargs: dict) -> set[str]:
        meta = self._meta

        # Assign values and do type conversions
        passed_fields = {*kwargs.keys()} | meta.fetch_fields

        for key, value in kwargs.items():
            if key in meta.fk_fields or key in meta.o2o_fields: