GeneralManager 0.6.2__py3-none-any.whl → 0.8.0__py3-none-any.whl

general_manager/interface/baseInterface.py

@@ -18,7 +18,6 @@ from general_manager.auxiliary import args_to_kwargs
 if TYPE_CHECKING:
     from general_manager.manager.input import Input
     from general_manager.manager.generalManager import GeneralManager
-    from general_manager.manager.meta import GeneralManagerMeta
     from general_manager.bucket.baseBucket import Bucket
 
 
@@ -28,7 +27,7 @@ type attributes = dict[str, Any]
 type interfaceBaseClass = Type[InterfaceBase]
 type newlyCreatedInterfaceClass = Type[InterfaceBase]
 type relatedClass = Type[Model] | None
-type newlyCreatedGeneralManagerClass = GeneralManagerMeta
+type newlyCreatedGeneralManagerClass = Type[GeneralManager]
 
 type classPreCreationMethod = Callable[
     [generalManagerClassName, attributes, interfaceBaseClass],
@@ -52,10 +51,11 @@ class AttributeTypedDict(TypedDict):
     default: Any
     is_required: bool
     is_editable: bool
+    is_derived: bool
 
 
 class InterfaceBase(ABC):
-    _parent_class: ClassVar[Type[Any]]
+    _parent_class: Type[GeneralManager]
     _interface_type: ClassVar[str]
     input_fields: dict[str, Input]
 
@@ -70,9 +70,9 @@ class InterfaceBase(ABC):
     ) -> dict[str, Any]:
         """
         Parses and validates input arguments into a structured identification dictionary.
-        
+
         Converts positional and keyword arguments into a dictionary keyed by input field names, normalizing argument names and ensuring all required fields are present. Processes input fields in dependency order, casting and validating each value. Raises a `TypeError` for unexpected or missing arguments and a `ValueError` if circular dependencies among input fields are detected.
-        
+
         Returns:
             A dictionary mapping input field names to their validated and cast values.
         """
@@ -131,7 +131,7 @@ class InterfaceBase(ABC):
     ) -> None:
         """
         Validates the type and allowed values of an input field.
-        
+
         Ensures that the provided value matches the expected type for the specified input field. In debug mode, also checks that the value is among the allowed possible values if defined, supporting both callables and iterables. Raises a TypeError for invalid types or possible value definitions, and a ValueError if the value is not permitted.
         """
         input_field = self.input_fields[name]
@@ -218,13 +218,13 @@ class InterfaceBase(ABC):
     def getFieldType(cls, field_name: str) -> type:
         """
         Returns the type of the specified input field.
-        
+
         Args:
             field_name: The name of the input field.
-        
+
         Returns:
             The Python type associated with the given field name.
-        
+
         Raises:
             NotImplementedError: This method must be implemented by subclasses.
         """

general_manager/interface/databaseBasedInterface.py

@@ -1,12 +1,5 @@
 from __future__ import annotations
-from typing import (
-    Type,
-    ClassVar,
-    Any,
-    Callable,
-    TYPE_CHECKING,
-    TypeVar,
-)
+from typing import Type, ClassVar, Any, Callable, TYPE_CHECKING, TypeVar, Generic
 from django.db import models
 from django.conf import settings
 from datetime import datetime, timedelta
@@ -66,17 +59,28 @@ def getFullCleanMethode(model: Type[models.Model]) -> Callable[..., None]:
     return full_clean
 
 
-class GeneralManagerModel(models.Model):
+class GeneralManagerBasisModel(models.Model):
     _general_manager_class: ClassVar[Type[GeneralManager]]
     is_active = models.BooleanField(default=True)
-    changed_by = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.PROTECT)
-    changed_by_id: int
     history = HistoricalRecords(inherit=True)
 
+    class Meta:
+        abstract = True
+
+
+class GeneralManagerModel(GeneralManagerBasisModel):
+    changed_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL, on_delete=models.PROTECT, null=True, blank=True
+    )
+    changed_by_id: int | None
+
     @property
-    def _history_user(self) -> AbstractUser:
+    def _history_user(self) -> AbstractUser | None:
         """
-        Returns the user who last modified this model instance.
+        Gets the user who last modified this model instance, or None if not set.
+        
+        Returns:
+            AbstractUser | None: The user who last changed the instance, or None if unavailable.
         """
         return self.changed_by
 
@@ -90,12 +94,15 @@ class GeneralManagerModel(models.Model):
         """
         self.changed_by = value
 
-    class Meta:
+    class Meta:  # type: ignore
         abstract = True
 
 
-class DBBasedInterface(InterfaceBase):
-    _model: ClassVar[Type[GeneralManagerModel]]
+MODEL_TYPE = TypeVar("MODEL_TYPE", bound=GeneralManagerBasisModel)
+
+
+class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
+    _model: Type[MODEL_TYPE]
     input_fields: dict[str, Input] = {"id": Input(int)}
 
     def __init__(
@@ -105,15 +112,15 @@ class DBBasedInterface(InterfaceBase):
         **kwargs: dict[str, Any],
     ):
         """
-        Initializes the interface instance and loads the corresponding model record.
-
-        If a `search_date` is provided, retrieves the historical record as of that date; otherwise, loads the current record.
+        Initialize the interface instance and load the associated model record.
+        
+        If `search_date` is provided, retrieves the historical record as of that date; otherwise, loads the current record.
         """
         super().__init__(*args, **kwargs)
         self.pk = self.identification["id"]
         self._instance = self.getData(search_date)
 
-    def getData(self, search_date: datetime | None = None) -> GeneralManagerModel:
+    def getData(self, search_date: datetime | None = None) -> GeneralManagerBasisModel:
         """
         Retrieves the model instance by primary key, optionally as of a specified historical date.
 
@@ -177,8 +184,8 @@ class DBBasedInterface(InterfaceBase):
 
     @classmethod
     def getHistoricalRecord(
-        cls, instance: GeneralManagerModel, search_date: datetime | None = None
-    ) -> GeneralManagerModel:
+        cls, instance: GeneralManagerBasisModel, search_date: datetime | None = None
+    ) -> GeneralManagerBasisModel:
         """
         Retrieves the most recent historical record of a model instance at or before a specified date.
 
@@ -194,9 +201,12 @@ class DBBasedInterface(InterfaceBase):
     @classmethod
     def getAttributeTypes(cls) -> dict[str, AttributeTypedDict]:
         """
-        Returns a dictionary mapping attribute names to their type information and metadata.
-
-        The returned dictionary includes all model fields, custom fields, foreign keys, many-to-many, and reverse relation fields. Each entry provides the Python type (translated from Django field types when possible), whether the field is required, editable, and its default value. For related models that have a general manager class, the type is set to that class.
+        Return a dictionary mapping attribute names to metadata describing their type and properties.
+        
+        The returned dictionary includes all model fields, custom fields, foreign keys, many-to-many, and reverse relation fields. For each attribute, the metadata includes its Python type (translated from Django field types when possible), whether it is required, editable, derived, and its default value. For related models with a general manager class, the type is set to that class.
+         
+        Returns:
+            dict[str, AttributeTypedDict]: Mapping of attribute names to their type information and metadata.
         """
         TRANSLATION: dict[Type[models.Field[Any, Any]], type] = {
             models.fields.BigAutoField: int,
@@ -222,6 +232,7 @@ class DBBasedInterface(InterfaceBase):
             field: models.Field = getattr(cls._model, field_name)
             fields[field_name] = {
                 "type": type(field),
+                "is_derived": False,
                 "is_required": not field.null,
                 "is_editable": field.editable,
                 "default": field.default,
@@ -232,6 +243,7 @@ class DBBasedInterface(InterfaceBase):
                 field: models.Field = getattr(cls._model, field_name).field
                 fields[field_name] = {
                     "type": type(field),
+                    "is_derived": False,
                     "is_required": not field.null,
                     "is_editable": field.editable,
                     "default": field.default,
@@ -249,6 +261,7 @@ class DBBasedInterface(InterfaceBase):
             elif related_model is not None:
                 fields[field_name] = {
                     "type": related_model,
+                    "is_derived": False,
                     "is_required": not field.null,
                     "is_editable": field.editable,
                     "default": field.default,
@@ -274,6 +287,7 @@ class DBBasedInterface(InterfaceBase):
                 fields[f"{field_name}_list"] = {
                     "type": related_model,
                     "is_required": False,
+                    "is_derived": not bool(field.many_to_many),
                     "is_editable": bool(field.many_to_many and field.editable),
                     "default": None,
                 }
@@ -440,16 +454,25 @@ class DBBasedInterface(InterfaceBase):
 
     @staticmethod
     def _preCreate(
-        name: generalManagerClassName, attrs: attributes, interface: interfaceBaseClass
+        name: generalManagerClassName,
+        attrs: attributes,
+        interface: interfaceBaseClass,
+        base_model_class=GeneralManagerModel,
     ) -> tuple[attributes, interfaceBaseClass, relatedClass]:
         # Felder aus der Interface-Klasse sammeln
         """
