GeneralManager 0.6.2__tar.gz → 0.7.0__tar.gz

{generalmanager-0.6.2 → generalmanager-0.7.0}/GeneralManager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.6.2
+Version: 0.7.0
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License-Expression: MIT

{generalmanager-0.6.2 → generalmanager-0.7.0}/GeneralManager.egg-info/SOURCES.txt

@@ -82,6 +82,7 @@ tests/test_measurement.py
 tests/test_measurement_field.py
 tests/test_modelDependencyCollector.py
 tests/test_noneToZero.py
+tests/test_readOnlyInterface.py
 tests/test_rule_handler.py
 tests/test_rules.py
 tests/test_settings.py

{generalmanager-0.6.2 → generalmanager-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.6.2
+Version: 0.7.0
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License-Expression: MIT

{generalmanager-0.6.2 → generalmanager-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.6.2"
+version = "0.7.0"
 description = "Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching."
 readme = "README.md"
 authors = [{ name = "Tim Kleindick", email = "tkleindick@yahoo.de" }]

generalmanager-0.7.0/src/general_manager/apps.py

@@ -0,0 +1,170 @@
+from django.apps import AppConfig
+import graphene
+import os
+from django.conf import settings
+from django.urls import path
+from graphene_django.views import GraphQLView
+from importlib import import_module
+from general_manager.manager.generalManager import GeneralManager
+from general_manager.manager.meta import GeneralManagerMeta
+from general_manager.manager.input import Input
+from general_manager.api.property import graphQlProperty
+from general_manager.api.graphql import GraphQL
+from typing import TYPE_CHECKING, Type
+from django.core.checks import register
+import logging
+
+
+if TYPE_CHECKING:
+    from general_manager.interface.readOnlyInterface import ReadOnlyInterface
+
+logger = logging.getLogger(__name__)
+
+
+class GeneralmanagerConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "general_manager"
+
+    def ready(self):
+        """
+        Initializes the general_manager app when Django starts.
+        
+        Sets up read-only interface synchronization and schema validation, initializes general manager class attributes and connections, and conditionally configures the GraphQL schema and endpoint based on settings.
+        """
+        self.handleReadOnlyInterface()
+        self.initializeGeneralManagerClasses()
+        if getattr(settings, "AUTOCREATE_GRAPHQL", False):
+            self.handleGraphQL()
+
+    def handleReadOnlyInterface(self):
+        """
+        Sets up synchronization and schema validation for all registered read-only interfaces.
+        
+        This method patches Django's management command execution to ensure read-only interfaces are synchronized during server runs. It also registers system checks for each read-only interface to validate that their schemas are up to date.
+        """
+        self.patchReadOnlyInterfaceSync(GeneralManagerMeta.read_only_classes)
+        from general_manager.interface.readOnlyInterface import ReadOnlyInterface
+
+        logger.debug("starting to register ReadOnlyInterface schema warnings...")
+        for general_manager_class in GeneralManagerMeta.read_only_classes:
+            read_only_interface: ReadOnlyInterface = general_manager_class.Interface  # type: ignore
+
+            register(
+                lambda app_configs, model=read_only_interface._model, manager_class=general_manager_class, **kwargs: ReadOnlyInterface.ensureSchemaIsUpToDate(
+                    manager_class, model
+                ),
+                "general_manager",
+            )
+
+    @staticmethod
+    def patchReadOnlyInterfaceSync(general_manager_classes: list[Type[GeneralManager]]):
+        """
+        Monkey-patches Django's management command runner to synchronize read-only interface data before executing commands.
+        
+        This ensures that for each provided general manager class, its associated read-only interface's `syncData` method is called before running management commands, except during autoreload subprocesses for `runserver`.
+        """
+        from django.core.management.base import BaseCommand
+
+        original_run_from_argv = BaseCommand.run_from_argv
+
+        def run_from_argv_with_sync(self, argv):
+            # Ensure syncData is only called at real run of runserver
+            """
+            Runs the management command and synchronizes read-only interface data before execution when appropriate.
+            
+            Synchronization occurs for all registered read-only interfaces unless the command is 'runserver' in an autoreload subprocess.
+            """
+            run_main = os.environ.get("RUN_MAIN") == "true"
+            command = argv[1] if len(argv) > 1 else None
+            if command != "runserver" or run_main:
+                logger.debug("start syncing ReadOnlyInterface data...")
+                for general_manager_class in general_manager_classes:
+                    read_only_interface: ReadOnlyInterface = general_manager_class.Interface  # type: ignore
+                    read_only_interface.syncData()
+
+                logger.debug("finished syncing ReadOnlyInterface data.")
+
+            return original_run_from_argv(self, argv)
+
+        BaseCommand.run_from_argv = run_from_argv_with_sync
+
+    def initializeGeneralManagerClasses(self):
+        """
+        Initializes attributes and interconnections for all GeneralManager classes.
+        
+        For each pending GeneralManager class, sets up its attributes and creates property accessors. Then, for all GeneralManager classes, connects input fields referencing other GeneralManager subclasses by dynamically adding GraphQL properties to enable filtered access to related objects.
+        """
+        logger.debug("Initializing GeneralManager classes...")
+
+        logger.debug("starting to create attributes for GeneralManager classes...")
+        for (
+            general_manager_class
+        ) in GeneralManagerMeta.pending_attribute_initialization:
+            attributes = general_manager_class.Interface.getAttributes()
+            setattr(general_manager_class, "_attributes", attributes)
+            GeneralManagerMeta.createAtPropertiesForAttributes(
+                attributes.keys(), general_manager_class
+            )
+
+        logger.debug("starting to connect inputs to other general manager classes...")
+        for general_manager_class in GeneralManagerMeta.all_classes:
+            attributes = getattr(general_manager_class.Interface, "input_fields", {})
+            for attribute_name, attribute in attributes.items():
+                if isinstance(attribute, Input) and issubclass(
+                    attribute.type, GeneralManager
+                ):
+                    connected_manager = attribute.type
+                    func = lambda x, attribute_name=attribute_name: general_manager_class.filter(
+                        **{attribute_name: x}
+                    )
+
+                    func.__annotations__ = {"return": general_manager_class}
+                    setattr(
+                        connected_manager,
+                        f"{general_manager_class.__name__.lower()}_list",
+                        graphQlProperty(func),
+                    )
+
+    def handleGraphQL(self):
+        """
+        Sets up GraphQL interfaces, mutations, and schema for all pending general manager classes, and adds the GraphQL endpoint to the Django URL configuration.
+        """
+        logger.debug("Starting to create GraphQL interfaces and mutations...")
+        for general_manager_class in GeneralManagerMeta.pending_graphql_interfaces:
+            GraphQL.createGraphqlInterface(general_manager_class)
+            GraphQL.createGraphqlMutation(general_manager_class)
+
+        query_class = type("Query", (graphene.ObjectType,), GraphQL._query_fields)
+        GraphQL._query_class = query_class
+
+        mutation_class = type(
+            "Mutation",
+            (graphene.ObjectType,),
+            {name: mutation.Field() for name, mutation in GraphQL._mutations.items()},
+        )
+        GraphQL._mutation_class = mutation_class
+
+        schema = graphene.Schema(
+            query=GraphQL._query_class,
+            mutation=GraphQL._mutation_class,
+        )
+        self.addGraphqlUrl(schema)
+
+    def addGraphqlUrl(self, schema):
+        """
+        Dynamically adds a GraphQL endpoint to the Django URL configuration using the provided schema.
+        
+        Raises an exception if the ROOT_URLCONF setting is not defined.
+        """
+        logging.debug("Adding GraphQL URL to Django settings...")
+        root_url_conf_path = getattr(settings, "ROOT_URLCONF", None)
+        graph_ql_url = getattr(settings, "GRAPHQL_URL", "graphql/")
+        if not root_url_conf_path:
+            raise Exception("ROOT_URLCONF not found in settings")
+        urlconf = import_module(root_url_conf_path)
+        urlconf.urlpatterns.append(
+            path(
+                graph_ql_url,
+                GraphQLView.as_view(graphiql=True, schema=schema),
+            )
+        )

{generalmanager-0.6.2 → generalmanager-0.7.0}/src/general_manager/cache/dependencyIndex.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 import time
 import ast
 import re
+import logging
 
 from django.core.cache import cache
 from general_manager.cache.signals import post_data_change, pre_data_change
@@ -27,6 +28,8 @@ type dependency_index = dict[
 type filter_type = Literal["filter", "exclude", "identification"]
 type Dependency = Tuple[general_manager_name, filter_type, str]
 
+logger = logging.getLogger(__name__)
+
 # -----------------------------------------------------------------------------
 # CONFIG
 # -----------------------------------------------------------------------------
@@ -181,6 +184,11 @@ def generic_cache_invalidation(
     old_relevant_values: dict[str, Any],
     **kwargs,
 ):
+    """
+    Invalidates cached query results related to a model instance when its data changes.
+    
+    This function is intended to be used as a Django signal handler. It compares old and new values of relevant fields on a model instance against registered cache dependencies (filters and excludes). If a change affects any cached queryset result, the corresponding cache keys are invalidated and removed from the dependency index.
+    """
     manager_name = sender.__name__
     idx = get_full_index()
 
@@ -280,7 +288,7 @@ def generic_cache_invalidation(
                 if action == "filter":
                     # Filter: invalidate if new match or old match
                     if new_match or old_match:
-                        print(
+                        logger.info(
                             f"Invalidate cache key {cache_keys} for filter {lookup} with value {val_key}"
                         )
                         for ck in list(cache_keys):
@@ -290,7 +298,7 @@ def generic_cache_invalidation(
                 else:  # action == 'exclude'
                     # Excludes: invalidate only if matches changed
                     if old_match != new_match:
-                        print(
+                        logger.info(
                             f"Invalidate cache key {cache_keys} for exclude {lookup} with value {val_key}"
                         )
                         for ck in list(cache_keys):

{generalmanager-0.6.2 → generalmanager-0.7.0}/src/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],
@@ -55,7 +54,7 @@ class AttributeTypedDict(TypedDict):
 
 
 class InterfaceBase(ABC):
-    _parent_class: ClassVar[Type[Any]]
+    _parent_class: Type[GeneralManager]
     _interface_type: ClassVar[str]
     input_fields: dict[str, Input]
 
@@ -70,9 +69,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 +130,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 +217,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.
         """

{generalmanager-0.6.2 → generalmanager-0.7.0}/src/general_manager/interface/databaseBasedInterface.py

@@ -66,12 +66,18 @@ 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)
+    history = HistoricalRecords(inherit=True)
+
+    class Meta:
+        abstract = True
+
+
+class GeneralManagerModel(GeneralManagerBasisModel):
     changed_by = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.PROTECT)
     changed_by_id: int
-    history = HistoricalRecords(inherit=True)
 
     @property
     def _history_user(self) -> AbstractUser:
@@ -90,12 +96,12 @@ 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[GeneralManagerBasisModel]
     input_fields: dict[str, Input] = {"id": Input(int)}
 
     def __init__(
@@ -113,7 +119,7 @@ class DBBasedInterface(InterfaceBase):
         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 +183,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.
 
@@ -440,14 +446,23 @@ 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 based on the provided interface definition.
+        
+        This method extracts fields and meta information from the 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.
         """
@@ -474,7 +489,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

generalmanager-0.7.0/src/general_manager/interface/readOnlyInterface.py

@@ -0,0 +1,265 @@
+from __future__ import annotations
+import json
+
+from typing import Type, Any, Callable, TYPE_CHECKING
+from django.db import models, transaction
+from general_manager.interface.databaseBasedInterface import (
+    DBBasedInterface,
+    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
+
+
+logger = logging.getLogger(__name__)
+
+
+class ReadOnlyInterface(DBBasedInterface):
+    _interface_type = "readonly"
+    _model: Type[GeneralManagerBasisModel]
+    _parent_class: Type[GeneralManager]
+
+    @staticmethod
+    def getUniqueFields(model: Type[models.Model]) -> set[str]:
+        """
+        Return the set of field names that uniquely identify instances of the given Django model.
+        
+        Considers fields marked as unique (excluding "id"), unique_together constraints, and UniqueConstraint definitions.
+        """
+        opts = model._meta
+        unique_fields: set[str] = set()
+
+        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:
+        """
+        Synchronizes the associated Django model with the JSON data from the parent class, ensuring records match exactly.
+        
+        Parses the JSON data, creates or updates model instances based on unique fields, and marks as inactive 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 set '_data'"
+            )
+
+        # JSON-Daten parsen
+        if isinstance(json_data, str):
+            data_list = json.loads(json_data)
+        elif isinstance(json_data, list):
+            data_list: list[Any] = json_data
+        else:
+            raise ValueError("_data must be a JSON string or a list of dictionaries")
+
+        unique_fields = cls.getUniqueFields(model)
+        if not unique_fields:
+            raise ValueError(
+                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()
+
+            # 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, 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 or not instance.is_active:
+                    instance.is_active = True
+                    instance.save()
+                    changes["created" if is_created else "updated"].append(instance)
+
+            # 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.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 ensureSchemaIsUpToDate(
+        new_manager_class: Type[GeneralManager], model: Type[models.Model]
+    ) -> list[Warning]:
+        """
+        Checks whether the database schema for the given model matches the model definition.
+        
+        Parameters:
+            new_manager_class (Type[GeneralManager]): The manager class associated with the model.
+            model (Type[models.Model]): The Django model to check.
+        
+        Returns:
+            list[Warning]: A list of Django Warning objects describing schema issues, or an empty list if the schema is up to date.
+        """
+
+        def table_exists(table_name: str) -> bool:
+            """
+            Check if a database table with the given name exists.
+            
+            Parameters:
+                table_name (str): The 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]]:
+            """
+            Compare a Django model's fields to the columns of a database table.
+            
+            Returns:
+                missing (list[str]): Columns defined in the model but missing from the database table.
+                extra (list[str]): Columns 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)
+
+        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 executing the wrapped post-creation function, this decorator appends the newly created manager class to the `read_only_classes` list in the meta-class, marking it as a read-only interface.
+        """
+
+        def wrapper(
+            new_class: Type[GeneralManager],
+            interface_cls: Type[ReadOnlyInterface],
+            model: Type[GeneralManagerBasisModel],
+        ):
+            """
+            Registers the newly created class as a read-only class after invoking the wrapped post-creation function.
+            
+            Parameters:
+                new_class (Type[GeneralManager]): The newly created manager class to register.
+                interface_cls (Type[ReadOnlyInterface]): The associated read-only interface class.
+                model (Type[GeneralManagerModel]): The model class associated with the manager.
+            """
+            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 to ensure the base model class is set to ReadOnlyModel.
+        
+        Wraps a pre-creation function, injecting ReadOnlyModel as the base model class argument before the GeneralManager instance is created.
+        """
+        def wrapper(
+            name: generalManagerClassName,
+            attrs: attributes,
+            interface: interfaceBaseClass,
+            base_model_class=GeneralManagerBasisModel,
+        ):
+            return func(
+                name, attrs, interface, base_model_class=GeneralManagerBasisModel
+            )
+
+        return wrapper
+
+    @classmethod
+    def handleInterface(cls) -> tuple[classPreCreationMethod, classPostCreationMethod]:
+        """
+        Return the pre- and post-creation hook methods for integrating this interface with a GeneralManager.
+        
+        The returned tuple contains the pre-creation method, which injects the base model class, and the post-creation method, which registers the class as read-only. These hooks are intended for use by GeneralManagerMeta during the manager class lifecycle.
+        
+        Returns:
+            tuple: A pair of methods for pre- and post-creation processing.
+        """
+        return cls.readOnlyPreCreate(cls._preCreate), cls.readOnlyPostCreate(
+            cls._postCreate
+        )