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

general_manager/factory/{factoryMethods.py → factory_methods.py}

@@ -17,7 +17,7 @@ _AVG_DELTA_DAYS_ERROR = "avg_delta_days must be >= 0"
 _EMPTY_OPTIONS_ERROR = "options must be a non-empty list"
 
 
-def LazyMeasurement(
+def lazy_measurement(
     min_value: int | float, max_value: int | float, unit: str
 ) -> LazyFunction:
     """
@@ -36,7 +36,7 @@ def LazyMeasurement(
     )
 
 
-def LazyDeltaDate(avg_delta_days: int, base_attribute: str) -> LazyAttribute:
+def lazy_delta_date(avg_delta_days: int, base_attribute: str) -> LazyAttribute:
     """
     Compute a date by offsetting an instance's base date attribute by a randomized number of days.
 
@@ -60,7 +60,7 @@ def LazyDeltaDate(avg_delta_days: int, base_attribute: str) -> LazyAttribute:
     )
 
 
-def LazyProjectName() -> LazyFunction:
+def lazy_project_name() -> LazyFunction:
     """Return a lazy factory producing a pseudo-random project-style name."""
     return LazyFunction(
         lambda: (
@@ -72,12 +72,12 @@ def LazyProjectName() -> LazyFunction:
     )
 
 
-def LazyDateToday() -> LazyFunction:
+def lazy_date_today() -> LazyFunction:
     """Return a lazy factory that yields today's date."""
     return LazyFunction(lambda: date.today())
 
 
-def LazyDateBetween(start_date: date, end_date: date) -> LazyAttribute:
+def lazy_date_between(start_date: date, end_date: date) -> LazyAttribute:
     """
     Produce a lazy attribute that yields a date between two given dates (inclusive).
 
@@ -95,7 +95,7 @@ def LazyDateBetween(start_date: date, end_date: date) -> LazyAttribute:
     return LazyAttribute(lambda _: start_date + timedelta(days=_RNG.randint(0, delta)))
 
 
-def LazyDateTimeBetween(start: datetime, end: datetime) -> LazyAttribute:
+def lazy_date_time_between(start: datetime, end: datetime) -> LazyAttribute:
     """
     Produce a lazy attribute that yields a datetime within the inclusive range defined by `start` and `end`.
 
@@ -117,7 +117,7 @@ def LazyDateTimeBetween(start: datetime, end: datetime) -> LazyAttribute:
     )
 
 
-def LazyInteger(min_value: int, max_value: int) -> LazyFunction:
+def lazy_integer(min_value: int, max_value: int) -> LazyFunction:
     """
     Return a lazy factory that produces an integer within the provided bounds.
 
@@ -131,7 +131,9 @@ def LazyInteger(min_value: int, max_value: int) -> LazyFunction:
     return LazyFunction(lambda: _RNG.randint(min_value, max_value))
 
 
-def LazyDecimal(min_value: float, max_value: float, precision: int = 2) -> LazyFunction:
+def lazy_decimal(
+    min_value: float, max_value: float, precision: int = 2
+) -> LazyFunction:
     """
     Create a lazy factory that produces Decimal values between min_value and max_value, rounded to the specified precision.
 
@@ -147,7 +149,7 @@ def LazyDecimal(min_value: float, max_value: float, precision: int = 2) -> LazyF
     return LazyFunction(lambda: Decimal(fmt.format(_RNG.uniform(min_value, max_value))))
 
 
-def LazyChoice(options: list[Any]) -> LazyFunction:
+def lazy_choice(options: list[Any]) -> LazyFunction:
     """
     Create a lazy factory that selects a random element from the provided options.
 
@@ -162,7 +164,7 @@ def LazyChoice(options: list[Any]) -> LazyFunction:
     return LazyFunction(lambda: _RNG.choice(options))
 
 
-def LazySequence(start: int = 0, step: int = 1) -> LazyAttributeSequence:
+def lazy_sequence(start: int = 0, step: int = 1) -> LazyAttributeSequence:
     """
     Produce a sequence attribute that yields successive integer values.
 
