GeneralManager 0.6.1__tar.gz → 0.7.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.6.1
+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.1 → generalmanager-0.7.0}/GeneralManager.egg-info/SOURCES.txt

@@ -65,6 +65,7 @@ tests/test_calculationBucket.py
 tests/test_calculationInterface.py
 tests/test_databaseBasedInterface.py
 tests/test_databaseBucket.py
+tests/test_databaseInterface.py
 tests/test_dependencyIndex.py
 tests/test_factories.py
 tests/test_factoryMethods.py
@@ -81,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.1 → generalmanager-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.6.1
+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.1 → generalmanager-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.6.1"
+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.1 → 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.1 → 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.1 → 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.6.1 → generalmanager-0.7.0}/src/general_manager/interface/databaseInterface.py

@@ -18,36 +18,24 @@ class DatabaseInterface(DBBasedInterface):
     def create(
         cls, creator_id: int, history_comment: str | None = None, **kwargs: Any
     ) -> int:
-        from general_manager.manager.generalManager import GeneralManager
 
-        cls.__checkForInvalidKwargs(cls._model, kwargs=kwargs)
-        kwargs, many_to_many_kwargs = cls.__sortKwargs(cls._model, kwargs)
-        instance = cls._model()
-        for key, value in kwargs.items():
-            if isinstance(value, GeneralManager):
-                value = value.identification["id"]
-                key = f"{key}_id"
-            setattr(instance, key, value)
-        for key, value in many_to_many_kwargs.items():
-            getattr(instance, key).set(value)
-        return cls.__save_with_history(instance, creator_id, history_comment)
+        cls._checkForInvalidKwargs(cls._model, kwargs=kwargs)
+        kwargs, many_to_many_kwargs = cls._sortKwargs(cls._model, kwargs)
+        instance = cls.__setAttrForWrite(cls._model(), kwargs)
+        pk = cls._save_with_history(instance, creator_id, history_comment)
+        cls.__setManyToManyAttributes(instance, many_to_many_kwargs)
+        return pk
 
     def update(
         self, creator_id: int, history_comment: str | None = None, **kwargs: Any
     ) -> int:
-        from general_manager.manager.generalManager import GeneralManager
 
-        self.__checkForInvalidKwargs(self._model, kwargs=kwargs)
-        kwargs, many_to_many_kwargs = self.__sortKwargs(self._model, kwargs)
-        instance = self._model.objects.get(pk=self.pk)
-        for key, value in kwargs.items():
-            if isinstance(value, GeneralManager):
-                value = value.identification["id"]
-                key = f"{key}_id"
-            setattr(instance, key, value)
-        for key, value in many_to_many_kwargs.items():
-            getattr(instance, key).set(value)
-        return self.__save_with_history(instance, creator_id, history_comment)
+        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)
+        pk = self._save_with_history(instance, creator_id, history_comment)
+        self.__setManyToManyAttributes(instance, many_to_many_kwargs)
+        return pk
 
     def deactivate(self, creator_id: int, history_comment: str | None = None) -> int:
         instance = self._model.objects.get(pk=self.pk)
@@ -56,32 +44,68 @@ class DatabaseInterface(DBBasedInterface):
             history_comment = f"{history_comment} (deactivated)"
         else:
             history_comment = "Deactivated"
-        return self.__save_with_history(instance, creator_id, history_comment)
+        return self._save_with_history(instance, creator_id, history_comment)
 
     @staticmethod
-    def __checkForInvalidKwargs(model: Type[models.Model], kwargs: dict[Any, Any]):
+    def __setManyToManyAttributes(
+        instance: GeneralManagerModel, many_to_many_kwargs: dict[str, list[Any]]
+    ) -> GeneralManagerModel:
+        """
+        Sets many-to-many attributes for the given instance based on the provided kwargs.
+
+        Args:
+            instance: The model instance to update.
+            many_to_many_kwargs: A dictionary containing many-to-many field names and their corresponding values.
+
+        Returns:
+            The updated model instance.
+        """
+        for key, value in many_to_many_kwargs.items():
+            if not value:
+                continue
+            field_name = key.split("_id_list")[0]
+            getattr(instance, field_name).set(value)
+
+        return instance
+
+    @staticmethod
+    def __setAttrForWrite(
+        instance: GeneralManagerModel,
+        kwargs: dict[str, Any],
+    ) -> GeneralManagerModel:
+        from general_manager.manager.generalManager import GeneralManager
+
+        for key, value in kwargs.items():
+            if isinstance(value, GeneralManager):
+                value = value.identification["id"]
+                key = f"{key}_id"
+            setattr(instance, key, value)
+        return instance
+
+    @staticmethod
+    def _checkForInvalidKwargs(model: Type[models.Model], kwargs: dict[str, Any]):
         attributes = vars(model)
-        fields = model._meta.get_fields()
+        field_names = {f.name for f in model._meta.get_fields()}
         for key in kwargs:
-            if key not in attributes and key not in fields:
+            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__}")
 
     @staticmethod
-    def __sortKwargs(
+    def _sortKwargs(
         model: Type[models.Model], kwargs: dict[Any, Any]
     ) -> tuple[dict[str, Any], dict[str, list[Any]]]:
-        many_to_many_fields = model._meta.many_to_many
+        many_to_many_fields = [field.name for field in model._meta.many_to_many]
         many_to_many_kwargs: dict[Any, Any] = {}
-        for key, value in kwargs.items():
+        for key, value in list(kwargs.items()):
             many_to_many_key = key.split("_id_list")[0]
             if many_to_many_key in many_to_many_fields:
-                many_to_many_kwargs[key] = value
-                kwargs.pop(key)
+                many_to_many_kwargs[key] = kwargs.pop(key)
         return kwargs, many_to_many_kwargs
 
     @classmethod
     @transaction.atomic
-    def __save_with_history(
+    def _save_with_history(
         cls, instance: GeneralManagerModel, creator_id: int, history_comment: str | None
     ) -> int:
         """