GeneralManager 0.19.0__py3-none-any.whl → 0.19.2__py3-none-any.whl

general_manager/interface/{databaseBasedInterface.py → database_based_interface.py}

@@ -7,10 +7,10 @@ from django.db import models
 from datetime import datetime, date, time, timedelta
 from django.utils import timezone
 from general_manager.measurement.measurement import Measurement
-from general_manager.measurement.measurementField import MeasurementField
+from general_manager.measurement.measurement_field import MeasurementField
 from decimal import Decimal
-from general_manager.factory.autoFactory import AutoFactory
-from general_manager.interface.baseInterface import (
+from general_manager.factory.auto_factory import AutoFactory
+from general_manager.interface.base_interface import (
     InterfaceBase,
     classPostCreationMethod,
     classPreCreationMethod,
@@ -23,11 +23,11 @@ from general_manager.interface.baseInterface import (
     AttributeTypedDict,
 )
 from general_manager.manager.input import Input
-from general_manager.bucket.databaseBucket import DatabaseBucket
+from general_manager.bucket.database_bucket import DatabaseBucket
 from general_manager.interface.models import (
     GeneralManagerBasisModel,
     GeneralManagerModel,
-    getFullCleanMethode,
+    get_full_clean_methode,
 )
 from django.contrib.contenttypes.fields import GenericForeignKey
 
@@ -76,9 +76,9 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         """
         super().__init__(*args, **kwargs)
         self.pk = self.identification["id"]
-        self._instance: MODEL_TYPE = self.getData(search_date)
+        self._instance: MODEL_TYPE = self.get_data(search_date)
 
-    def getData(self, search_date: datetime | None = None) -> MODEL_TYPE:
+    def get_data(self, search_date: datetime | None = None) -> MODEL_TYPE:
         """
         Fetch the underlying model instance, optionally as of a historical date.
 
@@ -95,13 +95,13 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
             if timezone.is_naive(search_date):
                 search_date = timezone.make_aware(search_date)
             if search_date <= timezone.now() - timedelta(seconds=5):
-                historical = self.getHistoricalRecord(instance, search_date)
+                historical = self.get_historical_record(instance, search_date)
                 if historical is not None:
                     instance = historical
         return instance
 
     @staticmethod
-    def __parseKwargs(**kwargs: Any) -> dict[str, Any]:
+    def __parse_kwargs(**kwargs: Any) -> dict[str, Any]:
         """
         Convert keyword arguments into ORM-friendly values.
 
@@ -111,7 +111,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         Returns:
             dict[str, Any]: Arguments ready to be passed to Django ORM methods.
         """
-        from general_manager.manager.generalManager import GeneralManager
+        from general_manager.manager.general_manager import GeneralManager
 
         parsed_kwargs: dict[str, Any] = {}
         for key, value in kwargs.items():
@@ -135,12 +135,12 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
             DatabaseBucket: Bucket wrapping the filtered queryset.
         """
 
-        kwargs = cls.__parseKwargs(**kwargs)
+        kwargs = cls.__parse_kwargs(**kwargs)
 
         return DatabaseBucket(
             cls._model.objects.filter(**kwargs),
             cls._parent_class,
-            cls.__createFilterDefinitions(**kwargs),
+            cls.__create_filter_definitions(**kwargs),
         )
 
     @classmethod
@@ -154,16 +154,16 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         Returns:
             DatabaseBucket: Bucket wrapping the excluded queryset.
         """
-        kwargs = cls.__parseKwargs(**kwargs)
+        kwargs = cls.__parse_kwargs(**kwargs)
 
         return DatabaseBucket(
             cls._model.objects.exclude(**kwargs),
             cls._parent_class,
-            cls.__createFilterDefinitions(**kwargs),
+            cls.__create_filter_definitions(**kwargs),
         )
 
     @staticmethod
-    def __createFilterDefinitions(**kwargs: Any) -> dict[str, Any]:
+    def __create_filter_definitions(**kwargs: Any) -> dict[str, Any]:
         """
         Build a filter-definition mapping from Django-style kwargs.
 
@@ -179,7 +179,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         return filter_definitions
 
     @classmethod
-    def getHistoricalRecord(
+    def get_historical_record(
         cls, instance: MODEL_TYPE, search_date: datetime | None = None
     ) -> MODEL_TYPE | None:
         """
@@ -196,7 +196,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         return cast(MODEL_TYPE | None, historical)
 
     @classmethod
-    def getAttributeTypes(cls) -> dict[str, AttributeTypedDict]:
+    def get_attribute_types(cls) -> dict[str, AttributeTypedDict]:
         """
         Builds a mapping of model attribute names to their type metadata for the interface.
 
@@ -232,7 +232,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
             models.TimeField: datetime,
         }
         fields: dict[str, AttributeTypedDict] = {}
-        field_name_list, to_ignore_list = cls.handleCustomFields(cls._model)
+        field_name_list, to_ignore_list = cls.handle_custom_fields(cls._model)
         for field_name in field_name_list:
             field = cast(models.Field, getattr(cls._model, field_name))
             fields[field_name] = {
@@ -243,7 +243,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                 "default": field.default,
             }
 
-        for field_name in cls.__getModelFields():
+        for field_name in cls.__get_model_fields():
             if field_name not in to_ignore_list:
                 field = cast(models.Field, getattr(cls._model, field_name).field)
                 fields[field_name] = {
@@ -255,7 +255,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                     "default": field.default,
                 }
 
-        for field_name in cls.__getForeignKeyFields():
+        for field_name in cls.__get_foreign_key_fields():
             field = cls._model._meta.get_field(field_name)
             if isinstance(field, GenericForeignKey):
                 continue
@@ -281,8 +281,8 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                 }
 
         for field_name, field_call in [
-            *cls.__getManyToManyFields(),
-            *cls.__getReverseRelations(),
+            *cls.__get_many_to_many_fields(),
+            *cls.__get_reverse_relations(),
         ]:
             if field_name in fields:
                 if field_call not in fields:
@@ -317,7 +317,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         }
 
     @classmethod
-    def getAttributes(cls) -> dict[str, Callable[[DBBasedInterface], Any]]:
+    def get_attributes(cls) -> dict[str, Callable[[DBBasedInterface], Any]]:
         """
         Builds a mapping of attribute names to accessor callables for a DBBasedInterface instance.
 
@@ -329,23 +329,23 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         Raises:
             DuplicateFieldNameError: If a generated attribute name conflicts with an existing attribute name.
         """
-        from general_manager.manager.generalManager import GeneralManager
+        from general_manager.manager.general_manager import GeneralManager
 
         field_values: dict[str, Any] = {}
 
-        field_name_list, to_ignore_list = cls.handleCustomFields(cls._model)
+        field_name_list, to_ignore_list = cls.handle_custom_fields(cls._model)
         for field_name in field_name_list:
             field_values[field_name] = lambda self, field_name=field_name: getattr(
                 self._instance, field_name
             )
 
-        for field_name in cls.__getModelFields():
+        for field_name in cls.__get_model_fields():
             if field_name not in to_ignore_list:
                 field_values[field_name] = lambda self, field_name=field_name: getattr(
                     self._instance, field_name
                 )
 
-        for field_name in cls.__getForeignKeyFields():
+        for field_name in cls.__get_foreign_key_fields():
             related_model = cls._model._meta.get_field(field_name).related_model
             if related_model and hasattr(
                 related_model,
@@ -371,8 +371,8 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                 )
 
         for field_name, field_call in [
-            *cls.__getManyToManyFields(),
-            *cls.__getReverseRelations(),
+            *cls.__get_many_to_many_fields(),
+            *cls.__get_reverse_relations(),
         ]:
             if field_name in field_values:
                 if field_call not in field_values:
@@ -415,7 +415,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         return field_values
 
     @staticmethod
-    def handleCustomFields(
+    def handle_custom_fields(
         model: Type[models.Model] | models.Model,
     ) -> tuple[list[str], list[str]]:
         """
@@ -429,7 +429,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         """
         field_name_list: list[str] = []
         to_ignore_list: list[str] = []
-        for field_name in DBBasedInterface._getCustomFields(model):
+        for field_name in DBBasedInterface._get_custom_fields(model):
             to_ignore_list.append(f"{field_name}_value")
             to_ignore_list.append(f"{field_name}_unit")
             field_name_list.append(field_name)
@@ -437,7 +437,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         return field_name_list, to_ignore_list
 
     @staticmethod
-    def _getCustomFields(model: Type[models.Model] | models.Model) -> list[str]:
+    def _get_custom_fields(model: Type[models.Model] | models.Model) -> list[str]:
         """
         Return names of fields declared directly on the model class.
 
@@ -454,7 +454,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         ]
 
     @classmethod
-    def __getModelFields(cls) -> list[str]:
+    def __get_model_fields(cls) -> list[str]:
         """Return names of non-relational fields defined on the model."""
         return [
             field.name
@@ -463,7 +463,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         ]
 
     @classmethod
-    def __getForeignKeyFields(cls) -> list[str]:
+    def __get_foreign_key_fields(cls) -> list[str]:
         """Return names of foreign-key and one-to-one relations on the model."""
         return [
             field.name
@@ -472,7 +472,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         ]
 
     @classmethod
-    def __getManyToManyFields(cls) -> list[tuple[str, str]]:
+    def __get_many_to_many_fields(cls) -> list[tuple[str, str]]:
         """Return (field_name, accessor_name) tuples for many-to-many fields."""
         return [
             (field.name, field.name)
@@ -481,7 +481,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         ]
 
     @classmethod
-    def __getReverseRelations(cls) -> list[tuple[str, str]]:
+    def __get_reverse_relations(cls) -> list[tuple[str, str]]:
         """Return (field_name, accessor_name) tuples for reverse one-to-many relations."""
         return [
             (field.name, f"{field.name}_set")
@@ -490,7 +490,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         ]
 
     @staticmethod
-    def _preCreate(
+    def _pre_create(
         name: generalManagerClassName,
         attrs: attributes,
         interface: interfaceBaseClass,
@@ -539,7 +539,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         if meta_class and rules:
             model._meta.rules = rules  # type: ignore[attr-defined]
             # add full_clean method
-            model.full_clean = getFullCleanMethode(model)  # type: ignore[assignment]
+            model.full_clean = get_full_clean_methode(model)  # type: ignore[assignment]
         # Determine interface type
         attrs["_interface_type"] = interface._interface_type
         interface_cls = type(interface.__name__, (interface,), {})
@@ -562,7 +562,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         return attrs, interface_cls, model
 
     @staticmethod
-    def _postCreate(
+    def _post_create(
         new_class: newlyCreatedGeneralManagerClass,
         interface_class: newlyCreatedInterfaceClass,
         model: relatedClass,
@@ -581,7 +581,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         model._general_manager_class = new_class  # type: ignore
 
     @classmethod
-    def handleInterface(
+    def handle_interface(
         cls,
     ) -> tuple[classPreCreationMethod, classPostCreationMethod]:
         """
@@ -590,10 +590,10 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         Returns:
             tuple[classPreCreationMethod, classPostCreationMethod]: A pair (pre_create, post_create) where `pre_create` is invoked before the manager class is created to allow customization, and `post_create` is invoked after creation to finalize setup.
         """
-        return cls._preCreate, cls._postCreate
+        return cls._pre_create, cls._post_create
 
     @classmethod
-    def getFieldType(cls, field_name: str) -> type:
+    def get_field_type(cls, field_name: str) -> type:
         """
         Return the type associated with a given model field name.
 

general_manager/interface/{databaseInterface.py → database_interface.py}

@@ -8,7 +8,7 @@ from typing import (
 )
 from django.db import models, transaction
 from simple_history.utils import update_change_reason  # type: ignore
-from general_manager.interface.databaseBasedInterface import (
+from general_manager.interface.database_based_interface import (
     DBBasedInterface,
     GeneralManagerModel,
 )
@@ -86,11 +86,11 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
             ValidationError: If model validation fails during save.
         """
         model_cls = cast(type[GeneralManagerModel], cls._model)
-        cls._checkForInvalidKwargs(model_cls, kwargs=kwargs)
-        kwargs, many_to_many_kwargs = cls._sortKwargs(model_cls, kwargs)
-        instance = cls.__setAttrForWrite(model_cls(), kwargs)
+        cls._check_for_invalid_kwargs(model_cls, kwargs=kwargs)
+        kwargs, many_to_many_kwargs = cls._sort_kwargs(model_cls, kwargs)
+        instance = cls.__set_attr_for_write(model_cls(), kwargs)
         pk = cls._save_with_history(instance, creator_id, history_comment)
-        cls.__setManyToManyAttributes(instance, many_to_many_kwargs)
+        cls.__set_many_to_many_attributes(instance, many_to_many_kwargs)
         return pk
 
     def update(
@@ -112,11 +112,11 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
             ValidationError: If model validation fails during save.
         """
         model_cls = cast(type[GeneralManagerModel], self._model)
-        self._checkForInvalidKwargs(model_cls, kwargs=kwargs)
-        kwargs, many_to_many_kwargs = self._sortKwargs(model_cls, kwargs)
-        instance = self.__setAttrForWrite(model_cls.objects.get(pk=self.pk), kwargs)
+        self._check_for_invalid_kwargs(model_cls, kwargs=kwargs)
+        kwargs, many_to_many_kwargs = self._sort_kwargs(model_cls, kwargs)
+        instance = self.__set_attr_for_write(model_cls.objects.get(pk=self.pk), kwargs)
         pk = self._save_with_history(instance, creator_id, history_comment)
-        self.__setManyToManyAttributes(instance, many_to_many_kwargs)
+        self.__set_many_to_many_attributes(instance, many_to_many_kwargs)
         return pk
 
     def deactivate(
@@ -142,7 +142,7 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         return self._save_with_history(instance, creator_id, history_comment)
 
     @staticmethod
-    def __setManyToManyAttributes(
+    def __set_many_to_many_attributes(
         instance: GeneralManagerModel, many_to_many_kwargs: dict[str, list[Any]]
     ) -> GeneralManagerModel:
         """
@@ -155,7 +155,7 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         Returns:
             GeneralManagerModel: Updated instance.
         """
-        from general_manager.manager.generalManager import GeneralManager
+        from general_manager.manager.general_manager import GeneralManager
 
         for key, value in many_to_many_kwargs.items():
             if value is None or value is NOT_PROVIDED:
@@ -173,7 +173,7 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         return instance
 
     @staticmethod
-    def __setAttrForWrite(
+    def __set_attr_for_write(
         instance: GeneralManagerModel,
         kwargs: dict[str, Any],
     ) -> GeneralManagerModel:
@@ -193,7 +193,7 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
             InvalidFieldValueError: If setting an attribute raises a `ValueError`.
             InvalidFieldTypeError: If setting an attribute raises a `TypeError`.
         """
-        from general_manager.manager.generalManager import GeneralManager
+        from general_manager.manager.general_manager import GeneralManager
 
         for key, value in kwargs.items():
             if isinstance(value, GeneralManager):
@@ -210,7 +210,7 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         return instance
 
     @staticmethod
-    def _checkForInvalidKwargs(
+    def _check_for_invalid_kwargs(
         model: Type[models.Model], kwargs: dict[str, Any]
     ) -> None:
         """
@@ -231,7 +231,7 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
                 raise UnknownFieldError(key, model.__name__)
 
     @staticmethod
-    def _sortKwargs(
+    def _sort_kwargs(
         model: Type[models.Model], kwargs: dict[Any, Any]
     ) -> tuple[dict[str, Any], dict[str, list[Any]]]:
         """

general_manager/interface/models.py

@@ -10,13 +10,13 @@ from django.core.exceptions import ValidationError
 
 
 if TYPE_CHECKING:
-    from general_manager.manager.generalManager import GeneralManager
+    from general_manager.manager.general_manager import GeneralManager
     from general_manager.rule.rule import Rule
 
 modelsModel = TypeVar("modelsModel", bound=models.Model)
 
 
-def getFullCleanMethode(model: Type[models.Model]) -> Callable[..., None]:
+def get_full_clean_methode(model: Type[models.Model]) -> Callable[..., None]:
     """
     Return a custom `full_clean` method for a Django model that performs both standard validation and additional rule-based checks.
 
@@ -44,7 +44,7 @@ def getFullCleanMethode(model: Type[models.Model]) -> Callable[..., None]:
         rules: list[Rule] = getattr(self._meta, "rules", [])
         for rule in rules:
             if rule.evaluate(self) is False:
-                error_message = rule.getErrorMessage()
+                error_message = rule.get_error_message()
                 if error_message:
                     errors.update(error_message)
 

general_manager/interface/{readOnlyInterface.py → read_only_interface.py}

@@ -5,7 +5,7 @@ import json
 
 from typing import Type, Any, Callable, TYPE_CHECKING, cast, ClassVar
 from django.db import models, transaction
-from general_manager.interface.databaseBasedInterface import (
+from general_manager.interface.database_based_interface import (
     DBBasedInterface,
     GeneralManagerBasisModel,
     classPreCreationMethod,
@@ -19,7 +19,7 @@ from django.core.checks import Warning
 import logging
 
 if TYPE_CHECKING:
-    from general_manager.manager.generalManager import GeneralManager
+    from general_manager.manager.general_manager import GeneralManager
 
 
 logger = logging.getLogger(__name__)
@@ -86,7 +86,7 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
     _parent_class: ClassVar[Type["GeneralManager"]]
 
     @staticmethod
-    def getUniqueFields(model: Type[models.Model]) -> set[str]:
+    def get_unique_fields(model: Type[models.Model]) -> set[str]:
         """
         Determine which fields on the given Django model uniquely identify its instances.
 
@@ -117,7 +117,7 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
         return unique_fields
 
     @classmethod
-    def syncData(cls) -> None:
+    def sync_data(cls) -> None:
         """
         Synchronize the Django model with the parent manager's class-level `_data` JSON.
 
@@ -129,7 +129,7 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
             InvalidReadOnlyDataTypeError: If `_data` is neither a string nor a list.
             MissingUniqueFieldError: If the model exposes no unique fields to identify records.
         """
-        if cls.ensureSchemaIsUpToDate(cls._parent_class, cls._model):
+        if cls.ensure_schema_is_up_to_date(cls._parent_class, cls._model):
             logger.warning(
                 f"Schema for ReadOnlyInterface '{cls._parent_class.__name__}' is not up to date."
             )
@@ -153,7 +153,7 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
 
         data_list = cast(list[dict[str, Any]], parsed_data)
 
-        unique_fields = cls.getUniqueFields(model)
+        unique_fields = cls.get_unique_fields(model)
         if not unique_fields:
             raise MissingUniqueFieldError(parent_class.__name__)
 
@@ -215,7 +215,7 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
             )
 
     @staticmethod
-    def ensureSchemaIsUpToDate(
+    def ensure_schema_is_up_to_date(
         new_manager_class: Type[GeneralManager], model: Type[models.Model]
     ) -> list[Warning]:
         """
@@ -286,7 +286,7 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
         return []
 
     @staticmethod
-    def readOnlyPostCreate(func: Callable[..., Any]) -> Callable[..., Any]:
+    def read_only_post_create(func: Callable[..., Any]) -> Callable[..., Any]:
         """
         Decorator for post-creation hooks that registers a new manager class as read-only.
 
@@ -311,7 +311,7 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
         return wrapper
 
     @staticmethod
-    def readOnlyPreCreate(func: Callable[..., Any]) -> Callable[..., Any]:
+    def read_only_pre_create(func: Callable[..., Any]) -> Callable[..., Any]:
         """
         Decorator for pre-creation hook functions that ensures the base model class is set to `GeneralManagerBasisModel`.
 
@@ -344,7 +344,7 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
         return wrapper
 
     @classmethod
-    def handleInterface(cls) -> tuple[classPreCreationMethod, classPostCreationMethod]:
+    def handle_interface(cls) -> tuple[classPreCreationMethod, classPostCreationMethod]:
         """
         Return the pre- and post-creation hook methods for integrating the interface with a manager meta-class system.
 
@@ -355,6 +355,6 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
         Returns:
             tuple: The pre-creation and post-creation hook methods for manager class lifecycle integration.
         """
-        return cls.readOnlyPreCreate(cls._preCreate), cls.readOnlyPostCreate(
-            cls._postCreate
+        return cls.read_only_pre_create(cls._pre_create), cls.read_only_post_create(
+            cls._post_create
         )

general_manager/manager/{generalManager.py → general_manager.py}

@@ -3,9 +3,9 @@ from typing import TYPE_CHECKING, Any, Iterator, Self, Type
 from general_manager.manager.meta import GeneralManagerMeta
 
 from general_manager.api.property import GraphQLProperty
-from general_manager.cache.cacheTracker import DependencyTracker
-from general_manager.cache.signals import dataChange
-from general_manager.bucket.baseBucket import Bucket
+from general_manager.cache.cache_tracker import DependencyTracker
+from general_manager.cache.signals import data_change
+from general_manager.bucket.base_bucket import Bucket
 
 
 class UnsupportedUnionOperandError(TypeError):
@@ -22,8 +22,8 @@ class UnsupportedUnionOperandError(TypeError):
 
 
 if TYPE_CHECKING:
-    from general_manager.permission.basePermission import BasePermission
-    from general_manager.interface.baseInterface import InterfaceBase
+    from general_manager.permission.base_permission import BasePermission
+    from general_manager.interface.base_interface import InterfaceBase
 
 
 class GeneralManager(metaclass=GeneralManagerMeta):
@@ -117,7 +117,7 @@ class GeneralManager(metaclass=GeneralManagerMeta):
                 yield name, getattr(self, name)
 
     @classmethod
-    @dataChange
+    @data_change
     def create(
         cls,
         creator_id: int | None = None,
@@ -141,13 +141,13 @@ class GeneralManager(metaclass=GeneralManagerMeta):
             PermissionError: Propagated if the permission check fails.
         """
         if not ignore_permission:
-            cls.Permission.checkCreatePermission(kwargs, cls, creator_id)
+            cls.Permission.check_create_permission(kwargs, cls, creator_id)
         identification = cls.Interface.create(
             creator_id=creator_id, history_comment=history_comment, **kwargs
         )
         return cls(identification)
 
-    @dataChange
+    @data_change
     def update(
         self,
         creator_id: int | None = None,
@@ -171,7 +171,7 @@ class GeneralManager(metaclass=GeneralManagerMeta):
             PermissionError: Propagated if the permission check fails.
         """
         if not ignore_permission:
-            self.Permission.checkUpdatePermission(kwargs, self, creator_id)
+            self.Permission.check_update_permission(kwargs, self, creator_id)
         self._interface.update(
             creator_id=creator_id,
             history_comment=history_comment,
@@ -179,7 +179,7 @@ class GeneralManager(metaclass=GeneralManagerMeta):
         )
         return self.__class__(**self.identification)
 
-    @dataChange
+    @data_change
     def deactivate(
         self,
         creator_id: int | None = None,
@@ -201,7 +201,7 @@ class GeneralManager(metaclass=GeneralManagerMeta):
             PermissionError: Propagated if the permission check fails.
         """
         if not ignore_permission:
-            self.Permission.checkDeletePermission(self, creator_id)
+            self.Permission.check_delete_permission(self, creator_id)
         self._interface.deactivate(
             creator_id=creator_id, history_comment=history_comment
         )

general_manager/manager/{groupManager.py → group_manager.py}

@@ -5,8 +5,8 @@ from typing import Any, Generic, Iterator, Type, cast, get_args
 from datetime import datetime, date, time
 from general_manager.api.property import GraphQLProperty
 from general_manager.measurement import Measurement
-from general_manager.manager.generalManager import GeneralManager
-from general_manager.bucket.baseBucket import (
+from general_manager.manager.general_manager import GeneralManager
+from general_manager.bucket.base_bucket import (
     Bucket,
     GeneralManagerType,
 )
@@ -99,7 +99,7 @@ class GroupManager(Generic[GeneralManagerType]):
         Yields:
             tuple[str, Any]: Attribute name and aggregated value pairs.
         """
-        for attribute in self._manager_class.Interface.getAttributes().keys():
+        for attribute in self._manager_class.Interface.get_attributes().keys():
             yield attribute, getattr(self, attribute)
         for attribute, attr_value in self._manager_class.__dict__.items():
             if isinstance(attr_value, GraphQLProperty):
@@ -121,10 +121,10 @@ class GroupManager(Generic[GeneralManagerType]):
         if item in self._group_by_value:
             return self._group_by_value[item]
         if item not in self._grouped_data.keys():
-            self._grouped_data[item] = self.combineValue(item)
+            self._grouped_data[item] = self.combine_value(item)
         return self._grouped_data[item]
 
-    def combineValue(self, item: str) -> Any:
+    def combine_value(self, item: str) -> Any:
         """
         Aggregate the values of a named attribute across all records in the group.
 
@@ -140,7 +140,7 @@ class GroupManager(Generic[GeneralManagerType]):
         if item == "id":
             return None
 
-        attribute_types = self._manager_class.Interface.getAttributeTypes()
+        attribute_types = self._manager_class.Interface.get_attribute_types()
         attr_info = attribute_types.get(item)
         data_type = attr_info["type"] if attr_info else None
         if data_type is None and item in self._manager_class.__dict__:

general_manager/manager/input.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 from typing import Iterable, Optional, Callable, List, TypeVar, Generic, Any, Type, cast
 import inspect
 
-from general_manager.manager.generalManager import GeneralManager
+from general_manager.manager.general_manager import GeneralManager
 from datetime import date, datetime
 from general_manager.measurement import Measurement