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

general_manager/api/graphql.py

@@ -5,19 +5,19 @@ from decimal import Decimal
 from datetime import date, datetime
 import json
 
-# Eigene Module
 from general_manager.measurement.measurement import Measurement
 from general_manager.manager.generalManager import GeneralManagerMeta, GeneralManager
 from general_manager.api.property import GraphQLProperty
 from general_manager.bucket.baseBucket import Bucket
 from general_manager.interface.baseInterface import InterfaceBase
+from django.db.models import NOT_PROVIDED
 
 if TYPE_CHECKING:
     from general_manager.permission.basePermission import BasePermission
     from graphene import ResolveInfo as GraphQLResolveInfo
 
 
-class MeasurementType(graphene.ObjectType):  # type: ignore
+class MeasurementType(graphene.ObjectType):
     value = graphene.Float()
     unit = graphene.String()
 
@@ -102,11 +102,9 @@ class GraphQL:
     @classmethod
     def createGraphqlInterface(cls, generalManagerClass: GeneralManagerMeta) -> None:
         """
-        Erzeugt ein GraphQL-Interface für die übergebene Manager-Klasse.
-        Dabei werden:
-          - Attribute aus dem Interface in Graphene-Felder abgebildet
-          - Zu jedem Feld ein Resolver generiert und hinzugefügt
-          - Der neue Type in das Registry eingetragen und Queries angehängt.
+        Generates and registers a GraphQL ObjectType for the specified GeneralManager class.
+        
+        This method maps interface attributes and GraphQLProperty attributes to Graphene fields, creates corresponding resolvers, registers the resulting type in the internal registry, and attaches relevant query fields to the schema.
         """
         interface_cls: InterfaceBase | None = getattr(
             generalManagerClass, "Interface", None
@@ -117,14 +115,14 @@ class GraphQL:
         graphene_type_name = f"{generalManagerClass.__name__}Type"
         fields: dict[str, Any] = {}
 
-        # Felder aus dem Interface mappen
+        # Map Attribute Types to Graphene Fields
         for field_name, field_info in interface_cls.getAttributeTypes().items():
             field_type = field_info["type"]
             fields[field_name] = cls._mapFieldToGrapheneRead(field_type, field_name)
             resolver_name = f"resolve_{field_name}"
             fields[resolver_name] = cls._createResolver(field_name, field_type)
 
-        # Zusätzliche GraphQLPropertys verarbeiten
+        # handle GraphQLProperty attributes
         for attr_name, attr_value in generalManagerClass.__dict__.items():
             if isinstance(attr_value, GraphQLProperty):
                 type_hints = get_args(attr_value.graphql_type_hint)
@@ -350,10 +348,14 @@ class GraphQL:
         base_getter: Callable[[Any], Any], fallback_manager_class: type[GeneralManager]
     ) -> Callable[..., Any]:
         """
-        Erzeugt einen Resolver für List-Felder, der:
-          - Eine Basisabfrage (base_queryset) über den base_getter ermittelt
-          - Zuerst die permission-basierten Filter anwendet
-          - Anschließend Filter, Excludes, Sortierung und Paginierung übernimmt
+        Creates a resolver function for list fields that applies permission filters, query filters, sorting, pagination, and optional grouping to a queryset.
+        
+        Parameters:
+            base_getter (Callable): Function to obtain the base queryset from the parent instance.
+            fallback_manager_class (type[GeneralManager]): Manager class to use if the queryset does not specify one.
+        
+        Returns:
+            Callable: A resolver function for use in GraphQL list fields.
         """
 
         def resolver(
@@ -367,8 +369,23 @@ class GraphQL:
             page_size: int | None = None,
             group_by: list[str] | None = None,
         ) -> Any:
+            """
+            Resolves a list field by applying permission filters, query parameters, sorting, pagination, and optional grouping to a queryset.
+            
+            Parameters:
+                filter: Optional filter criteria as a dictionary or JSON string.
+                exclude: Optional exclusion criteria as a dictionary or JSON string.
+                sort_by: Optional sorting field as a Graphene Enum.
+                reverse: If True, reverses the sort order.
+                page: Optional page number for pagination.
+                page_size: Optional number of items per page.
+                group_by: Optional list of field names to group results by.
+            
+            Returns:
+                The filtered, sorted, paginated, and optionally grouped queryset.
+            """
             base_queryset = base_getter(self)
-            # Verwende _manager_class aus dem Attribut falls vorhanden, ansonsten das Fallback
+            # use _manager_class from the attribute if available, otherwise fallback
             manager_class = getattr(
                 base_queryset, "_manager_class", fallback_manager_class
             )
@@ -441,8 +458,9 @@ class GraphQL:
         cls, graphene_type: type, generalManagerClass: GeneralManagerMeta
     ) -> None:
         """
-        Fügt dem Schema Abfragen hinzu (Liste und Einzelobjekt) basierend auf der
-        GeneralManager-Klasse.
+        Adds list and single-item query fields for a GeneralManager-derived class to the GraphQL schema.
+        
+        This method registers both a list query (with filtering, sorting, pagination, and grouping) and a single-item query (using identification fields) for the specified manager class. The corresponding resolvers are also attached to the schema.
         """
         if not issubclass(generalManagerClass, GeneralManager):
             raise TypeError(
@@ -452,7 +470,7 @@ class GraphQL:
         if not hasattr(cls, "_query_fields"):
             cls._query_fields: dict[str, Any] = {}
 
-        # Resolver und Feld für die Listenabfrage
+        # resolver and field for the list query
         list_field_name = f"{generalManagerClass.__name__.lower()}_list"
         filter_options = cls._createFilterOptions(
             generalManagerClass.__name__.lower(), generalManagerClass
@@ -475,7 +493,7 @@ class GraphQL:
         cls._query_fields[list_field_name] = list_field
         cls._query_fields[f"resolve_{list_field_name}"] = list_resolver
 
-        # Resolver und Feld für die Einzelobjektabfrage
+        # resolver and field for the single item query
         item_field_name = generalManagerClass.__name__.lower()
         identification_fields = {}
         for (
@@ -505,11 +523,21 @@ class GraphQL:
 
     @classmethod
     def createWriteFields(cls, interface_cls: InterfaceBase) -> dict[str, Any]:
+        """
+        Generate a dictionary of Graphene input fields for mutations based on the attributes of the provided interface class.
+        
+        Skips fields that are system-managed (`changed_by`, `created_at`, `updated_at`) or marked as derived. For attributes referencing `GeneralManager` subclasses, uses ID fields; for list references, uses a list of IDs. All other types are mapped to their corresponding Graphene scalar types. Each field is annotated with an `editable` attribute indicating if it can be modified. Adds an optional `history_comment` field marked as editable.
+        
+        Returns:
+            dict[str, Any]: A dictionary mapping attribute names to Graphene input fields for use in mutation arguments.
+        """
         fields: dict[str, Any] = {}
 
         for name, info in interface_cls.getAttributeTypes().items():
             if name in ["changed_by", "created_at", "updated_at"]:
                 continue
+            if info["is_derived"]:
+                continue
 
             typ = info["type"]
             req = info["is_required"]
@@ -534,11 +562,11 @@ class GraphQL:
                     default_value=default,
                 )
 
-            # Markierung, damit Dein generate*-Code weiß, was editable ist
+            # mark for generate* code to know what is editable
             setattr(fld, "editable", info["is_editable"])
             fields[name] = fld
 
-        # history_comment bleibt optional ohne Default
+        # history_comment is always optional without a default value
         fields["history_comment"] = graphene.String()
         setattr(fields["history_comment"], "editable", True)
 
@@ -551,7 +579,12 @@ class GraphQL:
         default_return_values: dict[str, Any],
     ) -> type[graphene.Mutation] | None:
         """
-        Generiert eine Mutation-Klasse für die Erstellung eines Objekts.
+        Generates a Graphene mutation class for creating an instance of the specified GeneralManager subclass.
+        
+        The generated mutation class defines a `mutate` method that filters out fields with `NOT_PROVIDED` values, invokes the `create` method on the manager class with the provided arguments and the current user's ID, and returns a dictionary indicating success or failure along with any errors and the created instance.
+        
+        Returns:
+            The generated Graphene mutation class, or None if the manager class does not define an interface.
         """
         interface_cls: InterfaceBase | None = getattr(
             generalManagerClass, "Interface", None
@@ -563,26 +596,32 @@ class GraphQL:
             self,
             info: GraphQLResolveInfo,
             **kwargs: dict[str, Any],
-        ) -> GeneralManager:
+        ) -> dict:
+            """
+            Creates a new instance of the specified manager class using provided input arguments.
+            
+            Filters out fields with default "not provided" values before creation. Returns a dictionary indicating success status, any errors encountered, and the created instance under a key named after the manager class.
+            """
             try:
+                kwargs = {
+                    field_name: value
+                    for field_name, value in kwargs.items()
+                    if value is not NOT_PROVIDED
+                }
                 instance = generalManagerClass.create(
                     **kwargs, creator_id=info.context.user.id
                 )
             except Exception as e:
-                return self.__class__(
-                    **{
-                        "success": False,
-                        "errors": [str(e)],
-                        generalManagerClass.__name__: None,
-                    }
-                )
-            return self.__class__(
-                **{
-                    "success": True,
-                    "errors": [],
-                    generalManagerClass.__name__: instance,
+                return {
+                    "success": False,
+                    "errors": [str(e)],
                 }
-            )
+
+            return {
+                "success": True,
+                "errors": [],
+                generalManagerClass.__name__: instance,
+            }
 
         return type(
             f"Create{generalManagerClass.__name__}",
@@ -612,7 +651,12 @@ class GraphQL:
         default_return_values: dict[str, Any],
     ) -> type[graphene.Mutation] | None:
         """
-        Generiert eine Mutation-Klasse für die Aktualisierung eines Objekts.
+        Generates a GraphQL mutation class for updating an instance of a GeneralManager subclass.
+        
+        The generated mutation accepts editable fields as arguments, calls the `update` method on the manager instance, and returns a dictionary indicating success, errors, and the updated instance. If the manager class does not define an `Interface`, returns None.
+        
+        Returns:
+            The generated Graphene mutation class, or None if no interface is defined.
         """
         interface_cls: InterfaceBase | None = getattr(
             generalManagerClass, "Interface", None
@@ -624,27 +668,32 @@ class GraphQL:
             self,
             info: GraphQLResolveInfo,
             **kwargs: dict[str, Any],
-        ) -> GeneralManager:
+        ) -> dict:
+            """
+            Handles the update mutation for a GeneralManager instance, applying provided field updates and returning the operation result.
+            
+            Parameters:
+                info (GraphQLResolveInfo): GraphQL resolver context containing user and request information.
+                **kwargs: Fields to update, including the required 'id' of the instance.
+            
+            Returns:
+                dict: A dictionary containing the success status, any error messages, and the updated instance keyed by its class name.
+            """
             try:
                 manager_id = kwargs.pop("id", None)
                 instance = generalManagerClass(manager_id).update(
                     creator_id=info.context.user.id, **kwargs
                 )
             except Exception as e:
-                return self.__class__(
-                    **{
-                        "success": False,
-                        "errors": [str(e)],
-                        generalManagerClass.__name__: None,
-                    }
-                )
-            return self.__class__(
-                **{
-                    "success": True,
-                    "errors": [],
-                    generalManagerClass.__name__: instance,
+                return {
+                    "success": False,
+                    "errors": [str(e)],
                 }
-            )
+            return {
+                "success": True,
+                "errors": [],
+                generalManagerClass.__name__: instance,
+            }
 
         return type(
             f"Create{generalManagerClass.__name__}",
@@ -674,7 +723,9 @@ class GraphQL:
         default_return_values: dict[str, Any],
     ) -> type[graphene.Mutation] | None:
         """
-        Generiert eine Mutation-Klasse für die Löschung eines Objekts.
+        Generates a GraphQL mutation class for deleting (deactivating) an instance of a GeneralManager subclass.
+        
+        The generated mutation accepts input fields defined in the manager's interface, deactivates the specified instance, and returns a dictionary indicating success or failure, along with any errors and the deleted instance.
         """
         interface_cls: InterfaceBase | None = getattr(
             generalManagerClass, "Interface", None
@@ -686,27 +737,28 @@ class GraphQL:
             self,
             info: GraphQLResolveInfo,
             **kwargs: dict[str, Any],
-        ) -> GeneralManager:
+        ) -> dict:
+            """
+            Deletes (deactivates) an instance of the specified GeneralManager class and returns the operation result.
+            
+            Returns:
+                dict: A dictionary containing the success status, any error messages, and the deactivated instance under the class name key.
+            """
             try:
                 manager_id = kwargs.pop("id", None)
                 instance = generalManagerClass(manager_id).deactivate(
                     creator_id=info.context.user.id
                 )
             except Exception as e:
