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

general_manager/factory/{autoFactory.py → auto_factory.py}

@@ -4,11 +4,14 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Type, Callable, Union, Any, TypeVar, Literal
 from django.db import models
 from factory.django import DjangoModelFactory
-from general_manager.factory.factories import getFieldValue, getManyToManyFieldValue
+from general_manager.factory.factories import (
+    get_field_value,
+    get_many_to_many_field_value,
+)
 from django.contrib.contenttypes.fields import GenericForeignKey
 
 if TYPE_CHECKING:
-    from general_manager.interface.databaseInterface import (
+    from general_manager.interface.database_interface import (
         DBBasedInterface,
     )
 
@@ -82,7 +85,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
             is_model = False
         if not is_model:
             raise InvalidAutoFactoryModelError
-        field_name_list, to_ignore_list = cls.interface.handleCustomFields(model)
+        field_name_list, to_ignore_list = cls.interface.handle_custom_fields(model)
 
         fields = [
             field
@@ -107,20 +110,20 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
                 continue  # Skip fields that are already set
             if isinstance(field, models.AutoField) or field.auto_created:
                 continue  # Skip auto fields
-            params[field.name] = getFieldValue(field)
+            params[field.name] = get_field_value(field)
 
         obj: list[models.Model] | models.Model = super()._generate(strategy, params)
         if isinstance(obj, list):
             for item in obj:
                 if not isinstance(item, models.Model):
                     raise InvalidGeneratedObjectError()
-                cls._handleManyToManyFieldsAfterCreation(item, params)
+                cls._handle_many_to_many_fields_after_creation(item, params)
         else:
-            cls._handleManyToManyFieldsAfterCreation(obj, params)
+            cls._handle_many_to_many_fields_after_creation(obj, params)
         return obj
 
     @classmethod
-    def _handleManyToManyFieldsAfterCreation(
+    def _handle_many_to_many_fields_after_creation(
         cls, obj: models.Model, attrs: dict[str, Any]
     ) -> None:
         """
@@ -134,7 +137,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
             if field.name in attrs:
                 m2m_values = attrs[field.name]
             else:
-                m2m_values = getManyToManyFieldValue(field)
+                m2m_values = get_many_to_many_field_value(field)
             if m2m_values:
                 getattr(obj, field.name).set(m2m_values)
 
@@ -172,8 +175,10 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         """
         kwargs = cls._adjust_kwargs(**kwargs)
         if cls._adjustmentMethod is not None:
-            return cls.__createWithGenerateFunc(use_creation_method=True, params=kwargs)
-        return cls._modelCreation(model_class, **kwargs)
+            return cls.__create_with_generate_func(
+                use_creation_method=True, params=kwargs
+            )
+        return cls._model_creation(model_class, **kwargs)
 
     @classmethod
     def _build(
@@ -192,13 +197,13 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         """
         kwargs = cls._adjust_kwargs(**kwargs)
         if cls._adjustmentMethod is not None:
-            return cls.__createWithGenerateFunc(
+            return cls.__create_with_generate_func(
                 use_creation_method=False, params=kwargs
             )
-        return cls._modelBuilding(model_class, **kwargs)
+        return cls._model_building(model_class, **kwargs)
 
     @classmethod
-    def _modelCreation(
+    def _model_creation(
         cls, model_class: Type[models.Model], **kwargs: Any
     ) -> models.Model:
         """
@@ -219,7 +224,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         return obj
 
     @classmethod
-    def _modelBuilding(
+    def _model_building(
         cls, model_class: Type[models.Model], **kwargs: Any
     ) -> models.Model:
         """Construct an unsaved model instance with the provided field values."""
@@ -229,7 +234,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         return obj
 
     @classmethod
-    def __createWithGenerateFunc(
+    def __create_with_generate_func(
         cls, use_creation_method: bool, params: dict[str, Any]
     ) -> models.Model | list[models.Model]:
         """
@@ -251,13 +256,13 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         records = cls._adjustmentMethod(**params)
         if isinstance(records, dict):
             if use_creation_method:
-                return cls._modelCreation(model_cls, **records)
-            return cls._modelBuilding(model_cls, **records)
+                return cls._model_creation(model_cls, **records)
+            return cls._model_building(model_cls, **records)
 
         created_objects: list[models.Model] = []
         for record in records:
             if use_creation_method:
-                created_objects.append(cls._modelCreation(model_cls, **record))
+                created_objects.append(cls._model_creation(model_cls, **record))
             else:
-                created_objects.append(cls._modelBuilding(model_cls, **record))
+                created_objects.append(cls._model_building(model_cls, **record))
         return created_objects

general_manager/factory/factories.py

@@ -1,21 +1,18 @@
 """Helpers for generating realistic factory values for Django models."""
 
 from __future__ import annotations
-from typing import TYPE_CHECKING, Any, cast
+from typing import Any, cast
 
 from factory.declarations import LazyFunction
 from factory.faker import Faker
 import exrex  # type: ignore[import-untyped]
 from django.core.validators import RegexValidator
 from django.db import models
-from datetime import date, datetime, time, timezone
+from datetime import date, datetime, time, timezone, timedelta
 from decimal import Decimal
 from random import SystemRandom
 from general_manager.measurement.measurement import Measurement
-from general_manager.measurement.measurementField import MeasurementField
-
-if TYPE_CHECKING:
-    from general_manager.factory.autoFactory import AutoFactory
+from general_manager.measurement.measurement_field import MeasurementField
 
 
 _RNG = SystemRandom()
@@ -65,7 +62,7 @@ class InvalidRelatedModelTypeError(TypeError):
         )
 
 
-def getFieldValue(
+def get_field_value(
     field: models.Field[Any, Any] | models.ForeignObjectRel,
 ) -> Any:
     """
@@ -158,7 +155,7 @@ def getFieldValue(
     elif isinstance(field, models.UUIDField):
         return cast(str, Faker("uuid4"))
     elif isinstance(field, models.DurationField):
-        return cast(time, Faker("time_delta"))
+        return cast(timedelta, Faker("time_delta"))
     elif isinstance(field, models.CharField):
         max_length = field.max_length or 100
         # Check for RegexValidator
@@ -173,7 +170,7 @@ def getFieldValue(
         else:
             return cast(str, Faker("text", max_nb_chars=max_length))
     elif isinstance(field, models.OneToOneField):
-        related_model = getRelatedModel(field)
+        related_model = get_related_model(field)
         if hasattr(related_model, "_general_manager_class"):
             related_factory = related_model._general_manager_class.Factory  # type: ignore
             return related_factory()
@@ -185,7 +182,7 @@ def getFieldValue(
             else:
                 raise MissingFactoryOrInstancesError(related_model)
     elif isinstance(field, models.ForeignKey):
-        related_model = getRelatedModel(field)
+        related_model = get_related_model(field)
         # Create or get an instance of the related model
         if hasattr(related_model, "_general_manager_class"):
             create_a_new_instance = _RNG.choice([True, True, False])
@@ -209,7 +206,7 @@ def getFieldValue(
         return None
 
 
-def getRelatedModel(
+def get_related_model(
     field: models.ForeignObjectRel | models.Field[Any, Any],
 ) -> type[models.Model]:
     """
@@ -239,7 +236,7 @@ def getRelatedModel(
     return cast(type[models.Model], related_model)
 
 
-def getManyToManyFieldValue(
+def get_many_to_many_field_value(
     field: models.ManyToManyField,
 ) -> list[models.Model]:
     """
@@ -257,7 +254,7 @@ def getManyToManyFieldValue(
         MissingFactoryOrInstancesError: If the related model provides neither a factory nor any existing instances.
     """
     related_factory = None
-    related_model = getRelatedModel(field)
+    related_model = get_related_model(field)
     related_instances = list(related_model.objects.all())
     if hasattr(related_model, "_general_manager_class"):
         related_factory = related_model._general_manager_class.Factory  # type: ignore

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(
@@ -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.