@@ -178,7 +180,7 @@ def LazySequence(start: int = 0, step: int = 1) -> LazyAttributeSequence:
     return LazyAttributeSequence(lambda _instance, index: start + index * step)
 
 
-def LazyBoolean(trues_ratio: float = 0.5) -> LazyFunction:
+def lazy_boolean(trues_ratio: float = 0.5) -> LazyFunction:
     """
     Return booleans where each value is True with the specified probability.
 
@@ -191,7 +193,7 @@ def LazyBoolean(trues_ratio: float = 0.5) -> LazyFunction:
     return LazyFunction(lambda: _RNG.random() < trues_ratio)
 
 
-def LazyUUID() -> LazyFunction:
+def lazy_uuid() -> LazyFunction:
     """
     Create a lazy factory that yields RFC 4122 version 4 UUID strings.
 
@@ -201,12 +203,12 @@ def LazyUUID() -> LazyFunction:
     return LazyFunction(lambda: str(uuid.uuid4()))
 
 
-def LazyFakerName() -> LazyFunction:
+def lazy_faker_name() -> LazyFunction:
     """Return a lazy factory producing names using Faker."""
     return LazyFunction(lambda: fake.name())
 
 
-def LazyFakerEmail(
+def lazy_faker_email(
     name: Optional[str] = None, domain: Optional[str] = None
 ) -> LazyFunction:
     """Return a lazy factory producing email addresses with optional overrides."""
@@ -219,16 +221,16 @@ def LazyFakerEmail(
     return LazyFunction(lambda: name.replace(" ", "_") + "@" + domain)
 
 
-def LazyFakerSentence(number_of_words: int = 6) -> LazyFunction:
+def lazy_faker_sentence(number_of_words: int = 6) -> LazyFunction:
     """Return a lazy factory producing fake sentences."""
     return LazyFunction(lambda: fake.sentence(nb_words=number_of_words))
 
 
-def LazyFakerAddress() -> LazyFunction:
+def lazy_faker_address() -> LazyFunction:
     """Return a lazy factory producing fake postal addresses."""
     return LazyFunction(lambda: fake.address())
 
 
-def LazyFakerUrl() -> LazyFunction:
+def lazy_faker_url() -> LazyFunction:
     """Return a lazy factory producing fake URLs."""
     return LazyFunction(lambda: fake.url())

general_manager/interface/{baseInterface.py → base_interface.py}

@@ -17,13 +17,13 @@ from datetime import datetime
 from django.conf import settings
 from django.db.models import Model
 
-from general_manager.utils import args_to_kwargs
+from general_manager.utils.args_to_kwargs import args_to_kwargs
 from general_manager.api.property import GraphQLProperty
 
 if TYPE_CHECKING:
     from general_manager.manager.input import Input
-    from general_manager.manager.generalManager import GeneralManager
-    from general_manager.bucket.baseBucket import Bucket
+    from general_manager.manager.general_manager import GeneralManager
+    from general_manager.bucket.base_bucket import Bucket
 
 
 GeneralManagerType = TypeVar("GeneralManagerType", bound="GeneralManager")
@@ -159,10 +159,10 @@ class InterfaceBase(ABC):
             *args: Positional identification values corresponding to the interface's input field order.
             **kwargs: Named identification values matching the interface's input field names.
         """
-        identification = self.parseInputFieldsToIdentification(*args, **kwargs)
-        self.identification = self.formatIdentification(identification)
+        identification = self.parse_input_fields_to_identification(*args, **kwargs)
+        self.identification = self.format_identification(identification)
 
-    def parseInputFieldsToIdentification(
+    def parse_input_fields_to_identification(
         self,
         *args: Any,
         **kwargs: Any,
@@ -192,11 +192,19 @@ class InterfaceBase(ABC):
         # Check for extra arguments
         extra_args = set(kwargs.keys()) - set(self.input_fields.keys())
         if extra_args:
-            for extra_arg in extra_args:
-                if extra_arg.replace("_id", "") in self.input_fields.keys():
-                    kwargs[extra_arg.replace("_id", "")] = kwargs.pop(extra_arg)
-                else:
-                    raise UnexpectedInputArgumentsError(extra_args)
+            handled: set[str] = set()
+            for extra_arg in list(extra_args):
+                if extra_arg.endswith("_id"):
+                    base = extra_arg[:-3]
+                    if base in self.input_fields:
+                        kwargs[base] = kwargs.pop(extra_arg)
+                        handled.add(extra_arg)
+            # recompute remaining unknown keys after handling known *_id aliases
+            remaining = (extra_args - handled) | (
+                set(kwargs.keys()) - set(self.input_fields.keys())
+            )
+            if remaining:
+                raise UnexpectedInputArgumentsError(remaining)
 
         missing_args = set(self.input_fields.keys()) - set(kwargs.keys())
         if missing_args:
@@ -223,7 +231,7 @@ class InterfaceBase(ABC):
         return identification
 
     @staticmethod
-    def formatIdentification(identification: dict[str, Any]) -> dict[str, Any]:
+    def format_identification(identification: dict[str, Any]) -> dict[str, Any]:
         """
         Normalise identification data by replacing manager instances with their IDs.
 
@@ -233,7 +241,7 @@ class InterfaceBase(ABC):
         Returns:
             dict[str, Any]: Identification mapping with nested managers replaced by their identifications.
         """
-        from general_manager.manager.generalManager import GeneralManager
+        from general_manager.manager.general_manager import GeneralManager
 
         for key, value in identification.items():
             if isinstance(value, GeneralManager):
@@ -245,12 +253,12 @@ class InterfaceBase(ABC):
                         identification[key].append(v.identification)
                     elif isinstance(v, dict):
                         identification[key].append(
-                            InterfaceBase.formatIdentification(v)
+                            InterfaceBase.format_identification(v)
                         )
                     else:
                         identification[key].append(v)
             elif isinstance(value, dict):
-                identification[key] = InterfaceBase.formatIdentification(value)
+                identification[key] = InterfaceBase.format_identification(value)
         return identification
 
     def _process_input(
@@ -294,7 +302,7 @@ class InterfaceBase(ABC):
                     raise InvalidInputValueError(name, value, allowed_values)
 
     @classmethod
-    def create(cls, *args: Any, **kwargs: Any) -> Any:
+    def create(cls, *args: Any, **kwargs: Any) -> dict[str, Any]:
         """
         Create a new managed record in the underlying data store using the interface's inputs.
 
@@ -316,24 +324,24 @@ class InterfaceBase(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def getData(self, search_date: datetime | None = None) -> Any:
+    def get_data(self, search_date: datetime | None = None) -> Any:
         """Return data materialised for the manager object."""
         raise NotImplementedError
 
     @classmethod
     @abstractmethod
-    def getAttributeTypes(cls) -> dict[str, AttributeTypedDict]:
+    def get_attribute_types(cls) -> dict[str, AttributeTypedDict]:
         """Return metadata describing each attribute exposed on the manager."""
         raise NotImplementedError
 
     @classmethod
     @abstractmethod
-    def getAttributes(cls) -> dict[str, Any]:
+    def get_attributes(cls) -> dict[str, Any]:
         """Return attribute values exposed via the interface."""
         raise NotImplementedError
 
     @classmethod
-    def getGraphQLProperties(cls) -> dict[str, GraphQLProperty]:
+    def get_graph_ql_properties(cls) -> dict[str, GraphQLProperty]:
         """Return GraphQLProperty descriptors defined on the parent manager class."""
         if not hasattr(cls, "_parent_class"):
             return {}
@@ -357,7 +365,7 @@ class InterfaceBase(ABC):
 
     @classmethod
     @abstractmethod
-    def handleInterface(
+    def handle_interface(
         cls,
     ) -> tuple[
         classPreCreationMethod,
@@ -374,7 +382,7 @@ class InterfaceBase(ABC):
 
     @classmethod
     @abstractmethod
-    def getFieldType(cls, field_name: str) -> type:
+    def get_field_type(cls, field_name: str) -> type:
         """
         Return the declared Python type for an input field.
 

general_manager/interface/{calculationInterface.py → calculation_interface.py}

@@ -3,7 +3,7 @@
 from __future__ import annotations
 from datetime import datetime
 from typing import Any, ClassVar
-from general_manager.interface.baseInterface import (
+from general_manager.interface.base_interface import (
     InterfaceBase,
     classPostCreationMethod,
     classPreCreationMethod,
@@ -16,7 +16,7 @@ from general_manager.interface.baseInterface import (
     AttributeTypedDict,
 )
 from general_manager.manager.input import Input
-from general_manager.bucket.calculationBucket import CalculationBucket
+from general_manager.bucket.calculation_bucket import CalculationBucket
 
 
 class CalculationInterface(InterfaceBase):
@@ -25,7 +25,7 @@ class CalculationInterface(InterfaceBase):
     _interface_type: ClassVar[str] = "calculation"
     input_fields: ClassVar[dict[str, Input]]
 
-    def getData(self, search_date: datetime | None = None) -> Any:
+    def get_data(self, search_date: datetime | None = None) -> Any:
         """
         Indicates that calculation interfaces do not provide stored data.
 
@@ -38,7 +38,7 @@ class CalculationInterface(InterfaceBase):
         raise NotImplementedError("Calculations do not store data.")
 
     @classmethod
-    def getAttributeTypes(cls) -> dict[str, AttributeTypedDict]:
+    def get_attribute_types(cls) -> dict[str, AttributeTypedDict]:
         """
         Return a dictionary describing the type and metadata for each input field in the calculation interface.
 
@@ -56,7 +56,7 @@ class CalculationInterface(InterfaceBase):
         }
 
     @classmethod
-    def getAttributes(cls) -> dict[str, Any]:
+    def get_attributes(cls) -> dict[str, Any]:
         """Return attribute accessors that cast values using the configured inputs."""
         return {
             name: lambda self, name=name: cls.input_fields[name].cast(
@@ -81,7 +81,7 @@ class CalculationInterface(InterfaceBase):
         return CalculationBucket(cls._parent_class).all()
 
     @staticmethod
-    def _preCreate(
+    def _pre_create(
         _name: generalManagerClassName, attrs: attributes, interface: interfaceBaseClass
     ) -> tuple[attributes, interfaceBaseClass, None]:
         """
@@ -111,7 +111,7 @@ class CalculationInterface(InterfaceBase):
         return attrs, interface_cls, None
 
     @staticmethod
-    def _postCreate(
+    def _post_create(
         new_class: newlyCreatedGeneralManagerClass,
         interface_class: newlyCreatedInterfaceClass,
         _model: relatedClass,
@@ -130,17 +130,17 @@ class CalculationInterface(InterfaceBase):
         interface_class._parent_class = new_class
 
     @classmethod
-    def handleInterface(cls) -> tuple[classPreCreationMethod, classPostCreationMethod]:
+    def handle_interface(cls) -> tuple[classPreCreationMethod, classPostCreationMethod]:
         """
         Return the pre- and post-creation hooks used by ``GeneralManagerMeta``.
 
         Returns:
             tuple[classPreCreationMethod, classPostCreationMethod]: Hook functions invoked around manager creation.
         """
-        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:
         """
         Get the Python type for an input field.
 

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.