GeneralManager 0.7.0__py3-none-any.whl → 0.9.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,27 +29,35 @@ class GeneralmanagerConfig(AppConfig):
 
     def ready(self):
         """
-        Initializes the general_manager app when Django starts.
+        Performs initialization tasks for the general_manager app when Django starts.
         
-        Sets up read-only interface synchronization and schema validation, initializes general manager class attributes and connections, and conditionally configures the GraphQL schema and endpoint based on settings.
+        Sets up synchronization and schema validation for read-only interfaces, initializes attributes and property accessors for general manager classes, and configures the GraphQL schema and endpoint if enabled in settings.
         """
-        self.handleReadOnlyInterface()
-        self.initializeGeneralManagerClasses()
+        self.handleReadOnlyInterface(GeneralManagerMeta.read_only_classes)
+        self.initializeGeneralManagerClasses(
+            GeneralManagerMeta.pending_attribute_initialization,
+            GeneralManagerMeta.all_classes,
+        )
         if getattr(settings, "AUTOCREATE_GRAPHQL", False):
-            self.handleGraphQL()
+            self.handleGraphQL(GeneralManagerMeta.pending_graphql_interfaces)
 
-    def handleReadOnlyInterface(self):
+    @staticmethod
+    def handleReadOnlyInterface(
+        read_only_classes: list[Type[GeneralManager[Any, ReadOnlyInterface]]],
+    ):
         """
-        Sets up synchronization and schema validation for all registered read-only interfaces.
+        Configures synchronization and schema validation for the provided read-only interface classes.
         
-        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.
+        Ensures that each read-only interface is synchronized before Django management commands run, and registers system checks to validate that their schemas are up to date.
         """
-        self.patchReadOnlyInterfaceSync(GeneralManagerMeta.read_only_classes)
+        GeneralmanagerConfig.patchReadOnlyInterfaceSync(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
+        for general_manager_class in 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(
@@ -57,29 +67,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 all provided read-only interfaces before executing any management command, except during autoreload subprocesses of 'runserver'.
         
-        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 class in `general_manager_classes`, the associated read-only interface's `syncData` method is called prior to command execution, ensuring data consistency before management operations.
         """
-        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 in an autoreload subprocess of 'runserver'.
+            
+            Parameters:
+                argv (list): Command-line arguments for the management command.
             
-            Synchronization occurs for all registered read-only interfaces unless the command is 'runserver' in an autoreload subprocess.
+            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.")
@@ -88,18 +106,20 @@ class GeneralmanagerConfig(AppConfig):
 
         BaseCommand.run_from_argv = run_from_argv_with_sync
 
-    def initializeGeneralManagerClasses(self):
+    @staticmethod
+    def initializeGeneralManagerClasses(
+        pending_attribute_initialization: list[Type[GeneralManager]],
+        all_classes: list[Type[GeneralManager]],
+    ):
         """
-        Initializes attributes and interconnections for all GeneralManager classes.
+        Initializes attributes and establishes dynamic relationships for 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 class pending attribute initialization, assigns interface attributes and creates property accessors. Then, for all registered GeneralManager classes, connects input fields referencing 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:
+        for general_manager_class in pending_attribute_initialization:
             attributes = general_manager_class.Interface.getAttributes()
             setattr(general_manager_class, "_attributes", attributes)
             GeneralManagerMeta.createAtPropertiesForAttributes(
@@ -107,7 +127,7 @@ class GeneralmanagerConfig(AppConfig):
             )
 
         logger.debug("starting to connect inputs to other general manager classes...")
-        for general_manager_class in GeneralManagerMeta.all_classes:
+        for general_manager_class in all_classes:
             attributes = getattr(general_manager_class.Interface, "input_fields", {})
             for attribute_name, attribute in attributes.items():
                 if isinstance(attribute, Input) and issubclass(
@@ -125,12 +145,15 @@ class GeneralmanagerConfig(AppConfig):
                         graphQlProperty(func),
                     )
 
-    def handleGraphQL(self):
+    @staticmethod
+    def handleGraphQL(
+        pending_graphql_interfaces: list[Type[GeneralManager]],
+    ):
         """
-        Sets up GraphQL interfaces, mutations, and schema for all pending general manager classes, and adds the GraphQL endpoint to the Django URL configuration.
+        Creates GraphQL interfaces and mutations for the provided general manager classes, builds the GraphQL schema, and registers the GraphQL endpoint in the Django URL configuration.
         """
         logger.debug("Starting to create GraphQL interfaces and mutations...")
-        for general_manager_class in GeneralManagerMeta.pending_graphql_interfaces:
+        for general_manager_class in pending_graphql_interfaces:
             GraphQL.createGraphqlInterface(general_manager_class)
             GraphQL.createGraphqlMutation(general_manager_class)
 
@@ -148,17 +171,22 @@ class GeneralmanagerConfig(AppConfig):
             query=GraphQL._query_class,
             mutation=GraphQL._mutation_class,
         )
-        self.addGraphqlUrl(schema)
+        GeneralmanagerConfig.addGraphqlUrl(schema)
 
-    def addGraphqlUrl(self, schema):
+    @staticmethod
+    def addGraphqlUrl(schema):
         """
-        Dynamically adds a GraphQL endpoint to the Django URL configuration using the provided schema.
+        Adds a GraphQL endpoint to the Django URL configuration using the provided schema.
+        
+        Parameters:
+            schema: The GraphQL schema to use for the endpoint.
         
-        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)
-        graph_ql_url = getattr(settings, "GRAPHQL_URL", "graphql/")
+        graph_ql_url = getattr(settings, "GRAPHQL_URL", "graphql")
         if not root_url_conf_path:
             raise Exception("ROOT_URLCONF not found in settings")
         urlconf = import_module(root_url_conf_path)

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