GeneralManager 0.10.3__py3-none-any.whl → 0.10.5__py3-none-any.whl

general_manager/factory/factories.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
-from typing import Any, cast
+from typing import Any, cast, TYPE_CHECKING
 from factory.declarations import LazyFunction
 from factory.faker import Faker
-import exrex  # type: ignore
+import exrex
 from django.db import models
 from django.core.validators import RegexValidator
 import random
@@ -11,12 +11,17 @@ from general_manager.measurement.measurement import Measurement
 from general_manager.measurement.measurementField import MeasurementField
 from datetime import date, datetime, time, timezone
 
+if TYPE_CHECKING:
+    from general_manager.factory.autoFactory import AutoFactory
 
-def getFieldValue(field: models.Field[Any, Any] | models.ForeignObjectRel) -> object:
+
+def getFieldValue(
+    field: models.Field[Any, Any] | models.ForeignObjectRel,
+) -> object:
     """
-    Generates an appropriate value for a given Django model field for use in testing or data factories.
+    Generate a suitable fake or factory value for a given Django model field, for use in tests or data factories.
     
-    If the field allows null values, there is a 10% chance of returning None. Handles a wide range of Django field types, including measurement, text, numeric, date/time, boolean, relational, and specialized fields, returning a suitable fake or factory-generated value for each. For relational fields (OneToOneField and ForeignKey), attempts to use a factory if available or selects a random existing instance; raises ValueError if neither is possible. Returns None for unsupported field types.
+    Returns a value appropriate for the field type, including support for measurement, text, numeric, date/time, boolean, email, URL, IP address, UUID, duration, and character fields (with regex support). For relational fields (OneToOneField and ForeignKey), attempts to use a related model factory or select a random existing instance; raises ValueError if neither is available. Returns None for unsupported field types or with a 10% chance if the field allows null values.
     """
     if field.null:
         if random.choice([True] + 9 * [False]):
@@ -62,78 +67,103 @@ def getFieldValue(field: models.Field[Any, Any] | models.ForeignObjectRel) -> ob
         return cast(date, Faker("date_between", start_date="-1y", end_date="today"))
     elif isinstance(field, models.BooleanField):
         return cast(bool, Faker("pybool"))
+    elif isinstance(field, models.EmailField):
+        return cast(str, Faker("email"))
+    elif isinstance(field, models.URLField):
+        return cast(str, Faker("url"))
+    elif isinstance(field, models.GenericIPAddressField):
+        return cast(str, Faker("ipv4"))
+    elif isinstance(field, models.UUIDField):
+        return cast(str, Faker("uuid4"))
+    elif isinstance(field, models.DurationField):
+        return cast(time, Faker("time_delta"))
+    elif isinstance(field, models.CharField):
+        max_length = field.max_length or 100
+        # Check for RegexValidator
+        regex = None
+        for validator in field.validators:
+            if isinstance(validator, RegexValidator):
+                regex = getattr(validator.regex, "pattern", None)
+                break
+        if regex:
+            # Use exrex to generate a string matching the regex
+            return LazyFunction(lambda: exrex.getone(regex))
+        else:
+            return cast(str, Faker("text", max_nb_chars=max_length))
     elif isinstance(field, models.OneToOneField):
-        if hasattr(field.related_model, "_general_manager_class"):
-            related_factory = field.related_model._general_manager_class.Factory
+        related_model = getRelatedModel(field)
+        if hasattr(related_model, "_general_manager_class"):
+            related_factory = related_model._general_manager_class.Factory  # type: ignore
             return related_factory()
         else:
             # If no factory exists, pick a random existing instance
-            related_instances = list(field.related_model.objects.all())
+            related_instances = list(related_model.objects.all())
             if related_instances:
                 return LazyFunction(lambda: random.choice(related_instances))
             else:
                 raise ValueError(
-                    f"No factory found for {field.related_model.__name__} and no instances found"
+                    f"No factory found for {related_model.__name__} and no instances found"
                 )
     elif isinstance(field, models.ForeignKey):
+        related_model = getRelatedModel(field)
         # Create or get an instance of the related model
-        if hasattr(field.related_model, "_general_manager_class"):
+        if hasattr(related_model, "_general_manager_class"):
             create_a_new_instance = random.choice([True, True, False])
             if not create_a_new_instance:
-                existing_instances = list(field.related_model.objects.all())
+                existing_instances = list(related_model.objects.all())
                 if existing_instances:
                     # Pick a random existing instance
                     return LazyFunction(lambda: random.choice(existing_instances))
 
-            related_factory = field.related_model._general_manager_class.Factory
+            related_factory = related_model._general_manager_class.Factory  # type: ignore
             return related_factory()
 
         else:
             # If no factory exists, pick a random existing instance
-            related_instances = list(field.related_model.objects.all())
+            related_instances = list(related_model.objects.all())
             if related_instances:
                 return LazyFunction(lambda: random.choice(related_instances))
             else:
                 raise ValueError(
-                    f"No factory found for {field.related_model.__name__} and no instances found"
+                    f"No factory found for {related_model.__name__} and no instances found"
                 )
-    elif isinstance(field, models.EmailField):
-        return cast(str, Faker("email"))
-    elif isinstance(field, models.URLField):
-        return cast(str, Faker("url"))
-    elif isinstance(field, models.GenericIPAddressField):
-        return cast(str, Faker("ipv4"))
-    elif isinstance(field, models.UUIDField):
-        return cast(str, Faker("uuid4"))
-    elif isinstance(field, models.DurationField):
-        return cast(time, Faker("time_delta"))
-    elif isinstance(field, models.CharField):
-        max_length = field.max_length or 100
-        # Check for RegexValidator
-        regex = None
-        for validator in field.validators:
-            if isinstance(validator, RegexValidator):
-                regex = getattr(validator.regex, "pattern", None)
-                break
-        if regex:
-            # Use exrex to generate a string matching the regex
-            return LazyFunction(lambda: exrex.getone(regex))  # type: ignore
-        else:
-            return cast(str, Faker("text", max_nb_chars=max_length))
     else:
-        return None  # For unsupported field types
+        return None
+
+
+def getRelatedModel(
+    field: models.ForeignObjectRel | models.Field[Any, Any],
+) -> type[models.Model]:
+    """
+    Return the related model class for a given Django relational field.
+    
+    Raises:
+        ValueError: If the field does not have a related model defined.
+    """
+    related_model = field.related_model
+    if related_model is None:
+        raise ValueError(f"Field {field.name} does not have a related model defined.")
+    if related_model == "self":
+        related_model = field.model
+    return related_model  # For unsupported field types
 
 
 def getManyToManyFieldValue(
     field: models.ManyToManyField,
 ) -> list[models.Model]:
     """
-    Returns a list of instances for a ManyToMany field.
+    Generate a list of model instances to associate with a ManyToMany field for testing or factory purposes.
+    
+    If a related model factory is available, creates new instances as needed. Otherwise, selects from existing instances. Raises a ValueError if neither a factory nor existing instances are available.
+    
+    Returns:
+        list[models.Model]: A list of related model instances for the ManyToMany field.
     """
     related_factory = None
