GeneralManager 0.7.0__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,3 +1,4 @@
+from __future__ import annotations
 from django.apps import AppConfig
 import graphene
 import os
@@ -10,9 +11,10 @@ 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 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:
@@ -27,9 +29,9 @@ class GeneralmanagerConfig(AppConfig):
 
     def ready(self):
         """
-        Initializes the general_manager app when Django starts.
+        Initializes the general_manager app on Django startup.
         
-        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.
+        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()
@@ -38,16 +40,18 @@ class GeneralmanagerConfig(AppConfig):
 
     def handleReadOnlyInterface(self):
         """
-        Sets up synchronization and schema validation for all registered read-only interfaces.
+        Configures 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.
+        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: ReadOnlyInterface = general_manager_class.Interface  # type: ignore
+            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(
@@ -57,29 +61,37 @@ class GeneralmanagerConfig(AppConfig):
             )
 
     @staticmethod
-    def patchReadOnlyInterfaceSync(general_manager_classes: list[Type[GeneralManager]]):
+    def patchReadOnlyInterfaceSync(
+        general_manager_classes: list[Type[GeneralManager[Any, ReadOnlyInterface]]],
+    ):
         """
-        Monkey-patches Django's management command runner to synchronize read-only interface data before executing commands.
+        Monkey-patches Django's management command runner to synchronize data for all provided read-only interfaces before executing management 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`.
+        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 django.core.management.base import BaseCommand
+        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
             """
-            Runs the management command and synchronizes read-only interface data before execution when appropriate.
+            Executes a Django management command, synchronizing all registered read-only interfaces before execution unless running an autoreload subprocess of 'runserver'.
             
-            Synchronization occurs for all registered read-only interfaces unless the command is 'runserver' in an autoreload subprocess.
+            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: ReadOnlyInterface = general_manager_class.Interface  # type: ignore
+                    read_only_interface = cast(
+                        Type[ReadOnlyInterface], general_manager_class.Interface
+                    )
                     read_only_interface.syncData()
 
                 logger.debug("finished syncing ReadOnlyInterface data.")
@@ -90,9 +102,9 @@ class GeneralmanagerConfig(AppConfig):
 
     def initializeGeneralManagerClasses(self):
         """
-        Initializes attributes and interconnections for all GeneralManager classes.
+        Initializes attributes and sets up dynamic relationships for all registered 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.
+        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...")
 
@@ -152,9 +164,10 @@ class GeneralmanagerConfig(AppConfig):
 
     def addGraphqlUrl(self, schema):
         """
-        Dynamically adds a GraphQL endpoint to the Django URL configuration using the provided schema.
+        Dynamically appends a GraphQL endpoint to the Django URL configuration using the given schema.
         
-        Raises an exception if the ROOT_URLCONF setting is not defined.
+        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)

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/interface/baseInterface.py

@@ -51,6 +51,7 @@ class AttributeTypedDict(TypedDict):
     default: Any
     is_required: bool
     is_editable: bool
+    is_derived: bool
 
 
 class InterfaceBase(ABC):

general_manager/interface/databaseBasedInterface.py

@@ -1,12 +1,5 @@
 from __future__ import annotations
-from typing import (
-    Type,
-    ClassVar,
-    Any,
-    Callable,
-    TYPE_CHECKING,
-    TypeVar,
-)
+from typing import Type, ClassVar, Any, Callable, TYPE_CHECKING, TypeVar, Generic
 from django.db import models
 from django.conf import settings
 from datetime import datetime, timedelta
@@ -76,13 +69,18 @@ class GeneralManagerBasisModel(models.Model):
 
 
 class GeneralManagerModel(GeneralManagerBasisModel):
-    changed_by = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.PROTECT)
-    changed_by_id: int
+    changed_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL, on_delete=models.PROTECT, null=True, blank=True
+    )
+    changed_by_id: int | None
 
     @property
-    def _history_user(self) -> AbstractUser:
+    def _history_user(self) -> AbstractUser | None:
         """
-        Returns the user who last modified this model instance.
+        Gets the user who last modified this model instance, or None if not set.
+        
+        Returns:
+            AbstractUser | None: The user who last changed the instance, or None if unavailable.
         """
         return self.changed_by
 
@@ -100,8 +98,11 @@ class GeneralManagerModel(GeneralManagerBasisModel):
         abstract = True
 
 
