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

general_manager/apps.py

@@ -1,5 +1,6 @@
 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
@@ -9,6 +10,15 @@ 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):
@@ -16,7 +26,87 @@ class GeneralmanagerConfig(AppConfig):
     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():
@@ -35,41 +125,38 @@ class GeneralmanagerConfig(AppConfig):
                         graphQlProperty(func),
                     )
 
-        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
-            )
-
-        if getattr(settings, "AUTOCREATE_GRAPHQL", False):
-
-            for general_manager_class in GeneralManagerMeta.pending_graphql_interfaces:
-                GraphQL.createGraphqlInterface(general_manager_class)
-                GraphQL.createGraphqlMutation(general_manager_class)
+    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
+        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
+        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.add_graphql_url(schema)
+        schema = graphene.Schema(
+            query=GraphQL._query_class,
+            mutation=GraphQL._mutation_class,
+        )
+        self.addGraphqlUrl(schema)
 
-    def add_graphql_url(self, 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:

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):

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.
         """

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

general_manager/interface/readOnlyInterface.py

@@ -5,34 +5,74 @@ 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
+
+
+logger = logging.getLogger(__name__)
 
 
 class ReadOnlyInterface(DBBasedInterface):
     _interface_type = "readonly"
+    _model: Type[GeneralManagerBasisModel]
+    _parent_class: Type[GeneralManager]
 
-    @classmethod
-    def sync_data(cls) -> None:
+    @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.
         """
-        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 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 be set '_json_data'"
+                f"For ReadOnlyInterface '{parent_class.__name__}' must set '_data'"
             )
 
         # JSON-Daten parsen
@@ -41,67 +81,185 @@ 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]:
+        """
+        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.
         """
-        Decorator for post-creation hooks that registers the interface class as read-only.
 