-    related_instances = list(field.related_model.objects.all())
-    if hasattr(field.related_model, "_general_manager_class"):
-        related_factory = field.related_model._general_manager_class.Factory
+    related_model = getRelatedModel(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
 
     min_required = 0 if field.blank else 1
     number_of_instances = random.randint(min_required, 10)
@@ -158,5 +188,5 @@ def getManyToManyFieldValue(
         return existing_instances
     else:
         raise ValueError(
-            f"No factory found for {field.related_model.__name__} and no instances found"
+            f"No factory found for {related_model.__name__} and no instances found"
         )

general_manager/interface/baseInterface.py

@@ -69,12 +69,12 @@ class InterfaceBase(ABC):
         **kwargs: dict[str, Any],
     ) -> dict[str, Any]:
         """
-        Parses and validates input arguments into a structured identification dictionary.
+        Parse and validate input arguments into a dictionary of input field values.
 
-        Converts positional and keyword arguments into a dictionary keyed by input field names, normalizing argument names and ensuring all required fields are present. Processes input fields in dependency order, casting and validating each value. Raises a `TypeError` for unexpected or missing arguments and a `ValueError` if circular dependencies among input fields are detected.
+        Positional and keyword arguments are mapped to input field names, with normalization of argument names (e.g., removing trailing `_id`). Ensures all required fields are present and no unexpected arguments are provided. Processes input fields in dependency order, casting and validating each value. Raises a `TypeError` for missing or unexpected arguments and a `ValueError` if circular dependencies are detected.
 
         Returns:
-            A dictionary mapping input field names to their validated and cast values.
+            dict[str, Any]: A dictionary mapping input field names to their validated and cast values.
         """
         identification = {}
         kwargs = args_to_kwargs(args, self.input_fields.keys(), kwargs)

general_manager/interface/calculationInterface.py

@@ -26,12 +26,18 @@ class CalculationInterface(InterfaceBase):
 
     @classmethod
     def getAttributeTypes(cls) -> dict[str, AttributeTypedDict]:
+        """
+        Return a dictionary describing the type and metadata for each input field in the calculation interface.
+
+        Each entry includes the field's type, default value (`None`), and flags indicating that the field is not editable, is required, and is not derived.
+        """
         return {
             name: {
                 "type": field.type,
                 "default": None,
                 "is_editable": False,
                 "is_required": True,
+                "is_derived": False,
             }
             for name, field in cls.input_fields.items()
         }
@@ -61,14 +67,13 @@ class CalculationInterface(InterfaceBase):
     def _preCreate(
         name: generalManagerClassName, attrs: attributes, interface: interfaceBaseClass
     ) -> tuple[attributes, interfaceBaseClass, None]:
-
         """
-        Prepares attributes and a new interface class before creating a GeneralManager class.
-        
-        Collects all `Input` instances from the provided interface class, sets the interface type in the attributes, dynamically creates a new interface class with these input fields, and adds it to the attributes.
-        
+        Prepare and return updated attributes and a new interface class for GeneralManager creation.
+
+        Collects all `Input` instances from the provided interface class, sets the interface type in the attributes, dynamically creates a new interface class with an `input_fields` attribute, and adds this class to the attributes dictionary.
+
         Returns:
-            A tuple containing the updated attributes dictionary, the new interface class, and None.
+            tuple: A tuple containing the updated attributes dictionary, the new interface class, and None.
         """
         input_fields: dict[str, Input[Any]] = {}
         for key, value in vars(interface).items():
@@ -109,12 +114,18 @@ class CalculationInterface(InterfaceBase):
     @classmethod
     def getFieldType(cls, field_name: str) -> type:
         """
-        Returns the Python type of a specified input field.
-        
+        Return the Python type of the specified input field.
+
+        Parameters:
+            field_name (str): The name of the input field.
+
+        Returns:
+            type: The Python type associated with the input field.
+
         Raises:
-            KeyError: If the field name does not exist in input_fields.
+            KeyError: If the specified field name does not exist in input_fields.
         """
-        input = cls.input_fields.get(field_name)
-        if input is None:
+        field = cls.input_fields.get(field_name)
+        if field is None:
             raise KeyError(f"Field '{field_name}' not found in input fields.")
-        return input.type
+        return field.type

general_manager/interface/databaseBasedInterface.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Type, Any, Callable, TYPE_CHECKING, TypeVar, Generic
+from typing import Type, Any, Callable, TYPE_CHECKING, TypeVar, Generic, cast
 from django.db import models
 from datetime import datetime, timedelta
 from general_manager.measurement.measurement import Measurement
@@ -25,13 +25,13 @@ from general_manager.interface.models import (
     GeneralManagerModel,
     getFullCleanMethode,
 )
+from django.contrib.contenttypes.fields import GenericForeignKey
 
 if TYPE_CHECKING:
     from general_manager.rule.rule import Rule
 
 modelsModel = TypeVar("modelsModel", bound=models.Model)
 
-
 MODEL_TYPE = TypeVar("MODEL_TYPE", bound=GeneralManagerBasisModel)
 
 
@@ -43,12 +43,12 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         self,
         *args: list[Any],
         search_date: datetime | None = None,
-        **kwargs: dict[str, Any],
+        **kwargs: Any,
     ):
         """
-        Initialize the interface and load the associated model instance.
-
-        If `search_date` is provided, loads the historical record as of that date; otherwise, loads the current record.
+        Initialize the interface and load the associated model instance by primary key.
+        
+        If a `search_date` is provided, retrieves the historical record as of that date; otherwise, loads the current record.
         """
         super().__init__(*args, **kwargs)
         self.pk = self.identification["id"]
@@ -135,10 +135,10 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @classmethod
     def getAttributeTypes(cls) -> dict[str, AttributeTypedDict]:
         """
-        Return a dictionary mapping attribute names to metadata describing their types and properties.
-
-        The dictionary includes all model fields, custom fields, foreign keys, many-to-many, and reverse relation fields. For each attribute, the metadata specifies its Python type (translated from Django field types when possible), whether it is required, editable, derived, and its default value. For related models with a general manager class, the type is set to that class.
-
+        Return a dictionary mapping each attribute name of the model to its type information and metadata.
+        
+        The returned dictionary includes all standard model fields, custom fields, foreign keys, many-to-many, and reverse relation fields, excluding any GenericForeignKey fields. For each attribute, the metadata specifies its Python type (translated from Django field types when possible), whether it is required, editable, derived, and its default value. For related models with a general manager class, the type is set to that class.
+        
         Returns:
             dict[str, AttributeTypedDict]: Mapping of attribute names to their type information and metadata.
         """
@@ -163,7 +163,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         fields: dict[str, AttributeTypedDict] = {}
         field_name_list, to_ignore_list = cls.handleCustomFields(cls._model)
         for field_name in field_name_list:
-            field: models.Field = getattr(cls._model, field_name)
+            field = cast(models.Field, getattr(cls._model, field_name))
             fields[field_name] = {
                 "type": type(field),
                 "is_derived": False,
@@ -174,7 +174,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
 
         for field_name in cls.__getModelFields():
             if field_name not in to_ignore_list:
-                field: models.Field = getattr(cls._model, field_name).field
+                field = cast(models.Field, getattr(cls._model, field_name).field)
                 fields[field_name] = {
                     "type": type(field),
                     "is_derived": False,
@@ -185,20 +185,27 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
 
         for field_name in cls.__getForeignKeyFields():
             field = cls._model._meta.get_field(field_name)
+            if isinstance(field, GenericForeignKey):
+                continue
             related_model = field.related_model
+            if related_model == "self":
+                related_model = cls._model
             if related_model and hasattr(
                 related_model,
                 "_general_manager_class",
             ):
-                related_model = related_model._general_manager_class
+                related_model = related_model._general_manager_class  # type: ignore
 
             elif related_model is not None:
+                default = None
+                if hasattr(field, "default"):
+                    default = field.default  # type: ignore
                 fields[field_name] = {
                     "type": related_model,
                     "is_derived": False,
                     "is_required": not field.null,
                     "is_editable": field.editable,
-                    "default": field.default,
+                    "default": default,
                 }
 
         for field_name, field_call in [
@@ -212,11 +219,17 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                     raise ValueError("Field name already exists.")
             field = cls._model._meta.get_field(field_name)
             related_model = cls._model._meta.get_field(field_name).related_model
+            if related_model == "self":
+                related_model = cls._model
+            if isinstance(field, GenericForeignKey):
+                continue
+
             if related_model and hasattr(
                 related_model,
                 "_general_manager_class",
             ):
-                related_model = related_model._general_manager_class
+                related_model = related_model._general_manager_class  # type: ignore
+
             if related_model is not None:
                 fields[f"{field_name}_list"] = {
                     "type": related_model,
@@ -234,9 +247,12 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @classmethod
     def getAttributes(cls) -> dict[str, Callable[[DBBasedInterface], Any]]:
         """
-        Returns a mapping of attribute names to callables that retrieve their values from a DBBasedInterface instance.
-
-        The returned dictionary includes accessors for custom fields, model fields, foreign keys (optionally returning related interface instances), many-to-many relations, and reverse relations. For related models that have a general manager class, the accessor returns an instance of that class; otherwise, it returns the related object or queryset directly. Raises a ValueError if a field name conflict occurs.
+        Return a dictionary mapping attribute names to callables that retrieve values from a DBBasedInterface instance.
+        
+        The mapping includes accessors for custom fields, standard model fields, foreign keys, many-to-many relations, and reverse relations. For related models with a general manager class, the accessor returns an instance of that class; otherwise, it returns the related object or queryset. Raises a ValueError if a field name conflict is detected.
+         
+        Returns:
+            dict: A dictionary where keys are attribute names and values are callables that extract the corresponding value from a DBBasedInterface instance.
         """
         field_values: dict[str, Any] = {}
 
@@ -258,7 +274,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                 related_model,
                 "_general_manager_class",
             ):
-                generalManagerClass = related_model._general_manager_class
+                generalManagerClass = related_model._general_manager_class  # type: ignore
                 field_values[f"{field_name}"] = (
                     lambda self, field_name=field_name, manager_class=generalManagerClass: manager_class(
                         getattr(self._instance, field_name).pk
@@ -322,13 +338,13 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @staticmethod
     def _getCustomFields(model: Type[models.Model] | models.Model) -> list[str]:
         """
-        Returns a list of custom field names defined directly on the model class.
-
-        Args:
+        Return a list of custom field names defined directly as class attributes on the given Django model.
+        
+        Parameters:
             model: The Django model class or instance to inspect.
-
+        
         Returns:
-            A list of field names that are defined as class attributes on the model, not via Django's meta system.
+            A list of field names for fields declared directly on the model class, excluding those defined via Django's meta system.
         """
         return [
             field.name
@@ -337,11 +353,11 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         ]
 
     @classmethod
-    def __getModelFields(cls):
+    def __getModelFields(cls) -> list[str]:
         """
-        Returns a list of model field names that are not many-to-many or related fields.
-
-        Excludes fields representing many-to-many relationships and related models.
+        Return a list of field names for the model that are neither many-to-many nor related fields.
+        
+        Fields representing many-to-many relationships or relations to other models are excluded from the result.
         """
         return [
             field.name
@@ -350,9 +366,9 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         ]
 
     @classmethod
-    def __getForeignKeyFields(cls):
+    def __getForeignKeyFields(cls) -> list[str]:
         """
-        Returns a list of field names for all foreign key and one-to-one relations on the model.
+        Return a list of field names for all foreign key and one-to-one relations on the model, excluding generic foreign keys.
         """
         return [
             field.name
@@ -361,11 +377,11 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         ]
 
     @classmethod
-    def __getManyToManyFields(cls):
+    def __getManyToManyFields(cls) -> list[tuple[str, str]]:
         """
-        Returns a list of tuples containing the names of all many-to-many fields on the model.
-
-        Each tuple consists of the field name repeated twice.
+        Return a list of tuples representing all many-to-many fields on the model.
+        
+        Each tuple contains the field name twice. Fields that are generic foreign keys are excluded.
         """
         return [
             (field.name, field.name)
@@ -374,11 +390,11 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         ]
 
     @classmethod
-    def __getReverseRelations(cls):
+    def __getReverseRelations(cls) -> list[tuple[str, str]]:
         """
-        Returns a list of tuples representing reverse one-to-many relations for the model.
-
-        Each tuple contains the related field's name and its default related accessor name.
+        Return a list of reverse one-to-many relations for the model, excluding generic foreign keys.
+        
+        Each tuple contains the related field's name and its default related accessor name (e.g., `fieldname_set`).
         """
         return [
             (field.name, f"{field.name}_set")
@@ -485,11 +501,15 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @classmethod
     def getFieldType(cls, field_name: str) -> type:
         """
-        Returns the type associated with the specified field name.
-
-        If the field is a relation and its related model defines a `_general_manager_class`, that class is returned; otherwise, returns the Django field type.
+        Return the type associated with a given model field name.
+        
+        If the field is a relation and its related model has a `_general_manager_class` attribute, that class is returned; otherwise, returns the Django field type.
         """
         field = cls._model._meta.get_field(field_name)
-        if field.is_relation and field.related_model:
-            return field.related_model._general_manager_class
+        if (
+            field.is_relation
+            and field.related_model
+            and hasattr(field.related_model, "_general_manager_class")
+        ):
+            return field.related_model._general_manager_class  # type: ignore
         return type(field)