-        Dynamically creates a Django model, its associated interface class, and a factory class based on the provided interface definition.
-
-        This method extracts fields and meta information from the interface class, constructs a new Django model inheriting from `GeneralManagerModel`, attaches custom validation rules if present, and generates a corresponding interface and factory class. The resulting classes are returned for further use in the general manager framework.
-
+        Dynamically creates a Django model class, its associated interface class, and a factory class from an interface definition.
+        
+        This method extracts fields and meta information from the provided interface class, constructs a new Django model inheriting from the specified base model class, attaches custom validation rules if present, and generates corresponding interface and factory classes. The resulting classes 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).
+        
         Returns:
-            A tuple containing the updated attributes dictionary, the new interface class, and the newly created model class.
+            tuple: A tuple containing the updated attributes dictionary, the new interface class, and the newly created model class.
         """
         model_fields: dict[str, Any] = {}
         meta_class = None
@@ -474,7 +497,7 @@ class DBBasedInterface(InterfaceBase):
                 delattr(meta_class, "rules")
 
         # Modell erstellen
-        model = type(name, (GeneralManagerModel,), model_fields)
+        model = type(name, (base_model_class,), model_fields)
         if meta_class and rules:
             setattr(model._meta, "rules", rules)
             # full_clean Methode hinzufügen

general_manager/interface/databaseInterface.py

@@ -11,14 +11,25 @@ from general_manager.interface.databaseBasedInterface import (
 )
 
 
-class DatabaseInterface(DBBasedInterface):
+class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
     _interface_type = "database"
 
     @classmethod
     def create(
-        cls, creator_id: int, history_comment: str | None = None, **kwargs: Any
+        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.
+
+        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.
 
+        Returns:
+            int: The primary key of the newly created instance.
+        """
         cls._checkForInvalidKwargs(cls._model, kwargs=kwargs)
         kwargs, many_to_many_kwargs = cls._sortKwargs(cls._model, kwargs)
         instance = cls.__setAttrForWrite(cls._model(), kwargs)
