GeneralManager 0.19.1__py3-none-any.whl → 0.19.2__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

@@ -8,10 +8,10 @@ from graphene_django.views import GraphQLView  # type: ignore[import]
 from importlib import import_module, util
 import importlib.abc
 import sys
-from general_manager.manager.generalManager import GeneralManager
+from general_manager.manager.general_manager 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.property import graph_ql_property
 from general_manager.api.graphql import GraphQL
 from typing import TYPE_CHECKING, Any, Callable, Type, cast
 from django.core.checks import register
@@ -43,7 +43,7 @@ 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__)
 
@@ -58,16 +58,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,8 +76,8 @@ 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...")
 
@@ -96,7 +96,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 +113,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 +133,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 +141,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`.
 
@@ -159,7 +159,7 @@ class GeneralmanagerConfig(AppConfig):
                     read_only_interface = cast(
                         Type[ReadOnlyInterface], general_manager_class.Interface
                     )
-                    read_only_interface.syncData()
+                    read_only_interface.sync_data()
 
                 logger.debug("finished syncing ReadOnlyInterface data.")
 
@@ -169,14 +169,14 @@ 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.
@@ -206,9 +206,9 @@ class GeneralmanagerConfig(AppConfig):
 
         logger.debug("starting to create attributes for GeneralManager classes...")
         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
             )
 
@@ -226,13 +226,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:
         """
@@ -243,8 +243,8 @@ class GeneralmanagerConfig(AppConfig):
         """
         logger.debug("Starting to create GraphQL interfaces and mutations...")
         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 +279,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.
 
@@ -498,7 +498,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 +510,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"],

general_manager/bucket/{databaseBucket.py → database_bucket.py}

@@ -6,15 +6,12 @@ from typing import TYPE_CHECKING, Any, Generator, Type, TypeVar
 from django.core.exceptions import FieldError
 from django.db import models
 
-from general_manager.bucket.baseBucket import Bucket
-from general_manager.interface.baseInterface import GeneralManagerType
-from general_manager.manager.generalManager import GeneralManager
-from general_manager.utils.filterParser import create_filter_function
+from general_manager.bucket.base_bucket import Bucket
+from general_manager.manager.general_manager import GeneralManager
+from general_manager.utils.filter_parser import create_filter_function
 
 modelsModel = TypeVar("modelsModel", bound=models.Model)
-
-if TYPE_CHECKING:
-    from general_manager.interface.databaseInterface import DatabaseInterface
+GeneralManagerType = TypeVar("GeneralManagerType", bound=GeneralManager)
 
 
 class DatabaseBucketTypeMismatchError(TypeError):
@@ -189,7 +186,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             {},
         )
 
-    def __mergeFilterDefinitions(
+    def __merge_filter_definitions(
         self, basis: dict[str, list[Any]], **kwargs: Any
     ) -> dict[str, list[Any]]:
         """
@@ -211,7 +208,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             kwarg_filter[key].append(value)
         return kwarg_filter
 
-    def __parseFilterDeifintions(
+    def __parse_filter_definitions(
         self,
         **kwargs: Any,
     ) -> tuple[dict[str, Any], dict[str, Any], list[tuple[str, Any, str]]]:
@@ -233,7 +230,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         annotations: dict[str, Any] = {}
         orm_kwargs: dict[str, Any] = {}
         python_filters: list[tuple[str, Any, str]] = []
-        properties = self._manager_class.Interface.getGraphQLProperties()
+        properties = self._manager_class.Interface.get_graph_ql_properties()
 
         for k, v in kwargs.items():
             root = k.split("__")[0]
@@ -251,7 +248,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
 
         return annotations, orm_kwargs, python_filters
 
-    def __parsePythonFilters(
+    def __parse_python_filters(
         self, query_set: models.QuerySet, python_filters: list[tuple[str, Any, str]]
     ) -> list[int]:
         """
@@ -293,7 +290,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             InvalidQueryAnnotationTypeError: If a query-annotation callback returns a non-QuerySet.
             QuerysetFilteringError: If the ORM rejects the filter arguments or filtering fails.
         """
-        annotations, orm_kwargs, python_filters = self.__parseFilterDeifintions(
+        annotations, orm_kwargs, python_filters = self.__parse_filter_definitions(
             **kwargs
         )
         qs = self._data
@@ -313,10 +310,10 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             raise QuerysetFilteringError(error) from error
 
         if python_filters:
-            ids = self.__parsePythonFilters(qs, python_filters)
+            ids = self.__parse_python_filters(qs, python_filters)
             qs = qs.filter(pk__in=ids)
 
-        merged_filter = self.__mergeFilterDefinitions(self.filters, **kwargs)
+        merged_filter = self.__merge_filter_definitions(self.filters, **kwargs)
         return self.__class__(qs, self._manager_class, merged_filter, self.excludes)
 
     def exclude(self, **kwargs: Any) -> DatabaseBucket[GeneralManagerType]:
@@ -334,7 +331,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         Raises:
             InvalidQueryAnnotationTypeError: If an annotation callable is applied and does not return a Django QuerySet.
         """
-        annotations, orm_kwargs, python_filters = self.__parseFilterDeifintions(
+        annotations, orm_kwargs, python_filters = self.__parse_filter_definitions(
             **kwargs
         )
         qs = self._data
@@ -351,10 +348,10 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         qs = qs.exclude(**orm_kwargs)
 
         if python_filters:
-            ids = self.__parsePythonFilters(qs, python_filters)
+            ids = self.__parse_python_filters(qs, python_filters)
             qs = qs.exclude(pk__in=ids)
 
-        merged_exclude = self.__mergeFilterDefinitions(self.excludes, **kwargs)
+        merged_exclude = self.__merge_filter_definitions(self.excludes, **kwargs)
         return self.__class__(qs, self._manager_class, self.filters, merged_exclude)
 
     def first(self) -> GeneralManagerType | None:
@@ -467,7 +464,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         Returns:
             bool: True when the primary key exists in the queryset.
         """
-        from general_manager.manager.generalManager import GeneralManager
+        from general_manager.manager.general_manager import GeneralManager
 
         if isinstance(item, GeneralManager):
             return item.identification.get("id", None) in self._data.values_list(
@@ -499,7 +496,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         """
         if isinstance(key, str):
             key = (key,)
-        properties = self._manager_class.Interface.getGraphQLProperties()
+        properties = self._manager_class.Interface.get_graph_ql_properties()
         annotations: dict[str, Any] = {}
         python_keys: list[str] = []
         qs = self._data

general_manager/bucket/{groupBucket.py → group_bucket.py}

@@ -2,8 +2,8 @@
 
 from __future__ import annotations
 from typing import Any, Generator, Type
-from general_manager.manager.groupManager import GroupManager
-from general_manager.bucket.baseBucket import Bucket, GeneralManagerType
+from general_manager.manager.group_manager import GroupManager
+from general_manager.bucket.base_bucket import Bucket, GeneralManagerType
 
 
 class InvalidGroupByKeyTypeError(TypeError):
@@ -132,10 +132,10 @@ class GroupBucket(Bucket[GeneralManagerType]):
             ValueError: If a group-by key is not a valid manager attribute.
         """
         super().__init__(manager_class)
-        self.__checkGroupByArguments(group_by_keys)
+        self.__check_group_by_arguments(group_by_keys)
         self._group_by_keys = group_by_keys
-        self._data: list[GroupManager[GeneralManagerType]] = self.__buildGroupedManager(
-            data
+        self._data: list[GroupManager[GeneralManagerType]] = (
+            self.__build_grouped_manager(data)
         )
         self._basis_data: Bucket[GeneralManagerType] = data
 
@@ -157,7 +157,7 @@ class GroupBucket(Bucket[GeneralManagerType]):
             and self._group_by_keys == other._group_by_keys
         )
 
-    def __checkGroupByArguments(self, group_by_keys: tuple[str, ...]) -> None:
+    def __check_group_by_arguments(self, group_by_keys: tuple[str, ...]) -> None:
         """
         Validate that each provided group-by key is a string and is exposed by the manager interface.
 
@@ -171,12 +171,12 @@ class GroupBucket(Bucket[GeneralManagerType]):
         if not all(isinstance(arg, str) for arg in group_by_keys):
             raise InvalidGroupByKeyTypeError()
         if not all(
-            arg in self._manager_class.Interface.getAttributes()
+            arg in self._manager_class.Interface.get_attributes()
             for arg in group_by_keys
         ):
             raise UnknownGroupByKeyError(self._manager_class.__name__)
 
-    def __buildGroupedManager(
+    def __build_grouped_manager(
         self,
         data: Bucket[GeneralManagerType],
     ) -> list[GroupManager[GeneralManagerType]]:

general_manager/cache/{cacheDecorator.py → cache_decorator.py}

@@ -3,10 +3,10 @@
 from typing import Any, Callable, Optional, Protocol, Set, TypeVar, cast
 from functools import wraps
 from django.core.cache import cache as django_cache
-from general_manager.cache.cacheTracker import DependencyTracker
-from general_manager.cache.dependencyIndex import record_dependencies, Dependency
-from general_manager.cache.modelDependencyCollector import ModelDependencyCollector
-from general_manager.utils.makeCacheKey import make_cache_key
+from general_manager.cache.cache_tracker import DependencyTracker
+from general_manager.cache.dependency_index import record_dependencies, Dependency
+from general_manager.cache.model_dependency_collector import ModelDependencyCollector
+from general_manager.utils.make_cache_key import make_cache_key
 
 
 class CacheBackend(Protocol):
@@ -78,7 +78,7 @@ def cached(
 
             with DependencyTracker() as dependencies:
                 result = func(*args, **kwargs)
-                ModelDependencyCollector.addArgs(dependencies, args, kwargs)
+                ModelDependencyCollector.add_args(dependencies, args, kwargs)
 
                 cache_backend.set(key, result, timeout)
                 cache_backend.set(deps_key, dependencies, timeout)

general_manager/cache/{cacheTracker.py → cache_tracker.py}

@@ -3,7 +3,7 @@
 import threading
 from types import TracebackType
 
-from general_manager.cache.dependencyIndex import (
+from general_manager.cache.dependency_index import (
     Dependency,
     filter_type,
     general_manager_name,

general_manager/cache/{dependencyIndex.py → dependency_index.py}

@@ -13,7 +13,7 @@ from django.dispatch import receiver
 from typing import Literal, Any, Iterable, TYPE_CHECKING, Type, Tuple, cast
 
 if TYPE_CHECKING:
-    from general_manager.manager.generalManager import GeneralManager
+    from general_manager.manager.general_manager import GeneralManager
 
 type general_manager_name = str  # e.g. "Project", "Derivative", "User"
 type attribute = str  # e.g. "field", "name", "id"

general_manager/cache/{modelDependencyCollector.py → model_dependency_collector.py}

@@ -1,9 +1,9 @@
 """Helpers that derive cache dependency metadata from GeneralManager objects."""
 
 from typing import Generator
-from general_manager.manager.generalManager import GeneralManager
-from general_manager.bucket.baseBucket import Bucket
-from general_manager.cache.dependencyIndex import (
+from general_manager.manager.general_manager import GeneralManager
+from general_manager.bucket.base_bucket import Bucket
+from general_manager.cache.dependency_index import (
     general_manager_name,
     Dependency,
     filter_type,
@@ -43,7 +43,7 @@ class ModelDependencyCollector:
                 yield from ModelDependencyCollector.collect(item)
 
     @staticmethod
-    def addArgs(dependencies: set[Dependency], args: tuple, kwargs: dict) -> None:
+    def add_args(dependencies: set[Dependency], args: tuple, kwargs: dict) -> None:
         """
         Enrich the dependency set with values discovered in positional and keyword arguments.
 

general_manager/cache/signals.py

@@ -13,7 +13,7 @@ P = ParamSpec("P")
 R = TypeVar("R")
 
 
-def dataChange(func: Callable[P, R]) -> Callable[P, R]:
+def data_change(func: Callable[P, R]) -> Callable[P, R]:
     """
     Wrap a data-modifying function with pre- and post-change signal dispatching.