GeneralManager 0.14.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

general_manager/interface/databaseBasedInterface.py

@@ -1,8 +1,11 @@
+"""Database-backed interface implementation for GeneralManager classes."""
+
 from __future__ import annotations
 from typing import Type, Any, Callable, TYPE_CHECKING, TypeVar, Generic, cast
 from django.db import models
 
-from datetime import datetime, timedelta
+from datetime import datetime, date, time, timedelta
+from django.utils import timezone
 from general_manager.measurement.measurement import Measurement
 from general_manager.measurement.measurementField import MeasurementField
 from decimal import Decimal
@@ -37,42 +40,64 @@ MODEL_TYPE = TypeVar("MODEL_TYPE", bound=GeneralManagerBasisModel)
 
 
 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)}
 
     def __init__(
         self,
-        *args: list[Any],
+        *args: Any,
         search_date: datetime | None = None,
         **kwargs: Any,
-    ):
+    ) -> None:
         """
-        Initialize the interface and load the associated model instance by primary key.
+        Build the interface and hydrate the 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.
 
-        If a `search_date` is provided, retrieves the historical record as of that date; otherwise, loads the current record.
+        Returns:
+            None
         """
         super().__init__(*args, **kwargs)
         self.pk = self.identification["id"]
-        self._instance = self.getData(search_date)
+        self._instance: MODEL_TYPE = self.getData(search_date)
 
-    def getData(self, search_date: datetime | None = None) -> GeneralManagerBasisModel:
+    def getData(self, search_date: datetime | None = None) -> MODEL_TYPE:
         """
-        Retrieves the model instance by primary key, optionally as of a specified historical date.
+        Fetch the underlying model instance, optionally as of a historical date.
+
+        Parameters:
+            search_date (datetime | None): When provided, retrieve the state closest to this timestamp.
 
-        If a `search_date` is provided and is not within the last 5 seconds, returns the historical record of the instance as of that date; otherwise, returns the current instance.
+        Returns:
+            MODEL_TYPE: Current or historical instance matching the primary key.
         """
         model = self._model
-        instance = model.objects.get(pk=self.pk)
-        if search_date and not search_date > datetime.now() - timedelta(seconds=5):
-            instance = self.getHistoricalRecord(instance, search_date)
+        instance = cast(MODEL_TYPE, model.objects.get(pk=self.pk))
+        if search_date is not None:
+            # Normalize to aware datetime if needed
+            if timezone.is_naive(search_date):
+                search_date = timezone.make_aware(search_date)
+            if search_date <= timezone.now() - timedelta(seconds=5):
+                historical = self.getHistoricalRecord(instance, search_date)
+                if historical is not None:
+                    instance = historical
         return instance
 
     @staticmethod
     def __parseKwargs(**kwargs: Any) -> dict[str, Any]:
         """
-        Parses keyword arguments to ensure they are compatible with the model's fields.
+        Convert keyword arguments into ORM-friendly values.
 
-        Converts GeneralManager instances to their primary key values and returns a dictionary of parsed arguments.
+        Parameters:
+            **kwargs (Any): Filter or update arguments potentially containing manager instances.
+
+        Returns:
+            dict[str, Any]: Arguments ready to be passed to Django ORM methods.
         """
         from general_manager.manager.generalManager import GeneralManager
 
@@ -89,13 +114,13 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @classmethod
     def filter(cls, **kwargs: Any) -> DatabaseBucket:
         """
-        Returns a DatabaseBucket containing model instances filtered by the given criteria.
+        Return a bucket of model instances filtered by the provided lookups.
 
-        Args:
-            **kwargs: Field lookups to filter the queryset.
+        Parameters:
+            **kwargs (Any): Django-style filter expressions.
 
         Returns:
-            A DatabaseBucket wrapping the filtered queryset and associated metadata.
+            DatabaseBucket: Bucket wrapping the filtered queryset.
         """
 
         kwargs = cls.__parseKwargs(**kwargs)
@@ -109,13 +134,13 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @classmethod
     def exclude(cls, **kwargs: Any) -> DatabaseBucket:
         """
-        Returns a DatabaseBucket containing model instances that do not match the given filter criteria.
+        Return a bucket excluding model instances that match the provided lookups.
 
-        Args:
-            **kwargs: Field lookups to exclude from the queryset.
+        Parameters:
+            **kwargs (Any): Django-style exclusion expressions.
 
         Returns:
-            A DatabaseBucket wrapping the queryset of excluded model instances.
+            DatabaseBucket: Bucket wrapping the excluded queryset.
         """
         kwargs = cls.__parseKwargs(**kwargs)
 
@@ -128,13 +153,13 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @staticmethod
     def __createFilterDefinitions(**kwargs: Any) -> dict[str, Any]:
         """
-        Creates a dictionary of filter definitions from the provided keyword arguments.
+        Build a filter-definition mapping from Django-style kwargs.
 
-        Args:
-            **kwargs: Key-value pairs representing filter criteria.
+        Parameters:
+            **kwargs (Any): Filter expressions provided by the caller.
 
         Returns:
-            A dictionary mapping filter keys to their corresponding values.
+            dict[str, Any]: Mapping of filter names to their values.
         """
         filter_definitions: dict[str, Any] = {}
         for key, value in kwargs.items():
@@ -143,19 +168,20 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
 
     @classmethod
     def getHistoricalRecord(
-        cls, instance: GeneralManagerBasisModel, search_date: datetime | None = None
-    ) -> GeneralManagerBasisModel:
+        cls, instance: MODEL_TYPE, search_date: datetime | None = None
+    ) -> MODEL_TYPE | None:
         """
         Retrieves the most recent historical record of a model instance at or before a specified date.
 
-        Args:
-            instance: The model instance whose history is queried.
-            search_date: The cutoff datetime; returns the last record at or before this date.
+        Parameters:
+            instance (MODEL_TYPE): Model instance whose history is queried.
+            search_date (datetime | None): Cutoff datetime used to select the historical record.
 
         Returns:
-            The historical model instance as of the specified date, or None if no such record exists.
+            MODEL_TYPE | None: Historical instance as of the specified date, if available.
         """
-        return instance.history.filter(history_date__lte=search_date).last()  # type: ignore
+        historical = instance.history.filter(history_date__lte=search_date).last()  # type: ignore[attr-defined]
+        return cast(MODEL_TYPE | None, historical)
 
     @classmethod
     def getAttributeTypes(cls) -> dict[str, AttributeTypedDict]:
@@ -363,11 +389,13 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         model: Type[models.Model] | models.Model,
     ) -> tuple[list[str], list[str]]:
         """
-        Identifies custom fields on a model and their associated utils fields to ignore.
+        Identify custom fields on a model and related helper fields to ignore.
+
+        Parameters:
+            model (type[models.Model] | models.Model): Model class or instance to inspect.
 
         Returns:
-            A tuple containing a list of custom field names and a list of related field names
-            (typically suffixed with '_value' and '_unit') that should be ignored.
+            tuple[list[str], list[str]]: Names of custom fields and associated helper fields to ignore.
         """
         field_name_list: list[str] = []
         to_ignore_list: list[str] = []
@@ -381,13 +409,13 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @staticmethod
     def _getCustomFields(model: Type[models.Model] | models.Model) -> list[str]:
         """
-        Return a list of custom field names defined directly as class attributes on the given Django model.
+        Return names of fields declared directly on the model class.
 
         Parameters:
-            model: The Django model class or instance to inspect.
+            model (type[models.Model] | models.Model): Model class or instance to inspect.
 
         Returns:
-            A list of field names for fields declared directly on the model class, excluding those defined via Django's meta system.
+            list[str]: Field names declared as class attributes.
         """
         return [
             field.name
@@ -397,11 +425,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
 
     @classmethod
     def __getModelFields(cls) -> list[str]:
-        """
-        Return a list of field names for the model that are neither many-to-many nor related fields.
-
-        Fields representing many-to-many relationships or relations to other models are excluded from the result.
-        """
+        """Return names of non-relational fields defined on the model."""
         return [
             field.name
             for field in cls._model._meta.get_fields()
@@ -410,9 +434,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
 
     @classmethod
     def __getForeignKeyFields(cls) -> list[str]:
-        """
-        Return a list of field names for all foreign key and one-to-one relations on the model, excluding generic foreign keys.
-        """
+        """Return names of foreign-key and one-to-one relations on the model."""
         return [
             field.name
             for field in cls._model._meta.get_fields()
@@ -421,11 +443,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
 
     @classmethod
     def __getManyToManyFields(cls) -> list[tuple[str, str]]:
-        """
-        Return a list of tuples representing all many-to-many fields on the model.
-
-        Each tuple contains the field name twice. Fields that are generic foreign keys are excluded.
-        """
+        """Return (field_name, accessor_name) tuples for many-to-many fields."""
         return [
             (field.name, field.name)
             for field in cls._model._meta.get_fields()
@@ -434,11 +452,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
 
     @classmethod
     def __getReverseRelations(cls) -> list[tuple[str, str]]:
-        """
-        Return a list of reverse one-to-many relations for the model, excluding generic foreign keys.
-
-        Each tuple contains the related field's name and its default related accessor name (e.g., `fieldname_set`).
-        """
+        """Return (field_name, accessor_name) tuples for reverse one-to-many relations."""
         return [
             (field.name, f"{field.name}_set")
             for field in cls._model._meta.get_fields()
@@ -450,37 +464,37 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         name: generalManagerClassName,
         attrs: attributes,
         interface: interfaceBaseClass,
-        base_model_class=GeneralManagerModel,
+        base_model_class: type[GeneralManagerBasisModel] = GeneralManagerModel,
     ) -> tuple[attributes, interfaceBaseClass, relatedClass]:
-        # Felder aus der Interface-Klasse sammeln
+        # 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.
 
         Parameters:
-            name: The name for the dynamically created model class.
-            attrs: The attributes dictionary to be updated with the new interface and factory classes.
-            interface: The interface base class defining the model structure and metadata.
-            base_model_class: The base class to use for the new model (defaults to GeneralManagerModel).
+            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).
 
         Returns:
-            tuple: A tuple containing the updated attributes dictionary, the new interface class, and the newly created model class.
+            tuple[attributes, interfaceBaseClass, relatedClass]: Updated attributes, interface class, and the generated model.
         """
         model_fields: dict[str, Any] = {}
         meta_class = None
         for attr_name, attr_value in interface.__dict__.items():
             if not attr_name.startswith("__"):
                 if attr_name == "Meta" and isinstance(attr_value, type):
-                    # Meta-Klasse speichern
+                    # Store the Meta class definition for later use
                     meta_class = attr_value
                 elif attr_name == "Factory":
-                    # Factory nicht in model_fields speichern
+                    # Do not register the factory on the model
                     pass
                 else:
                     model_fields[attr_name] = attr_value
         model_fields["__module__"] = attrs.get("__module__")
-        # Meta-Klasse hinzufügen oder erstellen
+        # Attach the Meta class or create a default one
         rules: list[Rule] | None = None
         if meta_class:
             model_fields["Meta"] = meta_class
@@ -489,19 +503,22 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                 rules = getattr(meta_class, "rules")
                 delattr(meta_class, "rules")
 
-        # Modell erstellen
-        model = type(name, (base_model_class,), model_fields)
+        # Create the concrete Django model dynamically
+        model = cast(
+            type[GeneralManagerBasisModel],
+            type(name, (base_model_class,), model_fields),
+        )
         if meta_class and rules:
             setattr(model._meta, "rules", rules)
             # full_clean Methode hinzufügen
-            model.full_clean = getFullCleanMethode(model)
+            setattr(model, "full_clean", getFullCleanMethode(model))
         # Interface-Typ bestimmen
         attrs["_interface_type"] = interface._interface_type
         interface_cls = type(interface.__name__, (interface,), {})
         setattr(interface_cls, "_model", model)
         attrs["Interface"] = interface_cls
 
-        # add factory class
+        # Build the associated factory class
         factory_definition = getattr(interface, "Factory", None)
         factory_attributes: dict[str, Any] = {}
         if factory_definition:
@@ -526,6 +543,11 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         Finalizes the setup of dynamically created classes by linking the interface and model to the new general manager class.
 
         This method sets the `_parent_class` attribute on the interface class and attaches the new general manager class to the model via the `_general_manager_class` attribute.
+
+        Parameters:
+            new_class (newlyCreatedGeneralManagerClass): Generated GeneralManager subclass.
+            interface_class (newlyCreatedInterfaceClass): Concrete interface class created for the model.
+            model (relatedClass): Django model linked to the manager.
         """
         interface_class._parent_class = new_class
         setattr(model, "_general_manager_class", new_class)
@@ -538,6 +560,9 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         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.
+
+        Returns:
+            tuple[classPreCreationMethod, classPostCreationMethod]: Hooks used during manager class creation.
         """
         return cls._preCreate, cls._postCreate
 
@@ -547,6 +572,12 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         Return the type associated with a given model field name.
 
         If the field is a relation and its related model has a `_general_manager_class` attribute, that class is returned; otherwise, returns the Django field type.
+
+        Parameters:
+            field_name (str): Name of the model field.
+
+        Returns:
+            type: Type or GeneralManager class representing the field.
         """
         field = cls._model._meta.get_field(field_name)
         if (

general_manager/interface/databaseInterface.py

@@ -1,3 +1,5 @@
+"""Concrete interface providing CRUD operations via Django ORM."""
+
 from __future__ import annotations
 from typing import (
     Type,
@@ -13,6 +15,8 @@ from django.db.models import NOT_PROVIDED
 
 
 class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
+    """CRUD-capable interface backed by a concrete Django model."""
+
     _interface_type = "database"
 
     @classmethod
@@ -20,16 +24,19 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         cls, creator_id: int | None, history_comment: str | None = None, **kwargs: Any
     ) -> int:
         """
-        Create a new model instance with the provided attributes and optional history tracking.
-
-        Validates input attributes, separates and sets many-to-many relationships, saves the instance with optional creator and history comment, and returns the primary key of the created instance.
+        Create a new model instance and return its primary key.
 
         Parameters:
-            creator_id (int | None): The ID of the user creating the instance, or None if not applicable.
-            history_comment (str | None): Optional comment to record in the instance's history.
+            creator_id (int | None): Identifier of the user creating the instance.
+            history_comment (str | None): Optional comment stored in the history log.
+            **kwargs (Any): Field values used to populate the model.
 
         Returns:
-            int: The primary key of the newly created instance.
+            int: Primary key of the newly created instance.
+
+        Raises:
+            ValueError: If unknown fields are supplied.
+            ValidationError: Propagated when model validation fails.
         """
         cls._checkForInvalidKwargs(cls._model, kwargs=kwargs)
         kwargs, many_to_many_kwargs = cls._sortKwargs(cls._model, kwargs)
@@ -42,14 +49,19 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         self, creator_id: int | None, history_comment: str | None = None, **kwargs: Any
     ) -> int:
         """
-        Update the current model instance with new attribute values and many-to-many relationships, saving changes with optional history tracking.
+        Update the current model instance and return its primary key.
 
         Parameters:
-            creator_id (int | None): The ID of the user making the update, or None if not specified.
-            history_comment (str | None): An optional comment describing the reason for the update.
+            creator_id (int | None): Identifier of the user performing the update.
+            history_comment (str | None): Optional comment stored in the history log.
+            **kwargs (Any): Field updates applied to the model.
 
         Returns:
-            int: The primary key of the updated instance.
+            int: Primary key of the updated instance.
+
+        Raises:
+            ValueError: If unknown fields are supplied.
+            ValidationError: Propagated when model validation fails.
         """
         self._checkForInvalidKwargs(self._model, kwargs=kwargs)
         kwargs, many_to_many_kwargs = self._sortKwargs(self._model, kwargs)
@@ -62,14 +74,14 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         self, creator_id: int | None, history_comment: str | None = None
     ) -> int:
         """
-        Deactivate the current model instance by setting its `is_active` flag to `False` and recording the change with an optional history comment.
+        Mark the current model instance as inactive and record the change.
 
         Parameters:
-            creator_id (int | None): The ID of the user performing the deactivation, or None if not specified.
-            history_comment (str | None): An optional comment to include in the instance's history log.
+            creator_id (int | None): Identifier of the user performing the action.
+            history_comment (str | None): Optional comment stored in the history log.
 
         Returns:
-            int: The primary key of the deactivated instance.
+            int: Primary key of the deactivated instance.
         """
         instance = self._model.objects.get(pk=self.pk)
         instance.is_active = False
@@ -84,12 +96,14 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         instance: GeneralManagerModel, many_to_many_kwargs: dict[str, list[Any]]
     ) -> GeneralManagerModel:
         """
-        Set many-to-many relationship fields on a model instance using the provided values.
-        
-        For each field, converts lists of `GeneralManager` instances to their IDs if necessary, and updates the corresponding many-to-many relationship on the instance. Fields with values of `None` or `NOT_PROVIDED` are ignored.
-        
+        Set many-to-many relationship values on the provided instance.
+
+        Parameters:
+            instance (GeneralManagerModel): Model instance whose relations are updated.
+            many_to_many_kwargs (dict[str, list[Any]]): Mapping of relation names to values.
+
         Returns:
-            GeneralManagerModel: The updated model instance with many-to-many relationships set.
+            GeneralManagerModel: Updated instance.
         """
         from general_manager.manager.generalManager import GeneralManager
 
@@ -113,6 +127,16 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         instance: GeneralManagerModel,
         kwargs: dict[str, Any],
     ) -> GeneralManagerModel:
+        """
+        Populate non-relational fields on the instance before saving.
+
+        Parameters:
+            instance (GeneralManagerModel): Model instance that will receive the values.
+            kwargs (dict[str, Any]): Key-value pairs to assign to the instance.
+
+        Returns:
+            GeneralManagerModel: Instance with updated attributes.
+        """
         from general_manager.manager.generalManager import GeneralManager
 
         for key, value in kwargs.items():
@@ -130,7 +154,19 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         return instance
 
     @staticmethod
-    def _checkForInvalidKwargs(model: Type[models.Model], kwargs: dict[str, Any]):
+    def _checkForInvalidKwargs(
+        model: Type[models.Model], kwargs: dict[str, Any]
+    ) -> None:
+        """
+        Ensure provided keyword arguments map to known fields or attributes.
+
+        Parameters:
+            model (type[models.Model]): Django model being validated.
+            kwargs (dict[str, Any]): Keyword arguments supplied by the caller.
+
+        Raises:
+            ValueError: If an unknown field name is encountered.
+        """
         attributes = vars(model)
         field_names = {f.name for f in model._meta.get_fields()}
         for key in kwargs:
@@ -142,6 +178,16 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
     def _sortKwargs(
         model: Type[models.Model], kwargs: dict[Any, Any]
     ) -> tuple[dict[str, Any], dict[str, list[Any]]]:
+        """
+        Split keyword arguments into simple fields and many-to-many relations.
+
+        Parameters:
+            model (type[models.Model]): Model whose relation metadata is inspected.
+            kwargs (dict[Any, Any]): Keyword arguments supplied by the caller.
+
+        Returns:
+            tuple[dict[str, Any], dict[str, list[Any]]]: Tuple containing simple-field kwargs and many-to-many kwargs.
+        """
         many_to_many_fields = [field.name for field in model._meta.many_to_many]
         many_to_many_kwargs: dict[Any, Any] = {}
         for key, value in list(kwargs.items()):

general_manager/interface/models.py

@@ -1,6 +1,9 @@
+"""Django model mixins and helpers backing GeneralManager interfaces."""
+
 from __future__ import annotations
 from typing import Type, ClassVar, Any, Callable, TYPE_CHECKING, TypeVar
 from django.db import models
+from django.contrib.auth.models import AbstractUser
 from django.conf import settings
 from simple_history.models import HistoricalRecords  # type: ignore
 from django.core.exceptions import ValidationError
@@ -8,7 +11,6 @@ from django.core.exceptions import ValidationError
 
 if TYPE_CHECKING:
     from general_manager.manager.generalManager import GeneralManager
-    from django.contrib.auth.models import AbstractUser
     from general_manager.rule.rule import Rule
 
 modelsModel = TypeVar("modelsModel", bound=models.Model)
@@ -27,7 +29,7 @@ def getFullCleanMethode(model: Type[models.Model]) -> Callable[..., None]:
         Callable[..., None]: A `full_clean` method that can be assigned to the model class.
     """
 
-    def full_clean(self: models.Model, *args: Any, **kwargs: Any):
+    def full_clean(self: models.Model, *args: Any, **kwargs: Any) -> None:
         """
         Performs full validation on the model instance, including both standard Django validation and custom rule-based checks.
 
@@ -53,6 +55,8 @@ def getFullCleanMethode(model: Type[models.Model]) -> Callable[..., None]:
 
 
 class GeneralManagerBasisModel(models.Model):
+    """Abstract base model providing shared fields for GeneralManager storage."""
+
     _general_manager_class: ClassVar[Type[GeneralManager]]
     is_active = models.BooleanField(default=True)
     history = HistoricalRecords(inherit=True)
@@ -62,6 +66,8 @@ class GeneralManagerBasisModel(models.Model):
 
 
 class GeneralManagerModel(GeneralManagerBasisModel):
+    """Abstract model adding change-tracking metadata for writeable managers."""
+
     changed_by = models.ForeignKey(
         settings.AUTH_USER_MODEL, on_delete=models.PROTECT, null=True, blank=True
     )
@@ -75,14 +81,14 @@ class GeneralManagerModel(GeneralManagerBasisModel):
         return self.changed_by
 
     @_history_user.setter
-    def _history_user(self, value: AbstractUser) -> None:
+    def _history_user(self, value: AbstractUser | None) -> None:
         """
         Set the user responsible for the most recent change to the model instance.
 
         Parameters:
             value (AbstractUser): The user to associate with the latest modification.
         """
-        self.changed_by = value
+        setattr(self, "changed_by", value)
 
     class Meta:  # type: ignore
         abstract = True