GeneralManager 0.59.0__tar.gz → 0.59.2__tar.gz

{generalmanager-0.59.0/src/GeneralManager.egg-info → generalmanager-0.59.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.59.0
+Version: 0.59.2
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License
@@ -47,7 +47,7 @@ License-File: LICENSE
 Requires-Dist: asgiref>=3.8.1
 Requires-Dist: celery<6.0.0,>=5.3.6
 Requires-Dist: channels>=4.1.0
-Requires-Dist: Django>=5.2.12
+Requires-Dist: Django>=5.2.15
 Requires-Dist: django-simple-history>=3.8.0
 Requires-Dist: exrex>=0.12.0
 Requires-Dist: factory_boy>=3.3.3

{generalmanager-0.59.0 → generalmanager-0.59.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.59.0"
+version = "0.59.2"
 description = "Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching."
 readme = "README.md"
 authors = [{ name = "Tim Kleindick", email = "tkleindick@yahoo.de" }]
@@ -35,7 +35,7 @@ dependencies = [
     "asgiref>=3.8.1",
     "celery>=5.3.6,<6.0.0",  # async search indexing (docs/concepts/search.md)
     "channels>=4.1.0",
-    "Django>=5.2.12",
+    "Django>=5.2.15",
     "django-simple-history>=3.8.0",
     "exrex>=0.12.0",
     "factory_boy>=3.3.3",

{generalmanager-0.59.0 → generalmanager-0.59.2/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.59.0
+Version: 0.59.2
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License
@@ -47,7 +47,7 @@ License-File: LICENSE
 Requires-Dist: asgiref>=3.8.1
 Requires-Dist: celery<6.0.0,>=5.3.6
 Requires-Dist: channels>=4.1.0
-Requires-Dist: Django>=5.2.12
+Requires-Dist: Django>=5.2.15
 Requires-Dist: django-simple-history>=3.8.0
 Requires-Dist: exrex>=0.12.0
 Requires-Dist: factory_boy>=3.3.3

{generalmanager-0.59.0 → generalmanager-0.59.2}/src/GeneralManager.egg-info/requires.txt

@@ -1,7 +1,7 @@
 asgiref>=3.8.1
 celery<6.0.0,>=5.3.6
 channels>=4.1.0
-Django>=5.2.12
+Django>=5.2.15
 django-simple-history>=3.8.0
 exrex>=0.12.0
 factory_boy>=3.3.3

{generalmanager-0.59.0 → generalmanager-0.59.2}/src/general_manager/factory/auto_factory.py

@@ -1,7 +1,7 @@
 """Auto-generating factory utilities for GeneralManager models."""
 
 from __future__ import annotations
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from typing import (
     TYPE_CHECKING,
     ClassVar,
@@ -15,6 +15,7 @@ from django.db import models
 from django.db import transaction
 from factory.django import DjangoModelFactory
 from general_manager.factory.factories import (
+    RelationGenerationMode,
     UnableToResolveManagerInstanceError,
     get_field_value,
     get_many_to_many_field_value,
@@ -115,6 +116,53 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
 
     interface: type[OrmInterfaceBase[models.Model]]
     _adjustmentMethod: ClassVar[AdjustmentMethod | None] = None
+    _related_factory_mode: ClassVar[RelationGenerationMode] = "reuse_existing"
+    _related_factory_modes: ClassVar[Mapping[str, RelationGenerationMode]] = {}
+
+    def __init_subclass__(cls, **kwargs: object) -> None:
+        super().__init_subclass__(**kwargs)
+        cls._related_factory_modes = dict(cls._related_factory_modes)
+
+    @classmethod
+    def _setup_next_sequence(cls) -> int:
+        """Initialize factory_boy sequences after existing persisted rows."""
+        model = cls._meta.model
+        try:
+            is_model = isinstance(model, type) and issubclass(model, models.Model)
+        except TypeError:
+            is_model = False
+        if not is_model:
+            return cls._factory_boy_next_sequence()
+
+        model_cls = cast(type[models.Model], model)
+        manager = model_cls._default_manager
+        database_alias = cls._get_database_alias()
+        if database_alias:
+            manager = manager.using(database_alias)
+        try:
+            count = manager.count()
+        except Exception:  # noqa: BLE001
+            return cls._factory_boy_next_sequence()
+        return max(cls._factory_boy_next_sequence(), count)
+
+    @classmethod
+    def _factory_boy_next_sequence(cls) -> int:
+        """Call factory_boy's untyped sequence initializer with a typed boundary."""
+        setup_next_sequence = cast(Callable[[], int], super()._setup_next_sequence)
+        return setup_next_sequence()
+
+    @classmethod
+    def _get_related_factory_mode(cls, field_name: str) -> RelationGenerationMode:
+        """Return the relation generation mode configured for a model field."""
+        return cls._related_factory_modes.get(field_name, cls._related_factory_mode)
+
+    @classmethod
+    def _get_database_alias(cls) -> str | None:
+        """Return the interface database alias, when the interface defines one."""
+        if not hasattr(cls.interface, "_get_database_alias"):
+            return None
+        database_alias = cls.interface._get_database_alias()
+        return database_alias or None
 
     @classmethod
     def _generate(
@@ -158,6 +206,8 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         if not is_model:
             raise InvalidAutoFactoryModelError
         field_name_list, to_ignore_list = cls.interface.handle_custom_fields(model)
+        supplied_field_names = set(params)
+        database_alias = cls._get_database_alias()
 
         fields = [
             field
@@ -186,6 +236,16 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
             if declared_default is not None:
                 params[field.name] = declared_default
                 continue
+            if getattr(field, "is_relation", False) and (
+                getattr(field, "many_to_one", False)
+                or getattr(field, "one_to_one", False)
+            ):
+                params[field.name] = get_field_value(
+                    field,
+                    relation_generation=cls._get_related_factory_mode(field.name),
+                    database_alias=database_alias,
+                )
+                continue
             params[field.name] = get_field_value(field)
 
         generate = cast(
@@ -201,16 +261,23 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
                     raise InvalidGeneratedObjectError()
             if strategy == "create":
                 for item in obj:
-                    cls._handle_many_to_many_fields_after_creation(item, params)
+                    cls._handle_many_to_many_fields_after_creation(
+                        item, params, supplied_field_names
+                    )
         elif strategy == "create":
-            cls._handle_many_to_many_fields_after_creation(obj, params)
+            cls._handle_many_to_many_fields_after_creation(
+                obj, params, supplied_field_names
+            )
         if strategy == "create":
             return cls._wrap_generated_objects(obj)
         return obj
 
     @classmethod
     def _handle_many_to_many_fields_after_creation(
-        cls, obj: models.Model, attrs: FactoryParams
+        cls,
+        obj: models.Model,
+        attrs: FactoryParams,
+        supplied_field_names: set[str] | None = None,
     ) -> None:
         """
         Assign related objects to many-to-many fields after saved creation.
@@ -223,11 +290,20 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
             obj (models.Model): Instance whose many-to-many relations should be populated.
             attrs: Original attributes passed to the factory.
         """
+        if supplied_field_names is None:
+            supplied_field_names = set(attrs)
         for field in obj._meta.many_to_many:
-            if field.name in attrs:
+            relation_generation = cls._get_related_factory_mode(field.name)
+            if field.name in attrs and field.name in supplied_field_names:
                 m2m_values = attrs[field.name]
+            elif relation_generation == "reuse_existing" and field.blank:
+                continue
             else:
-                m2m_values = get_many_to_many_field_value(field)
+                m2m_values = get_many_to_many_field_value(
+                    field,
+                    relation_generation=relation_generation,
+                    database_alias=cls._get_database_alias(),
+                )
             if m2m_values:
                 normalized_values = cls._coerce_many_to_many_values(m2m_values)
                 getattr(obj, field.name).set(normalized_values)
@@ -317,10 +393,10 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         obj = model_class()
         for field, value in kwargs.items():
             setattr(obj, field, value)
+        database_alias = cls._get_database_alias()
+        if database_alias:
+            obj._state.db = database_alias
         obj.full_clean()
-        database_alias: str | None = None
-        if hasattr(cls.interface, "_get_database_alias"):
-            database_alias = cls.interface._get_database_alias()
 
         if database_alias:
             obj.save(using=database_alias)
@@ -373,9 +449,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
 
         created_objects: list[models.Model] = []
         if use_creation_method:
-            database_alias: str | None = None
-            if hasattr(cls.interface, "_get_database_alias"):
-                database_alias = cls.interface._get_database_alias()
+            database_alias = cls._get_database_alias()
             with transaction.atomic(using=database_alias):
                 for record in records:
                     created_objects.append(cls._model_creation(model_cls, **record))

{generalmanager-0.59.0 → generalmanager-0.59.2}/src/general_manager/factory/factories.py

@@ -4,14 +4,14 @@ from __future__ import annotations
 
 from collections.abc import Callable
 import string
-from typing import Protocol, cast
+from typing import Any, Literal, Protocol, cast
 
 from factory.declarations import LazyFunction
 from factory.faker import Faker
 import exrex
 from django.apps import apps
 from django.core.validators import RegexValidator
-from django.db import models
+from django.db import DatabaseError, models
 from datetime import timezone
 from decimal import Decimal
 from random import SystemRandom
@@ -24,6 +24,7 @@ _RNG = SystemRandom()
 _NO_DEFAULT = object()
 type DjangoField = models.Field[object, object]
 type RelatedFactory = Callable[[], object]
+type RelationGenerationMode = Literal["reuse_existing", "create", "random"]
 
 _LazyFunctionConstructor = cast(
     Callable[[Callable[[], object]], LazyFunction],
@@ -137,6 +138,9 @@ class UnableToResolveManagerInstanceError(ValueError):
 
 def get_field_value(
     field: DjangoField | models.ForeignObjectRel,
+    *,
+    relation_generation: RelationGenerationMode = "reuse_existing",
+    database_alias: str | None = None,
 ) -> object:
     """
     Generate a realistic sample value appropriate for the given Django model field or relation.
@@ -164,6 +168,10 @@ def get_field_value(
             relation descriptor to generate a value for. Many-to-many fields are
             accepted by the broad type shape but intentionally return `None`
             here; pass them to `get_many_to_many_field_value()` instead.
+        relation_generation: Strategy for relation fields. Defaults to reusing
+            existing related rows before creating new related rows.
+        database_alias: Optional Django database alias used when querying
+            existing related rows.
 
     Returns:
         A value suitable for assignment to the field (scalar, string, Measurement-producing LazyFunction, model instance, LazyFunction that yields a related instance, or `None`).
@@ -173,14 +181,16 @@ def get_field_value(
         MissingRelatedModelError: When a relational field does not declare a related model.
         InvalidRelatedModelTypeError: When a relational field's related value is not a Django model class.
     """
+    field_is_relation = _is_relation_field(field)
     if (
-        getattr(field, "null", False)
+        relation_generation != "create"
+        and getattr(field, "null", False)
         and getattr(field, "default", _NO_DEFAULT) is None
-        and getattr(field, "is_relation", False)
+        and field_is_relation
     ):
         return None
 
-    if field.null:
+    if relation_generation != "create" and getattr(field, "null", False):
         if _RNG.choice([True] + 9 * [False]):
             return None
 
@@ -269,39 +279,65 @@ def get_field_value(
             return _faker("text", max_nb_chars=max_length)
     elif isinstance(field, models.OneToOneField):
         related_model = get_related_model(field)
-        if hasattr(related_model, "_general_manager_class"):
-            related_factory = _get_related_factory(related_model)
-            return _ensure_model_instance(related_factory())
-        else:
-            # If no factory exists, pick a random existing instance
-            related_instances = list(related_model.objects.all())
-            if related_instances:
-                return _lazy_function(lambda: _RNG.choice(related_instances))
+        related_factory = (
+            _get_related_factory(related_model)
+            if hasattr(related_model, "_general_manager_class")
+            else None
+        )
+        if relation_generation == "create":
+            if related_factory is not None:
+                return _ensure_model_instance(related_factory())
             if field.null:
                 return None
             raise MissingFactoryOrInstancesError(related_model)
+        related_instances = _existing_related_instances(
+            field,
+            related_model,
+            database_alias=database_alias,
+        )
+        if related_instances:
+            return _lazy_existing_choice(related_instances)
+        if related_factory is not None:
+            return _ensure_model_instance(related_factory())
+        if field.null:
+            return None
+        raise MissingFactoryOrInstancesError(related_model)
     elif isinstance(field, models.ForeignKey):
         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])
-            if not create_a_new_instance:
-                existing_instances = list(related_model.objects.all())
-                if existing_instances:
-                    # Pick a random existing instance
-                    return _lazy_function(lambda: _RNG.choice(existing_instances))
-
-            related_factory = _get_related_factory(related_model)
-            return _ensure_model_instance(related_factory())
-
-        else:
-            # If no factory exists, pick a random existing instance
-            related_instances = list(related_model.objects.all())
-            if related_instances:
-                return _lazy_function(lambda: _RNG.choice(related_instances))
+        related_factory = (
+            _get_related_factory(related_model)
+            if hasattr(related_model, "_general_manager_class")
+            else None
+        )
+        if relation_generation == "create":
+            if related_factory is not None:
+                return _ensure_model_instance(related_factory())
             if field.null:
                 return None
             raise MissingFactoryOrInstancesError(related_model)
+        if relation_generation == "random" and related_factory is not None:
+            create_a_new_instance = _RNG.choice([True, True, False])
+            if not create_a_new_instance:
+                related_instances = _existing_related_instances(
+                    field,
+                    related_model,
+                    database_alias=database_alias,
+                )
+                if related_instances:
+                    return _lazy_existing_choice(related_instances)
+            return _ensure_model_instance(related_factory())
+        related_instances = _existing_related_instances(
+            field,
+            related_model,
+            database_alias=database_alias,
+        )
+        if related_instances:
+            return _lazy_existing_choice(related_instances)
+        if related_factory is not None:
+            return _ensure_model_instance(related_factory())
+        if field.null:
+            return None
+        raise MissingFactoryOrInstancesError(related_model)
     else:
         return None
 
@@ -372,19 +408,26 @@ def _resolve_related_model_string(
 
 def get_many_to_many_field_value(
     field: models.ManyToManyField[models.Model, models.Model],
+    *,
+    relation_generation: RelationGenerationMode = "reuse_existing",
+    database_alias: str | None = None,
 ) -> list[models.Model]:
     """
     Generate a list of related model instances suitable for assigning to a ManyToManyField.
 
     The function selects a random number of related objects (at least one when
-    the field is not blank, up to 10). It will use the related model's factory
-    to create new instances when available, prefer a mix of created and existing
-    instances if both are present, or return existing instances when no factory
-    is available. `blank=True` allows an empty result; `blank=False` requires at
-    least one related instance.
+    the field is not blank, up to 10). Default generation samples existing
+    related rows when they are available and creates through the related model's
+    factory only when no existing rows are available. Create mode bypasses
+    existing rows and uses the related factory. `blank=True` allows an empty
+    result; `blank=False` requires at least one related instance.
 
     Parameters:
         field (models.ManyToManyField): The ManyToMany field to generate values for.
+        relation_generation: Strategy for relation values. Defaults to reusing
+            existing related rows before creating new related rows.
+        database_alias: Optional Django database alias used when querying
+            existing related rows.
 
     Returns:
         list[models.Model]: A list of related model instances to assign to the field.
@@ -400,37 +443,129 @@ def get_many_to_many_field_value(
     """
     related_factory: RelatedFactory | None = None
     related_model = get_related_model(field)
-    related_instances: list[models.Model] = list(related_model.objects.all())
     if hasattr(related_model, "_general_manager_class"):
         related_factory = _get_related_factory(related_model)
 
     min_required = 0 if field.blank else 1
     number_of_instances = _RNG.randint(min_required, 10)
-    if related_factory and related_instances:
-        number_to_create = _RNG.randint(min_required, number_of_instances)
-        number_to_pick = number_of_instances - number_to_create
-        if number_to_pick > len(related_instances):
-            number_to_pick = len(related_instances)
-        existing_instances = _RNG.sample(related_instances, number_to_pick)
-        new_factory_values = [related_factory() for _ in range(number_to_create)]
-        return existing_instances + [
-            _ensure_model_instance(instance) for instance in new_factory_values
-        ]
-    elif related_factory:
-        number_to_create = number_of_instances
-        new_instances = [
-            _ensure_model_instance(related_factory()) for _ in range(number_to_create)
-        ]
-        return new_instances
-    elif related_instances:
-        number_to_create = 0
+    if relation_generation == "create":
+        if related_factory:
+            return [
+                _ensure_model_instance(related_factory())
+                for _ in range(number_of_instances)
+            ]
+        raise MissingFactoryOrInstancesError(related_model)
+
+    related_instances = _existing_related_instances(
+        field,
+        related_model,
+        database_alias=database_alias,
+    )
+    if related_instances:
         number_to_pick = number_of_instances
         if number_to_pick > len(related_instances):
             number_to_pick = len(related_instances)
-        existing_instances = _RNG.sample(related_instances, number_to_pick)
-        return existing_instances
-    else:
-        raise MissingFactoryOrInstancesError(related_model)
+        return _RNG.sample(related_instances, number_to_pick)
+    if related_factory:
+        return [
+            _ensure_model_instance(related_factory())
+            for _ in range(number_of_instances)
+        ]
+    raise MissingFactoryOrInstancesError(related_model)
+
+
+def _is_relation_field(field: object) -> bool:
+    return (
+        isinstance(field, models.OneToOneField)
+        or isinstance(field, models.ForeignKey)
+        or getattr(field, "is_relation", False) is True
+        or getattr(field, "many_to_one", False) is True
+        or getattr(field, "one_to_one", False) is True
+        or getattr(field, "many_to_many", False) is True
+    )
+
+
+def _existing_related_instances(
+    field: object,
+    related_model: type[models.Model] | None = None,
+    *,
+    database_alias: str | None = None,
+) -> list[models.Model]:
+    """Return existing related rows that are reusable for this relation field."""
+    field_obj = cast(Any, field)
+    if related_model is None:
+        related_model = cast(type[models.Model], field_obj.related_model)
+    related_instances = list(
+        _get_model_manager(related_model, database_alias=database_alias).all()
+    )
+    if not (
+        isinstance(field, models.OneToOneField)
+        or getattr(field, "one_to_one", False) is True
+    ):
+        return related_instances
+
+    model = field_obj.model
+    attname = getattr(field_obj, "attname", field_obj.name)
+    try:
+        linked_values = set(
+            _get_model_manager(
+                model,
+                prefer_base=True,
+                database_alias=database_alias,
+            )
+            .exclude(**{attname: None})
+            .values_list(attname, flat=True)
+        )
+    except DatabaseError:
+        if getattr(getattr(model, "_meta", None), "managed", True) is not False:
+            raise
+        linked_values = set()
+    return [
+        instance
+        for instance in related_instances
+        if _related_target_value(instance, getattr(field_obj, "target_field", None))
+        not in linked_values
+    ]
+
+
+def _lazy_existing_choice(instances: list[models.Model]) -> LazyFunction:
+    return _lazy_function(lambda: _RNG.choice(instances))
+
+
+def _related_target_value(instance: object, target_field: object | None) -> object:
+    if target_field is not None:
+        target_attr = getattr(
+            target_field,
+            "attname",
+            getattr(target_field, "name", None),
+        )
+        if target_attr is not None and hasattr(instance, target_attr):
+            return getattr(instance, target_attr)
+    return getattr(instance, "pk", None)
+
+
+def _get_model_manager(
+    model: object,
+    *,
+    prefer_base: bool = False,
+    database_alias: str | None = None,
+) -> Any:
+    model_obj = cast(Any, model)
+    if prefer_base:
+        base_manager = getattr(model_obj, "_base_manager", None)
+        if base_manager is not None:
+            if database_alias:
+                return base_manager.using(database_alias)
+            return base_manager
+    default_manager = getattr(model_obj, "_default_manager", None)
+    if default_manager is not None:
+        if database_alias:
+            return default_manager.using(database_alias)
+        return default_manager
+    objects_manager = model_obj.objects
+    if database_alias:
+        return objects_manager.using(database_alias)
+    return objects_manager
 
 
 def _get_related_factory(related_model: type[models.Model]) -> RelatedFactory: