GeneralManager 0.17.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

general_manager/interface/baseInterface.py

@@ -55,23 +55,109 @@ class AttributeTypedDict(TypedDict):
     is_derived: bool
 
 
+class UnexpectedInputArgumentsError(TypeError):
+    """Raised when parseInputFields receives keyword arguments not defined by the interface."""
+
+    def __init__(self, extra_args: Iterable[str]) -> None:
+        """
+        Initialize the exception with a message listing unexpected input argument names.
+
+        Parameters:
+            extra_args (Iterable[str]): Names of the unexpected keyword arguments to include in the error message.
+        """
+        extras = ", ".join(extra_args)
+        super().__init__(f"Unexpected arguments: {extras}.")
+
+
+class MissingInputArgumentsError(TypeError):
+    """Raised when required interface inputs are not supplied."""
+
+    def __init__(self, missing_args: Iterable[str]) -> None:
+        """
+        Initialize the exception for missing required input arguments.
+
+        Parameters:
+            missing_args (Iterable[str]): Names of required input arguments that were not provided; these will be joined into the exception message.
+        """
+        missing = ", ".join(missing_args)
+        super().__init__(f"Missing required arguments: {missing}.")
+
+
+class CircularInputDependencyError(ValueError):
+    """Raised when input fields declare circular dependencies."""
+
+    def __init__(self, unresolved: Iterable[str]) -> None:
+        """
+        Initialize the CircularInputDependencyError with the names of inputs involved in the cycle.
+
+        Parameters:
+            unresolved (Iterable[str]): Iterable of input names that form the detected circular dependency.
+        """
+        names = ", ".join(unresolved)
+        super().__init__(f"Circular dependency detected among inputs: {names}.")
+
+
+class InvalidInputTypeError(TypeError):
+    """Raised when an input value does not match its declared type."""
+
+    def __init__(self, name: str, provided: type, expected: type) -> None:
+        """
+        Initialize the InvalidInputTypeError with a message describing a type mismatch for a named input.
+
+        Parameters:
+            name (str): The name of the input field with the invalid type.
+            provided (type): The actual type that was provided.
+            expected (type): The type that was expected.
+        """
+        super().__init__(f"Invalid type for {name}: {provided}, expected: {expected}.")
+
+
+class InvalidPossibleValuesTypeError(TypeError):
+    """Raised when an input's possible_values configuration is not callable or iterable."""
+
+    def __init__(self, name: str) -> None:
+        """
+        Exception raised when an input's `possible_values` configuration is neither callable nor iterable.
+
+        Parameters:
+            name (str): The input field name whose `possible_values` is invalid; included in the exception message.
+        """
+        super().__init__(f"Invalid type for possible_values of input {name}.")
+
+
+class InvalidInputValueError(ValueError):
+    """Raised when a provided input value is not within the allowed set."""
+
+    def __init__(self, name: str, value: object, allowed: Iterable[object]) -> None:
+        """
+        Initialize the exception with a message describing an invalid input value for a specific field.
+
+        Parameters:
+            name (str): The name of the input field that received the invalid value.
+            value (object): The value that was provided and deemed invalid.
+            allowed (Iterable[object]): An iterable of permitted values for the field; used to include allowed options in the exception message.
+        """
+        super().__init__(
+            f"Invalid value for {name}: {value}, allowed: {list(allowed)}."
+        )
+
+
 class InterfaceBase(ABC):
     """Common base API for interfaces backing GeneralManager classes."""
 
-    _parent_class: Type[GeneralManager]
+    _parent_class: ClassVar[Type["GeneralManager"]]
     _interface_type: ClassVar[str]
-    input_fields: dict[str, Input]
+    input_fields: ClassVar[dict[str, "Input"]]
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         """
-        Construct the interface using the supplied identification arguments.
+        Initialize the interface using the provided identification inputs.
 
-        Parameters:
-            *args: Positional arguments passed to the interface constructor.
-            **kwargs: Keyword arguments passed to the interface constructor.
+        Positional arguments are mapped to the interface's declared input fields by position; keyword arguments are matched by name. Inputs are validated and normalized according to the interface's input field definitions and the resulting normalized identification is stored on the instance as `self.identification`.
 
-        Returns:
-            None
+        Parameters:
+            *args: Positional identification values corresponding to the interface's input field order.
+            **kwargs: Named identification values matching the interface's input field names.
         """
         identification = self.parseInputFieldsToIdentification(*args, **kwargs)
         self.identification = self.formatIdentification(identification)
@@ -82,18 +168,22 @@ class InterfaceBase(ABC):
         **kwargs: Any,
     ) -> dict[str, Any]:
         """
-        Parse raw arguments into a validated identification mapping.
+        Convert positional and keyword inputs into a validated identification mapping for the interface's input fields.
 
         Parameters:
-            *args (Any): Positional arguments matched to the interface's input field order.
-            **kwargs (dict[str, Any]): Keyword arguments supplied by the caller.
+            *args: Positional arguments matched, in order, to the interface's defined input fields.
+            **kwargs: Keyword arguments supplying input values by name.
 
         Returns:
-            dict[str, Any]: Mapping of input field names to validated values.
+            dict[str, Any]: Mapping of input field names to their validated values.
 
         Raises:
-            TypeError: If required inputs are missing, unexpected inputs are provided, or a value fails type checking.
-            ValueError: If circular dependencies prevent resolution of the inputs.
+            UnexpectedInputArgumentsError: If extra keyword arguments are provided that do not match any input field (after allowing keys suffixed with "_id").
+            MissingInputArgumentsError: If one or more required input fields are not provided.
+            CircularInputDependencyError: If input fields declare dependencies that form a cycle and cannot be resolved.
+            InvalidInputTypeError: If a provided value does not match the declared type for an input.
+            InvalidPossibleValuesTypeError: If an input's `possible_values` configuration is neither callable nor iterable.
+            InvalidInputValueError: If a provided value is not in the allowed set defined by an input's `possible_values`.
         """
         identification: dict[str, Any] = {}
         kwargs = cast(
@@ -106,11 +196,11 @@ class InterfaceBase(ABC):
                 if extra_arg.replace("_id", "") in self.input_fields.keys():
                     kwargs[extra_arg.replace("_id", "")] = kwargs.pop(extra_arg)
                 else:
-                    raise TypeError(f"Unexpected arguments: {', '.join(extra_args)}")
+                    raise UnexpectedInputArgumentsError(extra_args)
 
         missing_args = set(self.input_fields.keys()) - set(kwargs.keys())
         if missing_args:
-            raise TypeError(f"Missing required arguments: {', '.join(missing_args)}")
+            raise MissingInputArgumentsError(missing_args)
 
         # process input fields with dependencies
         processed: set[str] = set()
@@ -129,9 +219,7 @@ class InterfaceBase(ABC):
             if not progress_made:
                 # detect circular dependencies
                 unresolved = set(self.input_fields.keys()) - processed
-                raise ValueError(
-                    f"Circular dependency detected among inputs: {', '.join(unresolved)}"
-                )
+                raise CircularInputDependencyError(unresolved)
         return identification
 
     @staticmethod
@@ -169,25 +257,23 @@ class InterfaceBase(ABC):
         self, name: str, value: Any, identification: dict[str, Any]
     ) -> None:
         """
-        Validate a single input value against its definition.
+        Validate a single input value against its declared Input definition.
 
-        Parameters:
-            name (str): Input field name being processed.
-            value (Any): Value provided by the caller.
-            identification (dict[str, Any]): Partially resolved identification mapping used to evaluate dependencies.
+        Checks that the provided value matches the declared Python type and, when DEBUG is enabled, verifies the value is allowed by the input's `possible_values` (which may be an iterable or a callable that receives dependent input values).
 
-        Returns:
-            None
+        Parameters:
+            name: The input field name being validated.
+            value: The value to validate.
+            identification: Partially resolved identification mapping used to supply dependent input values when evaluating `possible_values`.
 
         Raises:
-            TypeError: If the value has the wrong type or possible values are misconfigured.
-            ValueError: If the value is not permitted by the configured `possible_values`.
+            InvalidInputTypeError: If `value` is not an instance of the input's declared `type`.
+            InvalidPossibleValuesTypeError: If `possible_values` is neither callable nor iterable.
+            InvalidInputValueError: If `value` is not contained in the evaluated `possible_values` (only checked when DEBUG is true).
         """
         input_field = self.input_fields[name]
         if not isinstance(value, input_field.type):