-                return self.__class__(
-                    **{
-                        "success": False,
-                        "errors": [str(e)],
-                        generalManagerClass.__name__: None,
-                    }
-                )
-            return self.__class__(
-                **{
-                    "success": True,
-                    "errors": [],
-                    generalManagerClass.__name__: instance,
+                return {
+                    "success": False,
+                    "errors": [str(e)],
                 }
-            )
+            return {
+                "success": True,
+                "errors": [],
+                generalManagerClass.__name__: instance,
+            }
 
         return type(
             f"Delete{generalManagerClass.__name__}",

general_manager/api/mutation.py

@@ -5,20 +5,21 @@ import graphene
 from general_manager.api.graphql import GraphQL
 from general_manager.manager.generalManager import GeneralManager
 
-
-def snake_to_pascal(s: str) -> str:
-    return "".join(p.title() for p in s.split("_"))
-
-
-def snake_to_camel(s: str) -> str:
-    parts = s.split("_")
-    return parts[0] + "".join(p.title() for p in parts[1:])
+from general_manager.auxiliary.formatString import snake_to_camel
 
 
 def graphQlMutation(needs_role: Optional[str] = None, auth_required: bool = False):
     """
-    Decorator to generate a graphene.Mutation from a function and register it.
-    :param auth_required: if True, enforces that info.context.user is authenticated.
+    Decorator that transforms a function into a GraphQL mutation class and registers it for use in a Graphene-based API.
+    
+    The decorated function must have type hints for all parameters (except `info`) and a return annotation. The decorator dynamically generates a mutation class with arguments and output fields based on the function's signature and return type. It also enforces authentication if `auth_required` is set to True, returning an error if the user is not authenticated.
+    
+    Parameters:
+        needs_role (Optional[str]): Reserved for future use to specify a required user role.
+        auth_required (bool): If True, the mutation requires an authenticated user.
+    
+    Returns:
+        Callable: A decorator that registers the mutation and returns the original function.
     """
 
     def decorator(fn):

general_manager/apps.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
 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 +11,16 @@ 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, Any, cast
+from django.core.checks import register
+import logging
+from django.core.management.base import BaseCommand
+
+
+if TYPE_CHECKING:
+    from general_manager.interface.readOnlyInterface import ReadOnlyInterface
+
+logger = logging.getLogger(__name__)
 
 
 class GeneralmanagerConfig(AppConfig):
@@ -16,7 +28,97 @@ class GeneralmanagerConfig(AppConfig):
     name = "general_manager"
 
     def ready(self):
+        """
+        Initializes the general_manager app on Django startup.
+        
+        Sets up read-only interface synchronization and schema validation, initializes general manager class attributes and interconnections, and configures the GraphQL schema and endpoint if enabled in settings.
+        """
+        self.handleReadOnlyInterface()
+        self.initializeGeneralManagerClasses()
+        if getattr(settings, "AUTOCREATE_GRAPHQL", False):
+            self.handleGraphQL()
+
+    def handleReadOnlyInterface(self):
+        """
+        Configures synchronization and schema validation for all registered read-only interfaces.
+        
+        This method ensures that read-only interfaces are synchronized before Django management commands execute and registers system checks to validate that each read-only interface's schema remains current.
+        """
+        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 = cast(
+                Type[ReadOnlyInterface], general_manager_class.Interface
+            )
+
+            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[Any, ReadOnlyInterface]]],
+    ):
+        """
+        Monkey-patches Django's management command runner to synchronize data for all provided read-only interfaces before executing management commands.
+        
+        For each general manager class, its associated read-only interface's `syncData` method is called prior to command execution, except during autoreload subprocesses of `runserver`.
+        """
+        from general_manager.interface.readOnlyInterface import ReadOnlyInterface
+
+        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
+            """
+            Executes a Django management command, synchronizing all registered read-only interfaces before execution unless running an autoreload subprocess of 'runserver'.
+            
+            Parameters:
+                argv (list): Command-line arguments for the management command.
+            
+            Returns:
+                The result of the original management command execution.
+            """
+            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 = cast(
+                        Type[ReadOnlyInterface], general_manager_class.Interface
+                    )
+                    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 sets up dynamic relationships for all registered GeneralManager classes.
+        
+        For each pending GeneralManager class, assigns its interface attributes and creates property accessors. Then, for all GeneralManager classes, dynamically connects input fields that reference other GeneralManager subclasses by 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 +137,39 @@ 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 appends a GraphQL endpoint to the Django URL configuration using the given schema.
+        
+        Raises:
+            Exception: If the ROOT_URLCONF setting is not defined in Django settings.
+        """
+        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/auxiliary/formatString.py

@@ -0,0 +1,60 @@
+def snake_to_pascal(s: str) -> str:
+    """
+    Convert a snake_case string to PascalCase.
+
+    Parameters:
+        s (str): The input string in snake_case format.
+
+    Returns:
+        str: The converted string in PascalCase format.
+    """
+    return "".join(p.title() for p in s.split("_"))
+
+
+def snake_to_camel(s: str) -> str:
+    """
+    Convert a snake_case string to camelCase.
+
+    Parameters:
+        s (str): The snake_case string to convert.
+
+    Returns:
+        str: The input string converted to camelCase.
+    """
+    parts = s.split("_")
+    return parts[0] + "".join(p.title() for p in parts[1:])
+
+
+def pascal_to_snake(s: str) -> str:
+    """
+    Convert a PascalCase string to snake_case.
+
+    Parameters:
+        s (str): The PascalCase string to convert.
+
+    Returns:
+        str: The converted snake_case string.
+    """
+    return "".join(["_" + c.lower() if c.isupper() else c for c in s]).lstrip("_")
+
+
+def camel_to_snake(s: str) -> str:
+    """
+    Convert a camelCase string to snake_case.
+
+    Parameters:
+        s (str): The camelCase string to convert.
+
+    Returns:
+        str: The converted snake_case string. Returns an empty string if the input is empty.
+    """
+    if not s:
+        return ""
+    parts = [s[0].lower()]
+    for c in s[1:]:
+        if c.isupper():
+            parts.append("_")
+            parts.append(c.lower())
+        else:
+            parts.append(c)
+    return "".join(parts)

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