-class DBBasedInterface(InterfaceBase):
-    _model: Type[GeneralManagerBasisModel]
+MODEL_TYPE = TypeVar("MODEL_TYPE", bound=GeneralManagerBasisModel)
+
+
+class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
+    _model: Type[MODEL_TYPE]
     input_fields: dict[str, Input] = {"id": Input(int)}
 
     def __init__(
@@ -111,9 +112,9 @@ class DBBasedInterface(InterfaceBase):
         **kwargs: dict[str, Any],
     ):
         """
-        Initializes the interface instance and loads the corresponding model record.
-
-        If a `search_date` is provided, retrieves the historical record as of that date; otherwise, loads the current record.
+        Initialize the interface instance and load the associated model record.
+        
+        If `search_date` is provided, retrieves the historical record as of that date; otherwise, loads the current record.
         """
         super().__init__(*args, **kwargs)
         self.pk = self.identification["id"]
@@ -200,9 +201,12 @@ class DBBasedInterface(InterfaceBase):
     @classmethod
     def getAttributeTypes(cls) -> dict[str, AttributeTypedDict]:
         """
-        Returns a dictionary mapping attribute names to their type information and metadata.
-
-        The returned dictionary includes all model fields, custom fields, foreign keys, many-to-many, and reverse relation fields. Each entry provides the Python type (translated from Django field types when possible), whether the field is required, editable, and its default value. For related models that have a general manager class, the type is set to that class.
+        Return a dictionary mapping attribute names to metadata describing their type and properties.
+        
+        The returned dictionary includes all model fields, custom fields, foreign keys, many-to-many, and reverse relation fields. For each attribute, the metadata includes its Python type (translated from Django field types when possible), whether it is required, editable, derived, and its default value. For related models with a general manager class, the type is set to that class.
+         
+        Returns:
+            dict[str, AttributeTypedDict]: Mapping of attribute names to their type information and metadata.
         """
         TRANSLATION: dict[Type[models.Field[Any, Any]], type] = {
             models.fields.BigAutoField: int,
@@ -228,6 +232,7 @@ class DBBasedInterface(InterfaceBase):
             field: models.Field = getattr(cls._model, field_name)
             fields[field_name] = {
                 "type": type(field),
+                "is_derived": False,
                 "is_required": not field.null,
                 "is_editable": field.editable,
                 "default": field.default,
@@ -238,6 +243,7 @@ class DBBasedInterface(InterfaceBase):
                 field: models.Field = getattr(cls._model, field_name).field
                 fields[field_name] = {
                     "type": type(field),
+                    "is_derived": False,
                     "is_required": not field.null,
                     "is_editable": field.editable,
                     "default": field.default,
@@ -255,6 +261,7 @@ class DBBasedInterface(InterfaceBase):
             elif related_model is not None:
                 fields[field_name] = {
                     "type": related_model,
+                    "is_derived": False,
                     "is_required": not field.null,
                     "is_editable": field.editable,
                     "default": field.default,
@@ -280,6 +287,7 @@ class DBBasedInterface(InterfaceBase):
                 fields[f"{field_name}_list"] = {
                     "type": related_model,
                     "is_required": False,
+                    "is_derived": not bool(field.many_to_many),
                     "is_editable": bool(field.many_to_many and field.editable),
                     "default": None,
                 }
@@ -453,9 +461,9 @@ class DBBasedInterface(InterfaceBase):
     ) -> tuple[attributes, interfaceBaseClass, relatedClass]:
         # Felder aus der Interface-Klasse sammeln
         """
-        Dynamically creates a Django model class, its associated interface class, and a factory class based on the provided interface definition.
+        Dynamically creates a Django model class, its associated interface class, and a factory class from an interface definition.
         
-        This method extracts fields and meta information from the 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.
+        This method extracts fields and meta information from the provided interface class, constructs a new Django model inheriting from the specified base model class, attaches custom validation rules if present, and generates corresponding interface and factory classes. The resulting classes are returned for integration into the general manager framework.
         
         Parameters:
             name: The name for the dynamically created model class.
@@ -464,7 +472,7 @@ class DBBasedInterface(InterfaceBase):
             base_model_class: The base class to use for the new model (defaults to GeneralManagerModel).
         
         Returns:
-            A tuple containing the updated attributes dictionary, the new interface class, and the newly created model class.
+            tuple: A tuple containing the updated attributes dictionary, the new interface class, and the newly created model class.
         """
         model_fields: dict[str, Any] = {}
         meta_class = None

general_manager/interface/databaseInterface.py

@@ -11,14 +11,25 @@ from general_manager.interface.databaseBasedInterface import (
 )
 
 
-class DatabaseInterface(DBBasedInterface):
+class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
     _interface_type = "database"
 
     @classmethod
     def create(
-        cls, creator_id: int, history_comment: str | None = None, **kwargs: Any
+        cls, creator_id: int | None, history_comment: str | None = None, **kwargs: Any
     ) -> int:
+        """
+        Create a new model instance with the provided attributes and optional history tracking.
+
+        Validates input attributes, separates and sets many-to-many relationships, saves the instance with optional creator and history comment, and returns the primary key of the created instance.
+
+        Parameters:
+            creator_id (int | None): The ID of the user creating the instance, or None if not applicable.
+            history_comment (str | None): Optional comment to record in the instance's history.
 
+        Returns:
+            int: The primary key of the newly created instance.
+        """
         cls._checkForInvalidKwargs(cls._model, kwargs=kwargs)
         kwargs, many_to_many_kwargs = cls._sortKwargs(cls._model, kwargs)
         instance = cls.__setAttrForWrite(cls._model(), kwargs)
@@ -27,9 +38,18 @@ class DatabaseInterface(DBBasedInterface):
         return pk
 
     def update(
-        self, creator_id: int, history_comment: str | None = None, **kwargs: Any
+        self, creator_id: int | None, history_comment: str | None = None, **kwargs: Any
     ) -> int:
+        """
+        Update the current model instance with new attribute values and many-to-many relationships, saving changes with optional history tracking.
+
+        Parameters:
+            creator_id (int | None): The ID of the user making the update, or None if not specified.
+            history_comment (str | None): An optional comment describing the reason for the update.
 
+        Returns:
+            int: The primary key of the updated instance.
+        """
         self._checkForInvalidKwargs(self._model, kwargs=kwargs)
         kwargs, many_to_many_kwargs = self._sortKwargs(self._model, kwargs)
         instance = self.__setAttrForWrite(self._model.objects.get(pk=self.pk), kwargs)
@@ -37,7 +57,19 @@ class DatabaseInterface(DBBasedInterface):
         self.__setManyToManyAttributes(instance, many_to_many_kwargs)
         return pk
 
-    def deactivate(self, creator_id: int, history_comment: str | None = None) -> int:
+    def deactivate(
+        self, creator_id: int | None, history_comment: str | None = None
+    ) -> int:
+        """
+        Deactivate the current model instance by setting its `is_active` flag to `False` and recording the change with an optional history comment.
+
+        Parameters:
+            creator_id (int | None): The ID of the user performing the deactivation, or None if not specified.
+            history_comment (str | None): An optional comment to include in the instance's history log.
+
+        Returns:
+            int: The primary key of the deactivated instance.
+        """
         instance = self._model.objects.get(pk=self.pk)
         instance.is_active = False
         if history_comment:
@@ -89,7 +121,7 @@ class DatabaseInterface(DBBasedInterface):
         for key in kwargs:
             temp_key = key.split("_id_list")[0]  # Remove '_id_list' suffix
             if temp_key not in attributes and temp_key not in field_names:
-                raise ValueError(f"{key} does not exsist in {model.__name__}")
+                raise ValueError(f"{key} does not exist in {model.__name__}")
 
     @staticmethod
     def _sortKwargs(
@@ -106,17 +138,15 @@ class DatabaseInterface(DBBasedInterface):
     @classmethod
     @transaction.atomic
     def _save_with_history(
-        cls, instance: GeneralManagerModel, creator_id: int, history_comment: str | None
+        cls,
+        instance: GeneralManagerModel,
+        creator_id: int | None,
+        history_comment: str | None,
     ) -> int:
         """
-        Saves a model instance with validation and optional history tracking.
+        Atomically saves a model instance with validation and optional history comment.
 
-        Sets the `changed_by_id` field, validates the instance, applies a history comment if provided, and saves the instance within an atomic transaction.
-
-        Args:
-            instance: The model instance to save.
-            creator_id: The ID of the user making the change.
-            history_comment: Optional comment describing the reason for the change.
+        Sets the `changed_by_id` field, validates the instance, applies a history comment if provided, and saves the instance within a database transaction.
 
         Returns:
             The primary key of the saved instance.

general_manager/interface/readOnlyInterface.py

@@ -24,17 +24,16 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-class ReadOnlyInterface(DBBasedInterface):
+class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
     _interface_type = "readonly"
-    _model: Type[GeneralManagerBasisModel]
     _parent_class: Type[GeneralManager]
 
     @staticmethod
     def getUniqueFields(model: Type[models.Model]) -> set[str]:
         """
-        Return the set of field names that uniquely identify instances of the given Django model.
+        Return a set of field names that uniquely identify instances of the specified Django model.
         
-        Considers fields marked as unique (excluding "id"), unique_together constraints, and UniqueConstraint definitions.
+        Considers fields marked as unique (excluding "id"), as well as fields defined in `unique_together` and `UniqueConstraint` constraints.
         """
         opts = model._meta
         unique_fields: set[str] = set()
@@ -57,9 +56,9 @@ class ReadOnlyInterface(DBBasedInterface):
     @classmethod
     def syncData(cls) -> None:
         """
-        Synchronizes the associated Django model with the JSON data from the parent class, ensuring records match exactly.
+        Synchronizes the associated Django model with JSON data from the parent class, ensuring the database records match the provided data exactly.
         
-        Parses the JSON data, creates or updates model instances based on unique fields, and 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.
+        Parses the JSON data, creates or updates model instances based on unique fields, and deactivates any database records not present in the JSON data. Raises a ValueError if required attributes are missing, if the JSON data is invalid, or if no unique fields are defined.
         """
         if cls.ensureSchemaIsUpToDate(cls._parent_class, cls._model):
             logger.warning(
@@ -138,22 +137,18 @@ class ReadOnlyInterface(DBBasedInterface):
         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.
+        Check if the database schema for a Django model matches its model definition.
         
         Returns:
-            list[Warning]: A list of Django Warning objects describing schema issues, or an empty list if the schema is up to date.
+            A list of Django Warning objects describing schema issues, such as missing tables or column mismatches. Returns an empty list if the schema is up to date.
         """
 
         def table_exists(table_name: str) -> bool:
             """
-            Check if a database table with the given name exists.
+            Determine whether a database table with the specified name exists.
             
             Parameters:
-                table_name (str): The name of the database table to check.
+                table_name (str): Name of the database table to check.
             
             Returns:
                 bool: True if the table exists, False otherwise.
@@ -166,11 +161,12 @@ class ReadOnlyInterface(DBBasedInterface):
             model: Type[models.Model], table: str
         ) -> tuple[list[str], list[str]]:
             """
-            Compare a Django model's fields to the columns of a database table.
+            Compares the fields of a Django model to the columns of a specified 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.
+                A tuple containing two lists:
+                    - The first list contains column names defined in the model but missing from the database table.
+                    - The second list contains column names present in the database table but not defined in the model.
             """
             with connection.cursor() as cursor:
                 desc = connection.introspection.get_table_description(cursor, table)
@@ -208,7 +204,7 @@ class ReadOnlyInterface(DBBasedInterface):
         """
         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.
+        After the wrapped post-creation function is executed, the newly created manager class is added to the meta-class's list of read-only classes, marking it as a read-only interface.
         """
 
         def wrapper(
@@ -217,12 +213,9 @@ class ReadOnlyInterface(DBBasedInterface):
             model: Type[GeneralManagerBasisModel],
         ):
             """
-            Registers the newly created class as a read-only class after invoking the wrapped post-creation function.
+            Registers a newly created manager class as read-only after executing 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.
+            This function appends the new manager class to the list of read-only classes in the meta system, ensuring it is recognized as a read-only interface.
             """
             from general_manager.manager.meta import GeneralManagerMeta
 
@@ -234,16 +227,28 @@ class ReadOnlyInterface(DBBasedInterface):
     @staticmethod
     def readOnlyPreCreate(func: Callable[..., Any]) -> Callable[..., Any]:
         """
-        Decorator for pre-creation hook functions to ensure the base model class is set to ReadOnlyModel.
+        Decorator for pre-creation hook functions that ensures the base model class is set to `GeneralManagerBasisModel`.
         
-        Wraps a pre-creation function, injecting ReadOnlyModel as the base model class argument before the GeneralManager instance is created.
+        Wraps a pre-creation function, injecting `GeneralManagerBasisModel` as the `base_model_class` argument before the manager class is created.
         """
+
         def wrapper(
             name: generalManagerClassName,
             attrs: attributes,
             interface: interfaceBaseClass,
             base_model_class=GeneralManagerBasisModel,
         ):
+            """
+            Wraps a function to ensure the `base_model_class` argument is set to `GeneralManagerBasisModel` before invocation.
+            
+            Parameters:
+                name: The name of the manager class being created.
+                attrs: Attributes for the manager class.
+                interface: The interface base class to use.
+            
+            Returns:
+                The result of calling the wrapped function with `base_model_class` set to `GeneralManagerBasisModel`.
+            """
             return func(
                 name, attrs, interface, base_model_class=GeneralManagerBasisModel
             )
@@ -253,12 +258,14 @@ class ReadOnlyInterface(DBBasedInterface):
     @classmethod
     def handleInterface(cls) -> tuple[classPreCreationMethod, classPostCreationMethod]:
         """
-        Return the pre- and post-creation hook methods for integrating this interface with a GeneralManager.
+        Return the pre- and post-creation hook methods for integrating the interface with a manager meta-class system.
         
-        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.
+        The returned tuple includes:
+        - A pre-creation method that ensures the base model class is set for read-only operation.
+        - A post-creation method that registers the manager class as read-only.
         
         Returns:
-            tuple: A pair of methods for pre- and post-creation processing.
+            tuple: The pre-creation and post-creation hook methods for manager class lifecycle integration.
         """
         return cls.readOnlyPreCreate(cls._preCreate), cls.readOnlyPostCreate(
             cls._postCreate

general_manager/manager/generalManager.py

@@ -13,13 +13,21 @@ if TYPE_CHECKING:
         InterfaceBase,
     )
 GeneralManagerType = TypeVar("GeneralManagerType", bound="GeneralManager")
+InterfaceType = TypeVar("InterfaceType", bound="InterfaceBase", covariant=True)
 
 
-class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
-    Interface: Type[InterfaceBase]
+class GeneralManager(
+    Generic[GeneralManagerType, InterfaceType], metaclass=GeneralManagerMeta
+):
+    Interface: Type[InterfaceType]
     _attributes: dict[str, Any]
 
     def __init__(self, *args: Any, **kwargs: Any):
+        """
+        Initialize the manager by creating an interface instance with the provided arguments and storing its identification.
+        
+        The identification is registered with the dependency tracker for tracking purposes.
+        """
         self._interface = self.Interface(*args, **kwargs)
         self.__id: dict[str, Any] = self._interface.identification
         DependencyTracker.track(
@@ -33,11 +41,26 @@ class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
         return f"{self.__class__.__name__}(**{self.__id})"
 
     def __reduce__(self) -> str | tuple[Any, ...]:
+        """
+        Support object serialization by returning a tuple containing the class and identification values for pickling.
+        """
         return (self.__class__, tuple(self.__id.values()))
 
     def __or__(
-        self, other: GeneralManager[GeneralManagerType] | Bucket[GeneralManagerType]
+        self,
+        other: (
+            GeneralManager[GeneralManagerType, InterfaceType]
+            | Bucket[GeneralManagerType]
+        ),
     ) -> Bucket[GeneralManagerType]:
+        """
+        Combine this manager with another manager of the same class or a Bucket using the union operator.
+        
+        If combined with a Bucket, returns the union of the Bucket and this manager. If combined with another manager of the same class, returns a Bucket containing both instances. Raises a TypeError for unsupported types.
+        
+        Returns:
+            Bucket[GeneralManagerType]: A Bucket containing the union of the involved managers.
+        """
         if isinstance(other, Bucket):
             return other | self
         elif isinstance(other, GeneralManager) and other.__class__ == self.__class__:
@@ -63,11 +86,24 @@ class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
     @dataChange
     def create(
         cls,
-        creator_id: int,
+        creator_id: int | None = None,
         history_comment: str | None = None,
         ignore_permission: bool = False,
         **kwargs: dict[str, Any],
-    ) -> GeneralManager[GeneralManagerType]:
+    ) -> GeneralManager[GeneralManagerType, InterfaceType]:
+        """
+        Creates a new managed object using the underlying interface and returns a corresponding manager instance.
+        
+        Performs a permission check if a `Permission` class is defined and permission checks are not ignored. Passes all provided arguments to the interface's `create` method.
+        
+        Parameters:
+            creator_id (int | None): Optional identifier for the creator of the object.
+            history_comment (str | None): Optional comment for audit or history tracking.
+            ignore_permission (bool): If True, skips the permission check.
+        
+        Returns:
+            GeneralManager[GeneralManagerType, InterfaceType]: A new manager instance for the created object.
+        """
         Permission: Type[BasePermission] | None = getattr(cls, "Permission", None)
         if Permission is not None and not ignore_permission:
             Permission.checkCreatePermission(kwargs, cls, creator_id)
@@ -79,11 +115,23 @@ class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
     @dataChange
     def update(
         self,
-        creator_id: int,
+        creator_id: int | None = None,
         history_comment: str | None = None,
         ignore_permission: bool = False,
         **kwargs: dict[str, Any],
-    ) -> GeneralManager[GeneralManagerType]:
+    ) -> GeneralManager[GeneralManagerType, InterfaceType]:
+        """
+        Update the underlying interface object with new data and return a new manager instance.
+        
+        Parameters:
+            creator_id (int | None): Optional identifier for the user performing the update.
+            history_comment (str | None): Optional comment describing the update.
+            ignore_permission (bool): If True, skips permission checks.
+            **kwargs: Additional fields to update on the interface object.
+        
+        Returns:
+            GeneralManager[GeneralManagerType, InterfaceType]: A new manager instance reflecting the updated object.
+        """
         Permission: Type[BasePermission] | None = getattr(self, "Permission", None)
         if Permission is not None and not ignore_permission:
             Permission.checkUpdatePermission(kwargs, self, creator_id)
@@ -97,10 +145,21 @@ class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
     @dataChange
     def deactivate(
         self,
-        creator_id: int,
+        creator_id: int | None = None,
         history_comment: str | None = None,
         ignore_permission: bool = False,
-    ) -> GeneralManager[GeneralManagerType]:
+    ) -> GeneralManager[GeneralManagerType, InterfaceType]:
+        """
+        Deactivates the underlying interface object and returns a new manager instance.
+        
+        Parameters:
+            creator_id (int | None): Optional identifier for the user performing the deactivation.
+            history_comment (str | None): Optional comment describing the reason for deactivation.
+            ignore_permission (bool): If True, skips permission checks.
+        
+        Returns:
+            GeneralManager[GeneralManagerType, InterfaceType]: A new instance representing the deactivated object.
+        """
         Permission: Type[BasePermission] | None = getattr(self, "Permission", None)
         if Permission is not None and not ignore_permission:
             Permission.checkDeletePermission(self, creator_id)
@@ -130,15 +189,15 @@ class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
     @staticmethod
     def __parse_identification(kwargs: dict[str, Any]) -> dict[str, Any] | None:
         """
-        Processes a dictionary by replacing GeneralManager instances with their identifications.
+        Return a dictionary with all GeneralManager instances in the input replaced by their identification dictionaries.
         
-        For each key-value pair, replaces any GeneralManager instance with its identification. Lists and tuples are processed recursively, substituting contained GeneralManager instances with their identifications. Returns None if the resulting dictionary is empty.
+        For each key-value pair in the input, any GeneralManager instance is replaced by its identification. Lists and tuples are processed recursively, substituting contained GeneralManager instances with their identifications. Returns None if the resulting dictionary is empty.
         
-        Args:
-            kwargs: Dictionary to process.
+        Parameters:
+            kwargs (dict[str, Any]): Dictionary to process.
         
         Returns:
-            A new dictionary with GeneralManager instances replaced by their identifications, or None if empty.
+            dict[str, Any] | None: Processed dictionary with identifications, or None if empty.
         """
         output = {}
         for key, value in kwargs.items():

general_manager/manager/input.py

@@ -18,12 +18,12 @@ class Input(Generic[INPUT_TYPE]):
         depends_on: Optional[List[str]] = None,
     ):
         """
-        Initializes an Input instance with type information, possible values, and dependencies.
+        Create an Input specification with type information, allowed values, and dependency metadata.
         
-        Args:
-            type: The expected type for the input value.
-            possible_values: An optional iterable or callable that defines allowed values.
-            depends_on: An optional list of dependency names. If not provided and possible_values is callable, dependencies are inferred from its parameters.
+        Parameters:
+            type: The expected Python type for the input value.
+            possible_values: Optional; an iterable of allowed values or a callable returning allowed values.
+            depends_on: Optional; a list of dependency names. If not provided and possible_values is callable, dependencies are inferred from the callable's parameter names.
         """
         self.type = type
         self.possible_values = possible_values
@@ -42,14 +42,9 @@ class Input(Generic[INPUT_TYPE]):
 
     def cast(self, value: Any) -> Any:
         """
-        Casts the input value to the type specified by this Input instance.
+        Converts the input value to the type specified by this Input instance, handling special cases for dates, datetimes, GeneralManager subclasses, and Measurement types.
         
-        Handles special cases for date, datetime, GeneralManager subclasses, and Measurement types.
-        If the value is already of the target type, it is returned unchanged. Otherwise, attempts to
-        convert or construct the value as appropriate for the target type.
-        
-        Args:
-            value: The value to be cast or converted.
+        If the value is already of the target type, it is returned unchanged. For date and datetime types, string and cross-type conversions are supported. For GeneralManager subclasses, instances are constructed from a dictionary or an ID. For Measurement, string values are parsed accordingly. Otherwise, the value is cast using the target type's constructor.
         
         Returns:
             The value converted to the target type, or an instance of the target type.
@@ -57,6 +52,8 @@ class Input(Generic[INPUT_TYPE]):
         if self.type == date:
             if isinstance(value, datetime) and type(value) is not date:
                 return value.date()
+            elif isinstance(value, date):
+                return value
             return date.fromisoformat(value)
         if self.type == datetime:
             if isinstance(value, date):

general_manager/manager/meta.py

@@ -18,29 +18,30 @@ class _nonExistent:
 
 class GeneralManagerMeta(type):
     all_classes: list[Type[GeneralManager]] = []
-    read_only_classes: list[Type[GeneralManager]] = []
+    read_only_classes: list[Type[GeneralManager[Any, ReadOnlyInterface]]] = []
     pending_graphql_interfaces: list[Type[GeneralManager]] = []
     pending_attribute_initialization: list[Type[GeneralManager]] = []
     Interface: type[InterfaceBase]
 
     def __new__(mcs, name: str, bases: tuple[type, ...], attrs: dict[str, Any]) -> type:
-
         """
-        Creates a new class, handling interface integration and registration for the general manager framework.
-        
-        If an 'Interface' attribute is present in the class definition, validates and processes it using the interface's pre- and post-creation hooks, then registers the resulting class for attribute initialization and tracking. If the 'AUTOCREATE_GRAPHQL' setting is enabled, also registers the class for pending GraphQL interface creation.
+        Create a new class using the metaclass, integrating interface hooks and registering the class for attribute initialization and tracking.
         
-        Args:
-            name: The name of the class being created.
-            bases: Base classes for the new class.
-            attrs: Attribute dictionary for the new class.
+        If the class definition includes an 'Interface' attribute, validates it as a subclass of `InterfaceBase`, applies pre- and post-creation hooks from the interface, and registers the resulting class for attribute initialization and management. If the `AUTOCREATE_GRAPHQL` setting is enabled, also registers the class for pending GraphQL interface creation.
         
         Returns:
-            The newly created class, possibly augmented with interface and registration logic.
+            The newly created class, potentially augmented with interface integration and registration logic.
         """
+
         def createNewGeneralManagerClass(
             mcs, name: str, bases: tuple[type, ...], attrs: dict[str, Any]
         ) -> Type[GeneralManager]:
+            """
+            Create a new general manager class using the standard metaclass instantiation process.
+            
+            Returns:
+                The newly created general manager class.
+            """
             return super().__new__(mcs, name, bases, attrs)
 
         if "Interface" in attrs:
@@ -69,6 +70,11 @@ class GeneralManagerMeta(type):
         attributes: Iterable[str], new_class: Type[GeneralManager]
     ):
 
+        """
+        Dynamically assigns property descriptors to a class for the specified attribute names.
+        
+        For each attribute name, creates a descriptor that retrieves the value from an instance's `_attributes` dictionary. If accessed on the class, returns the field type from the class's interface. If the attribute is callable, it is invoked with the instance's interface. Raises `AttributeError` if the attribute is missing or if an error occurs during callable invocation.
+        """
         def desciptorMethod(attr_name: str, new_class: type):
             class Descriptor(Generic[GeneralManagerType]):
                 def __init__(self, attr_name: str, new_class: Type[GeneralManager]):
@@ -77,7 +83,7 @@ class GeneralManagerMeta(type):
 
                 def __get__(
                     self,
-                    instance: GeneralManager[GeneralManagerType] | None,
+                    instance: GeneralManager[GeneralManagerType, InterfaceBase] | None,
                     owner: type | None = None,
                 ):
                     if instance is None:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.7.0
+Version: 0.8.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.7.0.dist-info → generalmanager-0.8.0.dist-info}/RECORD

@@ -1,11 +1,12 @@
 general_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-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/apps.py,sha256=P_SmEPHto0Wl7cgP6l2MAOQJgXjuGBLzRIidpfHsdc0,8316
+general_manager/api/graphql.py,sha256=ZMzlpgmyn2X9Zwxo12r-b5UZ2R-u1pXys_nhNczxyX8,31622
+general_manager/api/mutation.py,sha256=RYCogAdUpUedyh2B9keMAzq9u-iIhEKAsoiw5xXmhrQ,5669
 general_manager/api/property.py,sha256=oc93p1P8dcIvrNorRuqD1EJVsd6eYttYhZuAS0s28gs,696
 general_manager/auxiliary/__init__.py,sha256=4IwKJzsNxGduF-Ej0u1BNHVaMhkql8PjHbVtx9DOTSY,76
 general_manager/auxiliary/argsToKwargs.py,sha256=kmp1xonpQp4X_y8ZJG6c5uOW7zQwo0HtPqsHWVzXRSM,921
 general_manager/auxiliary/filterParser.py,sha256=wmR4YzsnYgjI2Co5eyvCFROldotAraHx_GiCDJo79IY,5410
+general_manager/auxiliary/formatString.py,sha256=gZSbsKvpywBmf5bIx6YW43LmNJcqsCP7ZfrB7YPvaFo,1436
 general_manager/auxiliary/jsonEncoder.py,sha256=TDsgFQvheITHZgdmn-m8tk1_QCzpT0XwEHo7bY3Qe-M,638
 general_manager/auxiliary/makeCacheKey.py,sha256=lczutqxlofLSUnheKRi8nazhOyPa04TZOFNxNn5vDu4,1126
 general_manager/auxiliary/noneToZero.py,sha256=KfQtMQnrT6vsYST0K7lv6pVujkDcK3XL8czHYOhgqKQ,539
@@ -24,16 +25,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=WjavtLW_vzyv3PDIIGpw0cydFXjIBJfzxflMXDNF7ac,8583
+general_manager/interface/baseInterface.py,sha256=GCMo0MGlaRAElovfI34qfuWuVYOyTQLG0OA-ZJx8i3s,8604
 general_manager/interface/calculationInterface.py,sha256=Kg_OqLw67tcLwdzYNLq31eKVLzkM7taw-8Mzmk0CYi0,4232
-general_manager/interface/databaseBasedInterface.py,sha256=NoHJp1A9kWRa5R8aal3MS--4PRsHY4JMBzpcuNd69kY,22182
-general_manager/interface/databaseInterface.py,sha256=08dFgxoLQNa13RK2NQ4cDNbNPIG-X9ChLs3NvJcSp6Y,4923
-general_manager/interface/readOnlyInterface.py,sha256=USr4k6Jr1gz91Cdi8bbZY59cTy5MPGZ3oC40xCdWS88,10873
+general_manager/interface/databaseBasedInterface.py,sha256=twdqUyvPci77WXqCX0k2dpFajhx38bbUfgxrV_BjcxQ,22788
+general_manager/interface/databaseInterface.py,sha256=kYPuwjAVcVMbxozc-eg-LwGY1C0k-sqt73b7DSlVxWI,6389
+general_manager/interface/readOnlyInterface.py,sha256=TkfbOeaa2wCq5kCv0a3IwJWcYOTVbtNsdNWmGAz0Mns,11217
 general_manager/manager/__init__.py,sha256=l3RYp62aEhj3Y975_XUTIzo35LUnkTJHkb_hgChnXXI,111
-general_manager/manager/generalManager.py,sha256=HX69KhrnSGVkuJwHY_jzff5gS0VD-6fRxKnd59A5Ct4,6100
+general_manager/manager/generalManager.py,sha256=AVFZICHzqiIyn7lgPU_WLH8X8WLP1edvWAE5CljZPrk,9178
 general_manager/manager/groupManager.py,sha256=8dpZUfm7aFL4lraUWv4qbbDRClQZaYxw4prclhBZYZs,4367
-general_manager/manager/input.py,sha256=iKawV3P1QICz-0AQUF00OvH7LZYxussg3svpvCUl8hE,2977
-general_manager/manager/meta.py,sha256=I4HO7Tp2P0-eRKicVzZRFrYzyMshjWY2ZGP8no9Su-Y,4411
+general_manager/manager/input.py,sha256=-pJXGJ-g2-OxZfl4Buj3mQkf05fN4p8MsR2Lh9BQcEo,3208
+general_manager/manager/meta.py,sha256=gtzFKBMCvyAx5qo2BVuTBqHZzngR-ivu8YLY7oiSUEk,5059
 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 +47,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.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,,
+generalmanager-0.8.0.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
+generalmanager-0.8.0.dist-info/METADATA,sha256=awQ6aVm9myhb0KpGFMC_2Pc_McXqbMzECdrwxeORSkM,6205
+generalmanager-0.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+generalmanager-0.8.0.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
+generalmanager-0.8.0.dist-info/RECORD,,