-            raise TypeError(
-                f"Invalid type for {name}: {type(value)}, expected: {input_field.type}"
-            )
+            raise InvalidInputTypeError(name, type(value), input_field.type)
         if settings.DEBUG:
             # `possible_values` can be a callable or an iterable
             possible_values = input_field.possible_values
@@ -202,16 +288,23 @@ class InterfaceBase(ABC):
                 elif isinstance(possible_values, Iterable):
                     allowed_values = possible_values
                 else:
-                    raise TypeError(f"Invalid type for possible_values of input {name}")
+                    raise InvalidPossibleValuesTypeError(name)
 
                 if value not in allowed_values:
-                    raise ValueError(
-                        f"Invalid value for {name}: {value}, allowed: {allowed_values}"
-                    )
+                    raise InvalidInputValueError(name, value, allowed_values)
 
     @classmethod
     def create(cls, *args: Any, **kwargs: Any) -> Any:
-        """Create a new record via the underlying data source."""
+        """
+        Create a new managed record in the underlying data store using the interface's inputs.
+
+        Parameters:
+            *args: Positional input values corresponding to the interface's defined input fields.
+            **kwargs: Input values provided by name; unexpected extra keywords will be rejected.
+
+        Returns:
+            The created record or a manager-specific representation of the newly created entity.
+        """
         raise NotImplementedError
 
     def update(self, *args: Any, **kwargs: Any) -> Any:

