GeneralManager 0.19.1__py3-none-any.whl → 0.20.0__py3-none-any.whl

general_manager/api/mutation.py

@@ -20,10 +20,10 @@ import graphene  # type: ignore[import]
 from graphql import GraphQLResolveInfo
 
 from general_manager.api.graphql import GraphQL, HANDLED_MANAGER_ERRORS
-from general_manager.manager.generalManager import GeneralManager
+from general_manager.manager.general_manager import GeneralManager
 
-from general_manager.utils.formatString import snake_to_camel
-from general_manager.permission.mutationPermission import MutationPermission
+from general_manager.utils.format_string import snake_to_camel
+from general_manager.permission.mutation_permission import MutationPermission
 from types import UnionType
 
 
@@ -91,7 +91,7 @@ class DuplicateMutationOutputNameError(ValueError):
         )
 
 
-def graphQlMutation(
+def graph_ql_mutation(
     _func: FuncT | type[MutationPermission] | None = None,
     permission: Optional[Type[MutationPermission]] = None,
 ) -> FuncT | Callable[[FuncT], FuncT]:
@@ -162,14 +162,14 @@ def graphQlMutation(
             if get_origin(ann) is list or get_origin(ann) is List:
                 inner = get_args(ann)[0]
                 field = graphene.List(
-                    GraphQL._mapFieldToGrapheneBaseType(inner),
+                    GraphQL._map_field_to_graphene_base_type(inner),
                     **kwargs,
                 )
             else:
                 if inspect.isclass(ann) and issubclass(ann, GeneralManager):
                     field = graphene.ID(**kwargs)
                 else:
-                    field = GraphQL._mapFieldToGrapheneBaseType(ann)(**kwargs)
+                    field = GraphQL._map_field_to_graphene_base_type(ann)(**kwargs)
 
             arg_fields[name] = field
 
@@ -201,7 +201,7 @@ def graphQlMutation(
 
             basis_type = out.__value__ if is_named_type else out
 
-            outputs[field_name] = GraphQL._mapFieldToGrapheneRead(
+            outputs[field_name] = GraphQL._map_field_to_graphene_read(
                 basis_type, field_name
             )
 
@@ -220,7 +220,7 @@ def graphQlMutation(
                 **kwargs: Mutation arguments provided by the client.
 
             Returns:
-                mutation_class: Instance of the mutation with output fields populated; `success` is `True` on successful execution and `False` if a handled manager error occurred (after being forwarded to GraphQL._handleGraphQLError).
+                mutation_class: Instance of the mutation with output fields populated; `success` is `True` on successful execution and `False` if a handled manager error occurred (after being forwarded to GraphQL._handle_graph_ql_error).
             """
             if permission:
                 permission.check(kwargs, info.context.user)
@@ -244,7 +244,7 @@ def graphQlMutation(
                 data["success"] = True
                 return mutation_class(**data)
             except HANDLED_MANAGER_ERRORS as error:
-                raise GraphQL._handleGraphQLError(error) from error
+                raise GraphQL._handle_graph_ql_error(error) from error
 
         # Assemble class dict
         class_dict: dict[str, Any] = {

general_manager/api/property.py

@@ -109,9 +109,9 @@ class GraphQLProperty(property):
 
 
 @overload
-def graphQlProperty(func: T) -> GraphQLProperty: ...
+def graph_ql_property(func: T) -> GraphQLProperty: ...
 @overload
-def graphQlProperty(
+def graph_ql_property(
     *,
     sortable: bool = False,
     filterable: bool = False,
@@ -119,14 +119,14 @@ def graphQlProperty(
 ) -> Callable[[T], GraphQLProperty]: ...
 
 
-def graphQlProperty(
+def graph_ql_property(
     func: Callable[..., Any] | None = None,
     *,
     sortable: bool = False,
     filterable: bool = False,
     query_annotation: Any | None = None,
 ) -> GraphQLProperty | Callable[[T], GraphQLProperty]:
-    from general_manager.cache.cacheDecorator import cached
+    from general_manager.cache.cache_decorator import cached
 
     """
     Decorate a resolver to return a cached ``GraphQLProperty`` descriptor.

general_manager/apps.py

@@ -1,22 +1,25 @@
 from __future__ import annotations
-from django.apps import AppConfig
-import graphene  # type: ignore[import]
-import os
-from django.conf import settings
-from django.urls import path, re_path
-from graphene_django.views import GraphQLView  # type: ignore[import]
-from importlib import import_module, util
+
 import importlib.abc
+import os
 import sys
-from general_manager.manager.generalManager import GeneralManager
-from general_manager.manager.meta import GeneralManagerMeta
-from general_manager.manager.input import Input
-from general_manager.api.property import graphQlProperty
-from general_manager.api.graphql import GraphQL
+from importlib import import_module, util
 from typing import TYPE_CHECKING, Any, Callable, Type, cast
+
+import graphene  # type: ignore[import]
+from django.apps import AppConfig
+from django.conf import settings
 from django.core.checks import register
-import logging
 from django.core.management.base import BaseCommand
+from django.urls import path, re_path
+from graphene_django.views import GraphQLView  # type: ignore[import]
+
+from general_manager.api.graphql import GraphQL
+from general_manager.api.property import graph_ql_property
+from general_manager.logging import get_logger
+from general_manager.manager.general_manager import GeneralManager
+from general_manager.manager.input import Input
+from general_manager.manager.meta import GeneralManagerMeta
 
 
 class MissingRootUrlconfError(RuntimeError):
@@ -43,9 +46,9 @@ class InvalidPermissionClassError(TypeError):
 
 
 if TYPE_CHECKING:
-    from general_manager.interface.readOnlyInterface import ReadOnlyInterface
+    from general_manager.interface.read_only_interface import ReadOnlyInterface
 
-logger = logging.getLogger(__name__)
+logger = get_logger("apps")
 
 
 class GeneralmanagerConfig(AppConfig):
@@ -58,16 +61,16 @@ class GeneralmanagerConfig(AppConfig):
 
         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(GeneralManagerMeta.read_only_classes)
-        self.initializeGeneralManagerClasses(
+        self.handle_read_only_interface(GeneralManagerMeta.read_only_classes)
+        self.initialize_general_manager_classes(
             GeneralManagerMeta.pending_attribute_initialization,
             GeneralManagerMeta.all_classes,
         )
         if getattr(settings, "AUTOCREATE_GRAPHQL", False):
-            self.handleGraphQL(GeneralManagerMeta.pending_graphql_interfaces)
+            self.handle_graph_ql(GeneralManagerMeta.pending_graphql_interfaces)
 
     @staticmethod
-    def handleReadOnlyInterface(
+    def handle_read_only_interface(
         read_only_classes: list[Type[GeneralManager]],
     ) -> None:
         """
@@ -76,10 +79,13 @@ class GeneralmanagerConfig(AppConfig):
         Parameters:
             read_only_classes (list[Type[GeneralManager]]): GeneralManager subclasses whose Interface implements a ReadOnlyInterface; each class will have its read-only data synchronized before management commands and a Django system check registered to verify the Interface schema is up to date.
         """
-        GeneralmanagerConfig.patchReadOnlyInterfaceSync(read_only_classes)
-        from general_manager.interface.readOnlyInterface import ReadOnlyInterface
+        GeneralmanagerConfig.patch_read_only_interface_sync(read_only_classes)
+        from general_manager.interface.read_only_interface import ReadOnlyInterface
 
-        logger.debug("starting to register ReadOnlyInterface schema warnings...")
+        logger.debug(
+            "registering read-only schema checks",
+            context={"count": len(read_only_classes)},
+        )
 
         def _build_schema_check(
             manager_cls: Type[GeneralManager], model: Any
@@ -96,7 +102,7 @@ class GeneralmanagerConfig(AppConfig):
             """
 
             def schema_check(*_: Any, **__: Any) -> list[Any]:
-                return ReadOnlyInterface.ensureSchemaIsUpToDate(manager_cls, model)
+                return ReadOnlyInterface.ensure_schema_is_up_to_date(manager_cls, model)
 
             return schema_check
 
@@ -113,18 +119,18 @@ class GeneralmanagerConfig(AppConfig):
             )
 
     @staticmethod
-    def patchReadOnlyInterfaceSync(
+    def patch_read_only_interface_sync(
         general_manager_classes: list[Type[GeneralManager]],
     ) -> None:
         """
         Ensure the provided GeneralManager classes' ReadOnlyInterfaces synchronize their data before any Django management command is executed.
 
-        For each class in `general_manager_classes`, calls the class's `Interface.syncData()` to keep read-only data consistent. Skips synchronization when running the autoreload subprocess of `runserver`.
+        For each class in `general_manager_classes`, calls the class's `Interface.sync_data()` to keep read-only data consistent. Skips synchronization when running the autoreload subprocess of `runserver`.
         Parameters:
-            general_manager_classes (list[Type[GeneralManager]]): GeneralManager subclasses whose `Interface` implements `syncData`.
+            general_manager_classes (list[Type[GeneralManager]]): GeneralManager subclasses whose `Interface` implements `sync_data`.
         """
         """
-        Wrap BaseCommand.run_from_argv to call `syncData()` on registered ReadOnlyInterfaces before executing the original command.
+        Wrap BaseCommand.run_from_argv to call `sync_data()` on registered ReadOnlyInterfaces before executing the original command.
 
         Skips synchronization when the command is `runserver` and the process is the autoreload subprocess.
         Parameters:
@@ -133,7 +139,7 @@ class GeneralmanagerConfig(AppConfig):
         Returns:
             The result returned by the original `BaseCommand.run_from_argv` call.
         """
-        from general_manager.interface.readOnlyInterface import ReadOnlyInterface
+        from general_manager.interface.read_only_interface import ReadOnlyInterface
 
         original_run_from_argv = BaseCommand.run_from_argv
 
@@ -141,7 +147,7 @@ class GeneralmanagerConfig(AppConfig):
             self: BaseCommand,
             argv: list[str],
         ) -> None:
-            # Ensure syncData is only called at real run of runserver
+            # Ensure sync_data is only called at real run of runserver
             """
             Synchronizes all registered ReadOnlyInterface data before running a Django management command, except when running the autoreload subprocess of `runserver`.
 
@@ -154,14 +160,27 @@ class GeneralmanagerConfig(AppConfig):
             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...")
+                logger.debug(
+                    "syncing read-only interfaces",
+                    context={
+                        "command": command,
+                        "autoreload": not run_main if command == "runserver" else False,
+                        "count": len(general_manager_classes),
+                    },
+                )
                 for general_manager_class in general_manager_classes:
                     read_only_interface = cast(
                         Type[ReadOnlyInterface], general_manager_class.Interface
                     )
-                    read_only_interface.syncData()
-
-                logger.debug("finished syncing ReadOnlyInterface data.")
+                    read_only_interface.sync_data()
+
+                logger.debug(
+                    "finished syncing read-only interfaces",
+                    context={
+                        "command": command,
+                        "count": len(general_manager_classes),
+                    },
+                )
 
             result = original_run_from_argv(self, argv)
             return result
@@ -169,20 +188,26 @@ class GeneralmanagerConfig(AppConfig):
         BaseCommand.run_from_argv = run_from_argv_with_sync  # type: ignore[assignment]
 
     @staticmethod
-    def initializeGeneralManagerClasses(
+    def initialize_general_manager_classes(
         pending_attribute_initialization: list[Type[GeneralManager]],
         all_classes: list[Type[GeneralManager]],
     ) -> None:
         """
         Initialize GeneralManager classes' interface attributes, create attribute-based accessors, wire GraphQL connection properties between related managers, and validate each class's permission configuration.
 
-        For each class in `pending_attribute_initialization` this assigns the class's Interface attributes to its internal `_attributes` and creates property accessors for those attributes. For each class in `all_classes` this scans its Interface `input_fields` for inputs whose type is another GeneralManager subclass and adds a GraphQL property on the connected manager that resolves related objects filtered by the input attribute. Finally, validate and normalize the Permission attribute on every class via GeneralmanagerConfig.checkPermissionClass.
+        For each class in `pending_attribute_initialization` this assigns the class's Interface attributes to its internal `_attributes` and creates property accessors for those attributes. For each class in `all_classes` this scans its Interface `input_fields` for inputs whose type is another GeneralManager subclass and adds a GraphQL property on the connected manager that resolves related objects filtered by the input attribute. Finally, validate and normalize the Permission attribute on every class via GeneralmanagerConfig.check_permission_class.
 
         Parameters:
             pending_attribute_initialization (list[type[GeneralManager]]): GeneralManager classes whose Interface attributes need to be initialized and whose attribute properties should be created.
             all_classes (list[type[GeneralManager]]): All registered GeneralManager classes to inspect for input-field connections and to validate permissions.
         """
-        logger.debug("Initializing GeneralManager classes...")
+        logger.debug(
+            "initializing general manager classes",
+            context={
+                "pending_attributes": len(pending_attribute_initialization),
+                "total": len(all_classes),
+            },
+        )
 
         def _build_connection_resolver(
             attribute_key: str, manager_cls: Type[GeneralManager]
@@ -204,15 +229,21 @@ class GeneralmanagerConfig(AppConfig):
             resolver.__annotations__ = {"return": manager_cls}
             return resolver
 
-        logger.debug("starting to create attributes for GeneralManager classes...")
+        logger.debug(
+            "creating manager attributes",
+            context={"pending_attributes": len(pending_attribute_initialization)},
+        )
         for general_manager_class in pending_attribute_initialization:
-            attributes = general_manager_class.Interface.getAttributes()
+            attributes = general_manager_class.Interface.get_attributes()
             general_manager_class._attributes = attributes
-            GeneralManagerMeta.createAtPropertiesForAttributes(
+            GeneralManagerMeta.create_at_properties_for_attributes(
                 attributes.keys(), general_manager_class
             )
 
-        logger.debug("starting to connect inputs to other general manager classes...")
+        logger.debug(
+            "linking manager inputs",
+            context={"total_classes": len(all_classes)},
+        )
         for general_manager_class in all_classes:
             attributes = getattr(general_manager_class.Interface, "input_fields", {})
             for attribute_name, attribute in attributes.items():
@@ -226,13 +257,13 @@ class GeneralmanagerConfig(AppConfig):
                     setattr(
                         connected_manager,
                         f"{general_manager_class.__name__.lower()}_list",
-                        graphQlProperty(resolver),
+                        graph_ql_property(resolver),
                     )
         for general_manager_class in all_classes:
-            GeneralmanagerConfig.checkPermissionClass(general_manager_class)
+            GeneralmanagerConfig.check_permission_class(general_manager_class)
 
     @staticmethod
-    def handleGraphQL(
+    def handle_graph_ql(
         pending_graphql_interfaces: list[Type[GeneralManager]],
     ) -> None:
         """
@@ -241,10 +272,13 @@ class GeneralmanagerConfig(AppConfig):
         Parameters:
             pending_graphql_interfaces (list[Type[GeneralManager]]): GeneralManager classes for which GraphQL interfaces, mutations, and optional subscriptions should be created and included in the assembled schema.
         """
-        logger.debug("Starting to create GraphQL interfaces and mutations...")
+        logger.debug(
+            "creating graphql interfaces and mutations",
+            context={"pending": len(GeneralManagerMeta.pending_graphql_interfaces)},
+        )
         for general_manager_class in pending_graphql_interfaces:
-            GraphQL.createGraphqlInterface(general_manager_class)
-            GraphQL.createGraphqlMutation(general_manager_class)
+            GraphQL.create_graphql_interface(general_manager_class)
+            GraphQL.create_graphql_mutation(general_manager_class)
 
         query_class = type("Query", (graphene.ObjectType,), GraphQL._query_fields)
         GraphQL._query_class = query_class
@@ -279,10 +313,10 @@ class GeneralmanagerConfig(AppConfig):
             schema_kwargs["subscription"] = GraphQL._subscription_class
         schema = graphene.Schema(**schema_kwargs)
         GraphQL._schema = schema
-        GeneralmanagerConfig.addGraphqlUrl(schema)
+        GeneralmanagerConfig.add_graphql_url(schema)
 
     @staticmethod
-    def addGraphqlUrl(schema: graphene.Schema) -> None:
+    def add_graphql_url(schema: graphene.Schema) -> None:
         """
         Add a GraphQL endpoint to the project's URL configuration and ensure the ASGI subscription route is configured.
 
@@ -292,7 +326,13 @@ class GeneralmanagerConfig(AppConfig):
         Raises:
             MissingRootUrlconfError: If ROOT_URLCONF is not defined in Django settings.
         """
-        logging.debug("Adding GraphQL URL to Django settings...")
+        logger.debug(
+            "configuring graphql http endpoint",
+            context={
+                "root_urlconf": getattr(settings, "ROOT_URLCONF", None),
+                "graphql_url": getattr(settings, "GRAPHQL_URL", "graphql"),
+            },
+        )
         root_url_conf_path = getattr(settings, "ROOT_URLCONF", None)
         graph_ql_url = getattr(settings, "GRAPHQL_URL", "graphql")
         if not root_url_conf_path:
@@ -317,15 +357,18 @@ class GeneralmanagerConfig(AppConfig):
         """
         asgi_path = getattr(settings, "ASGI_APPLICATION", None)
         if not asgi_path:
-            logger.debug("ASGI_APPLICATION not configured; skipping websocket setup.")
+            logger.debug(
+                "asgi application missing",
+                context={"graphql_url": graphql_url},
+            )
             return
 
         try:
             module_path, attr_name = asgi_path.rsplit(".", 1)
         except ValueError:
             logger.warning(
-                "ASGI_APPLICATION '%s' is not a valid module path; skipping websocket setup.",
-                asgi_path,
+                "invalid asgi application path",
+                context={"asgi_application": asgi_path},
             )
             return
 
@@ -334,9 +377,12 @@ class GeneralmanagerConfig(AppConfig):
         except RuntimeError as exc:
             if "populate() isn't reentrant" not in str(exc):
                 logger.warning(
-                    "Unable to import ASGI module '%s': %s",
-                    module_path,
-                    exc,
+                    "unable to import asgi module",
+                    context={
+                        "module": module_path,
+                        "error": type(exc).__name__,
+                        "message": str(exc),
+                    },
                     exc_info=True,
                 )
                 return
@@ -344,8 +390,8 @@ class GeneralmanagerConfig(AppConfig):
             spec = util.find_spec(module_path)
             if spec is None or spec.loader is None:
                 logger.warning(
-                    "Could not locate loader for ASGI module '%s'; skipping websocket setup.",
-                    module_path,
+                    "missing loader for asgi module",
+                    context={"module": module_path},
                 )
                 return
 
@@ -416,7 +462,13 @@ class GeneralmanagerConfig(AppConfig):
             return
         except ImportError as exc:  # pragma: no cover - defensive
             logger.warning(
-                "Unable to import ASGI module '%s': %s", module_path, exc, exc_info=True
+                "unable to import asgi module",
+                context={
+                    "module": module_path,
+                    "error": type(exc).__name__,
+                    "message": str(exc),
+                },
+                exc_info=True,
             )
             return
 
@@ -447,8 +499,11 @@ class GeneralmanagerConfig(AppConfig):
             RuntimeError,
         ) as exc:  # pragma: no cover - optional dependency
             logger.debug(
-                "Channels or GraphQL subscription consumer unavailable (%s); skipping websocket setup.",
-                exc,
+                "channels dependencies unavailable",
+                context={
+                    "error": type(exc).__name__,
+                    "message": str(exc),
+                },
             )
             return
 
@@ -459,8 +514,8 @@ class GeneralmanagerConfig(AppConfig):
 
         if not hasattr(websocket_patterns, "append"):
             logger.warning(
-                "websocket_urlpatterns in '%s' does not support appending; skipping websocket setup.",
-                asgi_module.__name__,
+                "websocket_urlpatterns not appendable",
+                context={"module": asgi_module.__name__},
             )
             return
 
@@ -498,7 +553,7 @@ class GeneralmanagerConfig(AppConfig):
             setattr(asgi_module, attr_name, wrapped_application)
 
     @staticmethod
-    def checkPermissionClass(general_manager_class: Type[GeneralManager]) -> None:
+    def check_permission_class(general_manager_class: Type[GeneralManager]) -> None:
         """
         Validate and normalize a GeneralManager class's Permission attribute.
 
@@ -510,8 +565,8 @@ class GeneralmanagerConfig(AppConfig):
         Raises:
             InvalidPermissionClassError: If the existing Permission attribute is not a subclass of BasePermission.
         """
-        from general_manager.permission.basePermission import BasePermission
-        from general_manager.permission.managerBasedPermission import (
+        from general_manager.permission.base_permission import BasePermission
+        from general_manager.permission.manager_based_permission import (
             ManagerBasedPermission,
         )
 

general_manager/bucket/{baseBucket.py → base_bucket.py}

@@ -14,10 +14,10 @@ from typing import (
 GeneralManagerType = TypeVar("GeneralManagerType", bound="GeneralManager")
 
 if TYPE_CHECKING:
-    from general_manager.manager.generalManager import GeneralManager
-    from general_manager.manager.groupManager import GroupManager
-    from general_manager.bucket.groupBucket import GroupBucket
-    from general_manager.interface.baseInterface import InterfaceBase
+    from general_manager.manager.general_manager import GeneralManager
+    from general_manager.manager.group_manager import GroupManager
+    from general_manager.bucket.group_bucket import GroupBucket
+    from general_manager.interface.base_interface import InterfaceBase
 
 
 class Bucket(ABC, Generic[GeneralManagerType]):
@@ -243,7 +243,7 @@ class Bucket(ABC, Generic[GeneralManagerType]):
         Returns:
             GroupBucket[GeneralManagerType]: Bucket grouping items by the provided keys.
         """
-        from general_manager.bucket.groupBucket import GroupBucket
+        from general_manager.bucket.group_bucket import GroupBucket
 
         return GroupBucket(self._manager_class, group_by_keys, self)
 

general_manager/bucket/{calculationBucket.py → calculation_bucket.py}

@@ -17,13 +17,13 @@ from typing import (
 )
 from operator import attrgetter
 from copy import deepcopy
-from general_manager.interface.baseInterface import (
+from general_manager.interface.base_interface import (
     generalManagerClassName,
     GeneralManagerType,
 )
-from general_manager.bucket.baseBucket import Bucket
+from general_manager.bucket.base_bucket import Bucket
 from general_manager.manager.input import Input
-from general_manager.utils.filterParser import parse_filters
+from general_manager.utils.filter_parser import parse_filters
 
 if TYPE_CHECKING:
     from general_manager.api.property import GraphQLProperty
@@ -164,7 +164,7 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         Raises:
             InvalidCalculationInterfaceError: If the manager_class.Interface does not inherit from CalculationInterface.
         """
-        from general_manager.interface.calculationInterface import (
+        from general_manager.interface.calculation_interface import (
             CalculationInterface,
         )
 
@@ -181,8 +181,8 @@ class CalculationBucket(Bucket[GeneralManagerType]):
             {} if exclude_definitions is None else exclude_definitions
         )
 
-        properties = self._manager_class.Interface.getGraphQLProperties()
-        possible_values = self.transformPropertiesToInputFields(
+        properties = self._manager_class.Interface.get_graph_ql_properties()
+        possible_values = self.transform_properties_to_input_fields(
             properties, self.input_fields
         )
 
@@ -259,7 +259,7 @@ class CalculationBucket(Bucket[GeneralManagerType]):
             IncompatibleBucketTypeError: If `other` is neither a CalculationBucket nor a compatible manager instance.
             IncompatibleBucketManagerError: If `other` is a CalculationBucket for a different manager class.
         """
-        from general_manager.manager.generalManager import GeneralManager
+        from general_manager.manager.general_manager import GeneralManager
 
         if isinstance(other, GeneralManager) and other.__class__ == self._manager_class:
             return self.__or__(self.filter(id__in=[other.identification]))
@@ -322,7 +322,7 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         return f"{self.__class__.__name__}({self._manager_class.__name__}, {self.filter_definitions}, {self.exclude_definitions}, {self.sort_key}, {self.reverse})"
 
     @staticmethod
-    def transformPropertiesToInputFields(
+    def transform_properties_to_input_fields(
         properties: dict[str, GraphQLProperty], input_fields: dict[str, Input]
     ) -> dict[str, Input]:
         """
@@ -420,7 +420,7 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         for combo in combinations:
             yield self._manager_class(**combo)
 
-    def _sortFilters(self, sorted_inputs: List[str]) -> SortedFilters:
+    def _sort_filters(self, sorted_inputs: List[str]) -> SortedFilters:
         """
         Partition filters into input- and property-based buckets.
 
@@ -467,7 +467,7 @@ class CalculationBucket(Bucket[GeneralManagerType]):
 
         if self._data is None:
             sorted_inputs = self.topological_sort_inputs()
-            sorted_filters = self._sortFilters(sorted_inputs)
+            sorted_filters = self._sort_filters(sorted_inputs)
             current_combinations = self._generate_input_combinations(
                 sorted_inputs,
                 sorted_filters["input_filters"],