-        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.
+        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(
-            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 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]:
         """
-        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 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._preCreate, cls.readOnlyPostCreate(cls._postCreate)
+        return cls.readOnlyPreCreate(cls._preCreate), cls.readOnlyPostCreate(
+            cls._postCreate
+        )

general_manager/manager/meta.py

@@ -18,7 +18,7 @@ class _nonExistent:
 
 class GeneralManagerMeta(type):
     all_classes: list[Type[GeneralManager]] = []
-    read_only_classes: list[Type[ReadOnlyInterface]] = []
+    read_only_classes: list[Type[GeneralManager]] = []
     pending_graphql_interfaces: list[Type[GeneralManager]] = []
     pending_attribute_initialization: list[Type[GeneralManager]] = []
     Interface: type[InterfaceBase]

{generalmanager-0.6.2.dist-info → generalmanager-0.7.0.dist-info}/METADATA

@@ -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.dist-info → generalmanager-0.7.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 general_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-general_manager/apps.py,sha256=0QwuIAnhHm5u0wTlCiDVsl8k0RU0BEgfFjmBMl9zvsw,3320
+general_manager/apps.py,sha256=sfH8a1iaAdTjTmmf7R9TZfZl_8yrce7zlsKGB1mFSQY,7935
 general_manager/api/graphql.py,sha256=a_mH5dvM3yXC1WyQKFCYpzSE00DQFLNKhRsZrwvLrNM,27453
 general_manager/api/mutation.py,sha256=uu5RVxc9wbb-Zrbtt4azegvyKymMqEsxk_CkerKCd9Q,5178
 general_manager/api/property.py,sha256=oc93p1P8dcIvrNorRuqD1EJVsd6eYttYhZuAS0s28gs,696
@@ -16,7 +16,7 @@ general_manager/bucket/databaseBucket.py,sha256=V_xiPa8ErnPHVh_-i-oaH8qCa818UJxm
 general_manager/bucket/groupBucket.py,sha256=55QdUaH_qO1JFJ2Jc1f2WcxniiLE5LB3vNwbnksKk8A,10939
 general_manager/cache/cacheDecorator.py,sha256=DK2ANIJgPpMxazfMSiFrI9OuVE_7K9zlIZQRrgaC2Lw,3268
 general_manager/cache/cacheTracker.py,sha256=rRw3OhBDf86hTC2Xbt1ocRgZqwu8_kXk4lczamcADFg,2955
-general_manager/cache/dependencyIndex.py,sha256=kEbIAzzMzKlQgplKfcMYBPZ562zCBkOBKvJusxO_iC4,10537
+general_manager/cache/dependencyIndex.py,sha256=lxD7IfnWVsBNt9l0_yDfJlHDRHAFC7N7p-Typ2tJp88,11044
 general_manager/cache/modelDependencyCollector.py,sha256=lIqBvo0QygoxxZPJ32_vMs_-eJaVJDznGyrEmxPV41E,2436
 general_manager/cache/signals.py,sha256=ZHeXKFMN7tj9t0J-vSqf_05_NhGqEF2sZtbZO3vaRqI,1234
 general_manager/factory/__init__.py,sha256=wbPIGyBlWBHa7aGWUd-1IUMPWUS-M6YqtPUL1iKXW8U,93
@@ -24,16 +24,16 @@ general_manager/factory/autoFactory.py,sha256=WBhSuMVsxkPAPLhlZhYXwHVIqiomUveS7v
 general_manager/factory/factories.py,sha256=F6_nYFyJRYYc3LQApfoVFdctfLzsWUDHKafn6xjckB8,7224
 general_manager/factory/factoryMethods.py,sha256=9Bag891j0XHe3dUBAFi7gUKcKeUwcBZN3cDLBobyBiI,3225
 general_manager/interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-general_manager/interface/baseInterface.py,sha256=b7MH-jVADcpGluvJMogPn2O3Yiy37uCnWOM9j0Ec0o0,8692
+general_manager/interface/baseInterface.py,sha256=WjavtLW_vzyv3PDIIGpw0cydFXjIBJfzxflMXDNF7ac,8583
 general_manager/interface/calculationInterface.py,sha256=Kg_OqLw67tcLwdzYNLq31eKVLzkM7taw-8Mzmk0CYi0,4232
-general_manager/interface/databaseBasedInterface.py,sha256=K2PYxANuLQU8wzrajcl922tuWwko642KJAS3f3PnAmg,21566
+general_manager/interface/databaseBasedInterface.py,sha256=NoHJp1A9kWRa5R8aal3MS--4PRsHY4JMBzpcuNd69kY,22182
 general_manager/interface/databaseInterface.py,sha256=08dFgxoLQNa13RK2NQ4cDNbNPIG-X9ChLs3NvJcSp6Y,4923
-general_manager/interface/readOnlyInterface.py,sha256=d2CM2gj5XZNEaVFZeNCgqZf46rwUAetVS3SyePCKNsY,4691
+general_manager/interface/readOnlyInterface.py,sha256=USr4k6Jr1gz91Cdi8bbZY59cTy5MPGZ3oC40xCdWS88,10873
 general_manager/manager/__init__.py,sha256=l3RYp62aEhj3Y975_XUTIzo35LUnkTJHkb_hgChnXXI,111
 general_manager/manager/generalManager.py,sha256=HX69KhrnSGVkuJwHY_jzff5gS0VD-6fRxKnd59A5Ct4,6100
 general_manager/manager/groupManager.py,sha256=8dpZUfm7aFL4lraUWv4qbbDRClQZaYxw4prclhBZYZs,4367
 general_manager/manager/input.py,sha256=iKawV3P1QICz-0AQUF00OvH7LZYxussg3svpvCUl8hE,2977
-general_manager/manager/meta.py,sha256=g94L92hDy5gdGhgaTu3pjgZtt_fLC8LruNj9T34ApdA,4414
+general_manager/manager/meta.py,sha256=I4HO7Tp2P0-eRKicVzZRFrYzyMshjWY2ZGP8no9Su-Y,4411
 general_manager/measurement/__init__.py,sha256=X97meFujBldE5v0WMF7SmKeGpC5R0JTczfLo_Lq1Xek,84
 general_manager/measurement/measurement.py,sha256=e_FjHieeJbBtjXGCO9J7vRPw6KCkMrOxwWjaD0m8ee4,11777
 general_manager/measurement/measurementField.py,sha256=iq9Hqe6ZGX8CxXm4nIqTAWTRkQVptzpqE9ExX-jFyNs,5928
@@ -46,8 +46,8 @@ general_manager/permission/permissionDataManager.py,sha256=Ji7fsnuaKTa6M8yzCGyzr
 general_manager/rule/__init__.py,sha256=4Har5cfPD1fmOsilTDod-ZUz3Com-tkl58jz7yY4fD0,23
 general_manager/rule/handler.py,sha256=z8SFHTIZ0LbLh3fV56Mud0V4_OvWkqJjlHvFqau7Qfk,7334
 general_manager/rule/rule.py,sha256=3FVCKGL7BTVoStdgOTdWQwuoVRIxAIAilV4VOzouDpc,10759
-generalmanager-0.6.2.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
-generalmanager-0.6.2.dist-info/METADATA,sha256=LpZhar2vKhlCPwavT15s1yWSeMCHH6M9rqtC69BjraQ,6205
-generalmanager-0.6.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-generalmanager-0.6.2.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
-generalmanager-0.6.2.dist-info/RECORD,,
+generalmanager-0.7.0.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
+generalmanager-0.7.0.dist-info/METADATA,sha256=S1_khOXyPT4HXYuMLADTSI3pAHiI0bV_WRPzWUFRTCc,6205
+generalmanager-0.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+generalmanager-0.7.0.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
+generalmanager-0.7.0.dist-info/RECORD,,