general_manager/interface/calculationInterface.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 from datetime import datetime
-from typing import Any
+from typing import Any, ClassVar
 from general_manager.interface.baseInterface import (
     InterfaceBase,
     classPostCreationMethod,
@@ -21,10 +21,20 @@ from general_manager.bucket.calculationBucket import CalculationBucket
 
 class CalculationInterface(InterfaceBase):
     """Interface exposing calculation inputs without persisting data."""
-    _interface_type = "calculation"
-    input_fields: dict[str, Input]
+
+    _interface_type: ClassVar[str] = "calculation"
+    input_fields: ClassVar[dict[str, Input]]
 
     def getData(self, search_date: datetime | None = None) -> Any:
+        """
+        Indicates that calculation interfaces do not provide stored data.
+
+        Parameters:
+            search_date (datetime | None): Date for which data would be requested.
+
+        Raises:
+            NotImplementedError: Always raised with the message "Calculations do not store data."
+        """
         raise NotImplementedError("Calculations do not store data.")
 
     @classmethod
@@ -72,18 +82,18 @@ class CalculationInterface(InterfaceBase):
 
     @staticmethod
     def _preCreate(
-        name: generalManagerClassName, attrs: attributes, interface: interfaceBaseClass
+        _name: generalManagerClassName, attrs: attributes, interface: interfaceBaseClass
     ) -> tuple[attributes, interfaceBaseClass, None]:
         """
-        Prepare interface attributes prior to GeneralManager class creation.
+        Prepare and attach a generated Interface subclass into the attributes for a GeneralManager class before its creation.
 
         Parameters:
-            name (generalManagerClassName): Name of the new manager class.
-            attrs (attributes): Attribute dictionary for the manager being created.
-            interface (interfaceBaseClass): Base interface definition.
+            _name (generalManagerClassName): Name of the manager class being created.
+            attrs (attributes): Mutable attribute dictionary for the manager class under construction; will be modified to include the generated Interface and interface type.
+            interface (interfaceBaseClass): Base interface class from which the generated Interface subclass is derived.
 
         Returns:
-            tuple[attributes, interfaceBaseClass, None]: Updated attributes, interface class, and related model (None).
+            tuple[attributes, interfaceBaseClass, None]: The updated attributes dict, the newly created Interface subclass, and None for the related model.
         """
         input_fields: dict[str, Input[Any]] = {}
         for key, value in vars(interface).items():
@@ -104,9 +114,19 @@ class CalculationInterface(InterfaceBase):
     def _postCreate(
         new_class: newlyCreatedGeneralManagerClass,
         interface_class: newlyCreatedInterfaceClass,
-        model: relatedClass,
+        _model: relatedClass,
     ) -> None:
-        """Link the generated interface to the manager class after creation."""
+        """
+        Link the generated interface class to its manager class after creation.
+
+        Parameters:
+            new_class: The newly created GeneralManager class to attach.
+            interface_class: The generated interface class that will reference the manager.
+            _model: Unused placeholder for the related model class; ignored.
+
+        Description:
+            Sets `interface_class._parent_class` to `new_class` so the interface knows its owning manager.
+        """
         interface_class._parent_class = new_class
 
     @classmethod
@@ -122,18 +142,15 @@ class CalculationInterface(InterfaceBase):
     @classmethod
     def getFieldType(cls, field_name: str) -> type:
         """
-        Return the Python type of the specified input field.
-
-        Parameters:
-            field_name (str): The name of the input field.
+        Get the Python type for an input field.
 
         Returns:
-            type: The Python type associated with the input field.
+            The Python type associated with the specified input field.
 
         Raises:
-            KeyError: If the specified field name does not exist in input_fields.
+            KeyError: If `field_name` is not present in `cls.input_fields`.
         """
         field = cls.input_fields.get(field_name)
         if field is None:
-            raise KeyError(f"Field '{field_name}' not found in input fields.")
+            raise KeyError(field_name)
         return field.type

general_manager/interface/databaseBasedInterface.py

@@ -1,7 +1,7 @@
 """Database-backed interface implementation for GeneralManager classes."""
 
 from __future__ import annotations
-from typing import Type, Any, Callable, TYPE_CHECKING, TypeVar, Generic, cast
+from typing import Any, Callable, ClassVar, Generic, TYPE_CHECKING, TypeVar, Type, cast
 from django.db import models
 
 from datetime import datetime, date, time, timedelta
@@ -39,11 +39,23 @@ modelsModel = TypeVar("modelsModel", bound=models.Model)
 MODEL_TYPE = TypeVar("MODEL_TYPE", bound=GeneralManagerBasisModel)
 
 
+class DuplicateFieldNameError(ValueError):
+    """Raised when a dynamically generated field name conflicts with an existing one."""
+
+    def __init__(self) -> None:
+        """
+        Initialize the DuplicateFieldNameError with a default descriptive message.
+
+        This exception indicates a conflict where a dynamically generated field name duplicates an existing name; the default message is "Field name already exists."
+        """
+        super().__init__("Field name already exists.")
+
+
 class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     """Interface implementation that persists data using Django ORM models."""
 
     _model: Type[MODEL_TYPE]
-    input_fields: dict[str, Input] = {"id": Input(int)}
+    input_fields: ClassVar[dict[str, Input]] = {"id": Input(int)}
 
     def __init__(
         self,
@@ -52,15 +64,15 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         **kwargs: Any,
     ) -> None:
         """
-        Build the interface and hydrate the underlying model instance.
+        Initialize the interface and load its underlying model instance.
 
-        Parameters:
-            *args (list[Any]): Positional identification arguments forwarded to the parent interface.
-            search_date (datetime | None): When provided, load historical data for the given timestamp.
-            **kwargs (Any): Keyword identification arguments forwarded to the parent interface.
+        Positional and keyword arguments are forwarded to the parent interface to establish identification.
+        search_date, when provided, causes the instance to be resolved from historical records at or before that timestamp; if omitted, the current database record is loaded.
 
-        Returns:
-            None
+        Parameters:
+            *args: Positional identification arguments forwarded to the parent interface.
+            search_date (datetime | None): Timestamp to select a historical record; `None` to use the current record.
+            **kwargs: Keyword identification arguments forwarded to the parent interface.
         """
         super().__init__(*args, **kwargs)
         self.pk = self.identification["id"]
@@ -186,12 +198,20 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @classmethod
     def getAttributeTypes(cls) -> dict[str, AttributeTypedDict]:
         """
-        Return a dictionary mapping each model attribute name to its type information and metadata.
+        Builds a mapping of model attribute names to their type metadata for the interface.
 
-        Includes standard fields, custom fields, foreign keys, many-to-many, and reverse relation fields, excluding GenericForeignKey fields. For each attribute, provides its Python type (translated from Django field types when possible), required and editable status, whether it is derived, and its default value. For related models with a general manager class, the type is set to that class.
+        Produces entries for model fields, custom measurement-like fields, foreign-key relations, many-to-many relations, and reverse one-to-many relations. For related models that expose a general manager class, the attribute type is that manager class; many-to-many and reverse relation attributes are exposed with a "_list" suffix. GenericForeignKey fields are omitted.
 
         Returns:
-            dict[str, AttributeTypedDict]: Mapping of attribute names to their type information and metadata.
+            dict[str, AttributeTypedDict]: Mapping from attribute name to metadata with keys:
+                - `type`: the attribute's Python type or general-manager class for related models (common Django field classes are translated to built-in Python types),
+                - `is_derived`: `True` for attributes computed from relations, `False` for direct model fields,
+                - `is_required`: `True` if the attribute must be present (e.g., field null is False and no default),
+                - `is_editable`: `True` if the field is editable on the model,
+                - `default`: the field's default value or `None` when not applicable.
+
+        Raises:
+            DuplicateFieldNameError: if a generated attribute name collides with an existing attribute name.
         """
         TRANSLATION: dict[Type[models.Field[Any, Any]], type] = {
             models.fields.BigAutoField: int,
@@ -253,7 +273,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                 if hasattr(field, "default"):
                     default = field.default  # type: ignore
                 fields[field_name] = {
-                    "type": related_model,
+                    "type": cast(type, related_model),
                     "is_derived": False,
                     "is_required": not field.null,
                     "is_editable": field.editable,
@@ -268,7 +288,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                 if field_call not in fields:
                     field_name = field_call
                 else:
-                    raise ValueError("Field name already exists.")
+                    raise DuplicateFieldNameError()
             field = cls._model._meta.get_field(field_name)
             related_model = cls._model._meta.get_field(field_name).related_model
             if related_model == "self":
@@ -284,7 +304,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
 
             if related_model is not None:
                 fields[f"{field_name}_list"] = {
-                    "type": related_model,
+                    "type": cast(type, related_model),
                     "is_required": False,
                     "is_derived": not bool(field.many_to_many),
                     "is_editable": bool(field.many_to_many and field.editable),
@@ -299,12 +319,15 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @classmethod
     def getAttributes(cls) -> dict[str, Callable[[DBBasedInterface], Any]]:
         """
-        Return a mapping of attribute names to callables that extract values from a DBBasedInterface instance.
+        Builds a mapping of attribute names to accessor callables for a DBBasedInterface instance.
 
-        The returned dictionary includes accessors for custom fields, standard model fields, foreign keys, many-to-many relations, and reverse relations. For related models with a general manager class, the accessor returns an instance or queryset of that class; otherwise, it returns the related object or queryset directly. Raises a ValueError if a field name conflict is detected.
+        Includes accessors for custom fields, standard model fields, foreign-key relations, many-to-many relations, and reverse relations. For relations whose related model exposes a _general_manager_class, the accessor yields the corresponding GeneralManager instance (for single relations) or a filtered manager/queryset (for multi-relations); otherwise the accessor yields the related model instance or a queryset directly.
 
         Returns:
-            dict[str, Callable[[DBBasedInterface], Any]]: Mapping of attribute names to callables for retrieving values from a DBBasedInterface instance.
+            dict[str, Callable[[DBBasedInterface], Any]]: Mapping from attribute name to a callable that accepts a DBBasedInterface and returns that attribute's value.
+
+        Raises:
+            DuplicateFieldNameError: If a generated attribute name conflicts with an existing attribute name.
         """
         from general_manager.manager.generalManager import GeneralManager
 
@@ -332,7 +355,9 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                     Type[GeneralManager], related_model._general_manager_class
                 )
                 field_values[f"{field_name}"] = (
-                    lambda self, field_name=field_name, manager_class=generalManagerClass: (
+                    lambda self,
+                    field_name=field_name,
+                    manager_class=generalManagerClass: (
                         manager_class(getattr(self._instance, field_name).pk)
                         if getattr(self._instance, field_name)
                         else None
@@ -353,7 +378,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                 if field_call not in field_values:
                     field_name = field_call
                 else:
-                    raise ValueError("Field name already exists.")
+                    raise DuplicateFieldNameError()
             if hasattr(
                 cls._model._meta.get_field(field_name).related_model,
                 "_general_manager_class",
@@ -368,12 +393,17 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                     if f.related_model == cls._model
                 ]
 
-                field_values[
-                    f"{field_name}_list"
-                ] = lambda self, field_name=field_name, related_fields=related_fields: self._instance._meta.get_field(
-                    field_name
-                ).related_model._general_manager_class.filter(
-                    **{related_field.name: self.pk for related_field in related_fields}
+                field_values[f"{field_name}_list"] = (
+                    lambda self,
+                    field_name=field_name,
+                    related_fields=related_fields: self._instance._meta.get_field(
+                        field_name
+                    ).related_model._general_manager_class.filter(
+                        **{
+                            related_field.name: self.pk
+                            for related_field in related_fields
+                        }
+                    )
                 )
             else:
                 field_values[f"{field_name}_list"] = (
@@ -468,18 +498,16 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     ) -> tuple[attributes, interfaceBaseClass, relatedClass]:
         # Collect fields defined directly on the interface class
         """
-        Dynamically generates a Django model class, its associated interface class, and a factory class from an interface definition.
-
-        This method collects fields and metadata from the provided interface class, creates a new Django model inheriting from the specified base model class, attaches custom validation rules if present, and constructs corresponding interface and factory classes. The updated attributes dictionary, the new interface class, and the newly created model class are returned for integration into the general manager framework.
+        Create a Django model class, a corresponding interface subclass, and a Factory class from an interface definition.
 
         Parameters:
-            name (generalManagerClassName): Name for the dynamically created model class.
-            attrs (attributes): Attribute dictionary updated with interface and factory definitions.
-            interface (interfaceBaseClass): Interface definition used to derive the model.
-            base_model_class (type[GeneralManagerBasisModel]): Base Django model class (defaults to GeneralManagerModel).
+            name (generalManagerClassName): Name to assign to the generated Django model class.
+            attrs (attributes): Attribute dictionary to be updated with the generated Interface and Factory entries.
+            interface (interfaceBaseClass): Interface definition used to derive the model and interface subclass.
+            base_model_class (type[GeneralManagerBasisModel]): Base class for the generated Django model (defaults to GeneralManagerModel).
 
         Returns:
-            tuple[attributes, interfaceBaseClass, relatedClass]: Updated attributes, interface class, and the generated model.
+            tuple[attributes, interfaceBaseClass, relatedClass]: A tuple containing the updated attributes dictionary, the newly created interface subclass, and the generated Django model class.
         """
         model_fields: dict[str, Any] = {}
         meta_class = None
@@ -500,7 +528,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
             model_fields["Meta"] = meta_class
 
             if hasattr(meta_class, "rules"):
-                rules = getattr(meta_class, "rules")
+                rules = meta_class.rules
                 delattr(meta_class, "rules")
 
         # Create the concrete Django model dynamically
@@ -509,13 +537,13 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
             type(name, (base_model_class,), model_fields),
         )
         if meta_class and rules:
-            setattr(model._meta, "rules", rules)
-            # full_clean Methode hinzufügen
-            setattr(model, "full_clean", getFullCleanMethode(model))
-        # Interface-Typ bestimmen
+            model._meta.rules = rules  # type: ignore[attr-defined]
+            # add full_clean method
+            model.full_clean = getFullCleanMethode(model)  # type: ignore[assignment]
+        # Determine interface type
         attrs["_interface_type"] = interface._interface_type
         interface_cls = type(interface.__name__, (interface,), {})
-        setattr(interface_cls, "_model", model)
+        interface_cls._model = model  # type: ignore[attr-defined]
         attrs["Interface"] = interface_cls
 
         # Build the associated factory class
@@ -550,19 +578,17 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
             model (relatedClass): Django model linked to the manager.
         """
         interface_class._parent_class = new_class
-        setattr(model, "_general_manager_class", new_class)
+        model._general_manager_class = new_class  # type: ignore
 
     @classmethod
     def handleInterface(
         cls,
     ) -> tuple[classPreCreationMethod, classPostCreationMethod]:
         """
-        Returns the pre- and post-creation hooks for initializing the interface.
-
-        The pre-creation method is called before the GeneralManager class is created to allow customization, while the post-creation method is called after creation to finalize setup.
+        Provide hooks invoked before and after dynamic interface class creation.
 
         Returns:
-            tuple[classPreCreationMethod, classPostCreationMethod]: Hooks used during manager class creation.
+            tuple[classPreCreationMethod, classPostCreationMethod]: A pair (pre_create, post_create) where `pre_create` is invoked before the manager class is created to allow customization, and `post_create` is invoked after creation to finalize setup.
         """
         return cls._preCreate, cls._postCreate