@@ -27,9 +38,18 @@ class DatabaseInterface(DBBasedInterface):
         return pk
 
     def update(
-        self, creator_id: int, history_comment: str | None = None, **kwargs: Any
+        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.
+
+        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.
 
+        Returns:
+            int: The primary key of the updated instance.
+        """
         self._checkForInvalidKwargs(self._model, kwargs=kwargs)
         kwargs, many_to_many_kwargs = self._sortKwargs(self._model, kwargs)
         instance = self.__setAttrForWrite(self._model.objects.get(pk=self.pk), kwargs)
@@ -37,7 +57,19 @@ class DatabaseInterface(DBBasedInterface):
         self.__setManyToManyAttributes(instance, many_to_many_kwargs)
         return pk
 
-    def deactivate(self, creator_id: int, history_comment: str | None = None) -> int:
+    def deactivate(
+        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.
+
+        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.
+
+        Returns:
+            int: The primary key of the deactivated instance.
+        """
         instance = self._model.objects.get(pk=self.pk)
         instance.is_active = False
         if history_comment:
@@ -89,7 +121,7 @@ class DatabaseInterface(DBBasedInterface):
         for key in kwargs:
             temp_key = key.split("_id_list")[0]  # Remove '_id_list' suffix
             if temp_key not in attributes and temp_key not in field_names:
-                raise ValueError(f"{key} does not exsist in {model.__name__}")
+                raise ValueError(f"{key} does not exist in {model.__name__}")
 
     @staticmethod
     def _sortKwargs(
@@ -106,17 +138,15 @@ class DatabaseInterface(DBBasedInterface):
     @classmethod
     @transaction.atomic
     def _save_with_history(
-        cls, instance: GeneralManagerModel, creator_id: int, history_comment: str | None
+        cls,
+        instance: GeneralManagerModel,
+        creator_id: int | None,
+        history_comment: str | None,
     ) -> int:
         """
-        Saves a model instance with validation and optional history tracking.
+        Atomically saves a model instance with validation and optional history comment.
 
-        Sets the `changed_by_id` field, validates the instance, applies a history comment if provided, and saves the instance within an atomic transaction.
-
-        Args:
-            instance: The model instance to save.
-            creator_id: The ID of the user making the change.
-            history_comment: Optional comment describing the reason for the change.
+        Sets the `changed_by_id` field, validates the instance, applies a history comment if provided, and saves the instance within a database transaction.
 
         Returns:
             The primary key of the saved instance.

general_manager/interface/readOnlyInterface.py

@@ -5,34 +5,73 @@ from typing import Type, Any, Callable, TYPE_CHECKING
 from django.db import models, transaction
 from general_manager.interface.databaseBasedInterface import (
     DBBasedInterface,
-    GeneralManagerModel,
+    GeneralManagerBasisModel,
     classPreCreationMethod,
     classPostCreationMethod,
+    generalManagerClassName,
+    attributes,
+    interfaceBaseClass,
 )
+from django.db import connection
+from typing import ClassVar
+from django.core.checks import Warning
+import logging
 
 if TYPE_CHECKING:
     from general_manager.manager.generalManager import GeneralManager
-    from general_manager.manager.meta import GeneralManagerMeta
 
 
-class ReadOnlyInterface(DBBasedInterface):
+logger = logging.getLogger(__name__)
+
+
+class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
     _interface_type = "readonly"
+    _parent_class: Type[GeneralManager]
 
-    @classmethod
-    def sync_data(cls) -> None:
+    @staticmethod
+    def getUniqueFields(model: Type[models.Model]) -> set[str]:
+        """
+        Return a set of field names that uniquely identify instances of the specified Django model.
+        
+        Considers fields marked as unique (excluding "id"), as well as fields defined in `unique_together` and `UniqueConstraint` constraints.
         """
-        Synchronizes the database model with JSON data, ensuring exact correspondence.
+        opts = model._meta
+        unique_fields: set[str] = set()
 
-        This method parses JSON data from the parent class and updates the associated Django model so that its records exactly match the JSON content. It creates or updates instances based on unique fields and deletes any database entries not present in the JSON data. Raises a ValueError if required attributes are missing or if the JSON data is invalid.
+        for field in opts.local_fields:
+            if getattr(field, "unique", False):
+                if field.name == "id":
+                    continue
+                unique_fields.add(field.name)
+
+        for ut in opts.unique_together:
+            unique_fields.update(ut)
+
+        for constraint in opts.constraints:
+            if isinstance(constraint, models.UniqueConstraint):
+                unique_fields.update(constraint.fields)
+
+        return unique_fields
+
+    @classmethod
+    def syncData(cls) -> None:
         """
-        model: Type[models.Model] | None = getattr(cls, "_model", None)
-        parent_class = getattr(cls, "_parent_class", None)
-        if model is None or parent_class is None:
-            raise ValueError("Attribute '_model' and '_parent_class' must be set.")
-        json_data = getattr(parent_class, "_json_data", None)
-        if not json_data:
+        Synchronizes the associated Django model with JSON data from the parent class, ensuring the database records match the provided data exactly.
+        
+        Parses the JSON data, creates or updates model instances based on unique fields, and deactivates any database records not present in the JSON data. Raises a ValueError if required attributes are missing, if the JSON data is invalid, or if no unique fields are defined.
+        """
+        if cls.ensureSchemaIsUpToDate(cls._parent_class, cls._model):
+            logger.warning(
+                f"Schema for ReadOnlyInterface '{cls._parent_class.__name__}' is not up to date."
+            )
+            return
+
+        model = cls._model
+        parent_class = cls._parent_class
+        json_data = getattr(parent_class, "_data", None)
+        if json_data is None:
             raise ValueError(
-                f"For ReadOnlyInterface '{parent_class.__name__}' must be set '_json_data'"
+                f"For ReadOnlyInterface '{parent_class.__name__}' must set '_data'"
             )
 
         # JSON-Daten parsen
@@ -41,67 +80,193 @@ class ReadOnlyInterface(DBBasedInterface):
         elif isinstance(json_data, list):
             data_list: list[Any] = json_data
         else:
-            raise ValueError(
-                "_json_data must be a JSON string or a list of dictionaries"
-            )
+            raise ValueError("_data must be a JSON string or a list of dictionaries")
 
-        unique_fields = getattr(parent_class, "_unique_fields", [])
+        unique_fields = cls.getUniqueFields(model)
         if not unique_fields:
             raise ValueError(
-                f"For ReadOnlyInterface '{parent_class.__name__}' must be defined '_unique_fields'"
+                f"For ReadOnlyInterface '{parent_class.__name__}' must have at least one unique field."
             )
 
+        changes = {
+            "created": [],
+            "updated": [],
+            "deactivated": [],
+        }
+
         with transaction.atomic():
             json_unique_values: set[Any] = set()
 
-            # Daten synchronisieren
+            # data synchronization
             for data in data_list:
                 lookup = {field: data[field] for field in unique_fields}
                 unique_identifier = tuple(lookup[field] for field in unique_fields)
                 json_unique_values.add(unique_identifier)
 
-                instance, _ = model.objects.get_or_create(**lookup)
+                instance, is_created = model.objects.get_or_create(**lookup)
                 updated = False
                 for field_name, value in data.items():
                     if getattr(instance, field_name, None) != value:
                         setattr(instance, field_name, value)
                         updated = True
-                if updated:
+                if updated or not instance.is_active:
+                    instance.is_active = True
                     instance.save()
+                    changes["created" if is_created else "updated"].append(instance)
 
-            # Existierende Einträge abrufen und löschen, wenn nicht im JSON vorhanden
-            existing_instances = model.objects.all()
+            # deactivate instances not in JSON data
+            existing_instances = model.objects.filter(is_active=True)
             for instance in existing_instances:
                 lookup = {field: getattr(instance, field) for field in unique_fields}
                 unique_identifier = tuple(lookup[field] for field in unique_fields)
                 if unique_identifier not in json_unique_values:
-                    instance.delete()
+                    instance.is_active = False
+                    instance.save()
+                    changes["deactivated"].append(instance)
+
+        if changes["created"] or changes["updated"] or changes["deactivated"]:
+            logger.info(
+                f"Data changes for ReadOnlyInterface '{parent_class.__name__}': "
+                f"Created: {len(changes['created'])}, "
+                f"Updated: {len(changes['updated'])}, "
+                f"Deactivated: {len(changes['deactivated'])}"
+            )
 
     @staticmethod
-    def readOnlyPostCreate(func: Callable[..., Any]) -> Callable[..., Any]:
+    def ensureSchemaIsUpToDate(
+        new_manager_class: Type[GeneralManager], model: Type[models.Model]
+    ) -> list[Warning]:
         """
-        Decorator for post-creation hooks that registers the interface class as read-only.
+        Check if the database schema for a Django model matches its model definition.
+        
+        Returns:
+            A list of Django Warning objects describing schema issues, such as missing tables or column mismatches. Returns an empty list if the schema is up to date.
+        """
+
+        def table_exists(table_name: str) -> bool:
+            """
+            Determine whether a database table with the specified name exists.
+            
+            Parameters:
+                table_name (str): Name of the database table to check.
+            
+            Returns:
+                bool: True if the table exists, False otherwise.
+            """
+            with connection.cursor() as cursor:
+                tables = connection.introspection.table_names(cursor)
+            return table_name in tables
+
+        def compare_model_to_table(
+            model: Type[models.Model], table: str
+        ) -> tuple[list[str], list[str]]:
+            """
+            Compares the fields of a Django model to the columns of a specified database table.
+            
+            Returns:
+                A tuple containing two lists:
+                    - The first list contains column names defined in the model but missing from the database table.
+                    - The second list contains column names present in the database table but not defined in the model.
+            """
+            with connection.cursor() as cursor:
+                desc = connection.introspection.get_table_description(cursor, table)
+            existing_cols = {col.name for col in desc}
+            model_cols = {field.column for field in model._meta.local_fields}
+            missing = model_cols - existing_cols
+            extra = existing_cols - model_cols
+            return list(missing), list(extra)
 
-        Wraps a function to be called after a class creation event, then appends the interface
-        class to the meta-class's `read_only_classes` list.
+        table = model._meta.db_table
+        if not table_exists(table):
+            return [
+                Warning(
+                    f"Database table does not exist!",
+                    hint=f"ReadOnlyInterface '{new_manager_class.__name__}' (Table '{table}') does not exist in the database.",
+                    obj=model,
+                )
+            ]
+        missing, extra = compare_model_to_table(model, table)
+        if missing or extra:
+            return [
+                Warning(
+                    "Database schema mismatch!",
+                    hint=(
+                        f"ReadOnlyInterface '{new_manager_class.__name__}' has missing columns: {missing} or extra columns: {extra}. \n"
+                        "        Please update the model or the database schema, to enable data synchronization."
+                    ),
+                    obj=model,
+                )
+            ]
+        return []
+
+    @staticmethod
+    def readOnlyPostCreate(func: Callable[..., Any]) -> Callable[..., Any]:
+        """
+        Decorator for post-creation hooks that registers a new manager class as read-only.
+        
+        After the wrapped post-creation function is executed, the newly created manager class is added to the meta-class's list of read-only classes, marking it as a read-only interface.
         """
 
         def wrapper(
-            mcs: Type[GeneralManagerMeta],
             new_class: Type[GeneralManager],
             interface_cls: Type[ReadOnlyInterface],
-            model: Type[GeneralManagerModel],
+            model: Type[GeneralManagerBasisModel],
         ):
-            func(mcs, new_class, interface_cls, model)
-            mcs.read_only_classes.append(interface_cls)
+            """
+            Registers a newly created manager class as read-only after executing the wrapped post-creation function.
+            
+            This function appends the new manager class to the list of read-only classes in the meta system, ensuring it is recognized as a read-only interface.
+            """
+            from general_manager.manager.meta import GeneralManagerMeta
+
+            func(new_class, interface_cls, model)
+            GeneralManagerMeta.read_only_classes.append(new_class)
+
+        return wrapper
+
+    @staticmethod
+    def readOnlyPreCreate(func: Callable[..., Any]) -> Callable[..., Any]:
+        """
+        Decorator for pre-creation hook functions that ensures the base model class is set to `GeneralManagerBasisModel`.
+        
+        Wraps a pre-creation function, injecting `GeneralManagerBasisModel` as the `base_model_class` argument before the manager class is created.
+        """
+
+        def wrapper(
+            name: generalManagerClassName,
+            attrs: attributes,
+            interface: interfaceBaseClass,
+            base_model_class=GeneralManagerBasisModel,
+        ):
+            """
+            Wraps a function to ensure the `base_model_class` argument is set to `GeneralManagerBasisModel` before invocation.
+            
+            Parameters:
+                name: The name of the manager class being created.
+                attrs: Attributes for the manager class.
+                interface: The interface base class to use.
+            
+            Returns:
+                The result of calling the wrapped function with `base_model_class` set to `GeneralManagerBasisModel`.
+            """
+            return func(
+                name, attrs, interface, base_model_class=GeneralManagerBasisModel
+            )
 
         return wrapper
 
     @classmethod
     def handleInterface(cls) -> tuple[classPreCreationMethod, classPostCreationMethod]:
         """
-        Returns pre- and post-creation methods for integrating the interface with a GeneralManager.
-
-        The pre-creation method modifies keyword arguments before a GeneralManager instance is created. The post-creation method, wrapped with a decorator, modifies the instance after creation to add additional data. These methods are intended for use by the GeneralManagerMeta class during the manager's lifecycle.
+        Return the pre- and post-creation hook methods for integrating the interface with a manager meta-class system.
+        
+        The returned tuple includes:
+        - A pre-creation method that ensures the base model class is set for read-only operation.
+        - A post-creation method that registers the manager class as read-only.
+        
+        Returns:
+            tuple: The pre-creation and post-creation hook methods for manager class lifecycle integration.
         """
-        return cls._preCreate, cls.readOnlyPostCreate(cls._postCreate)
+        return cls.readOnlyPreCreate(cls._preCreate), cls.readOnlyPostCreate(
+            cls._postCreate
+        )