GeneralManager 0.57.2__tar.gz → 0.57.4__tar.gz

{generalmanager-0.57.2/src/GeneralManager.egg-info → generalmanager-0.57.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.57.2
+Version: 0.57.4
 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

{generalmanager-0.57.2 → generalmanager-0.57.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.57.2"
+version = "0.57.4"
 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" }]

{generalmanager-0.57.2 → generalmanager-0.57.4/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.57.2
+Version: 0.57.4
 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

{generalmanager-0.57.2 → generalmanager-0.57.4}/src/general_manager/bucket/calculation_bucket.py

@@ -1,8 +1,9 @@
 """Bucket implementation that enumerates calculation interface combinations."""
 
 from __future__ import annotations
-from collections.abc import Hashable, Iterable
+from collections.abc import Hashable, Iterable, Iterator
 from types import UnionType
+from itertools import islice
 from typing import (
     Type,
     TYPE_CHECKING,
@@ -25,6 +26,7 @@ from general_manager.bucket.base_bucket import Bucket
 from general_manager.bucket.indexing import freeze_bucket_index_value
 from general_manager.manager.input import Input, InputDomain
 from general_manager.utils.filter_parser import (
+    FilterFunction,
     ParsedFilters,
     parse_filters,
 )
@@ -47,6 +49,15 @@ class SortedFilters(TypedDict):
     input_excludes: ParsedFilters
 
 
+def _build_exclude_filter(exclude_func: FilterFunction) -> FilterFunction:
+    """Create a lazy predicate that keeps values an exclude does not reject."""
+
+    def includes_value(value: object) -> bool:
+        return not exclude_func(value)
+
+    return includes_value
+
+
 class InvalidCalculationInterfaceError(TypeError):
     """Raised when a CalculationBucket is initialized with a non-CalculationInterface manager."""
 
@@ -308,25 +319,95 @@ class CalculationBucket(Bucket[GeneralManagerType]):
 
     def __str__(self) -> str:
         """
-        Return a compact preview of the generated combinations.
+        Return a compact preview of generated combinations.
+
+        Cached buckets include the exact combination count. Uncached buckets avoid
+        materializing all combinations for string formatting; when more than the
+        preview limit exists, the count is reported as a lower-bound label.
 
         Returns:
             str: Human-readable summary of up to five combinations.
         """
         PRINT_MAX = 5
-        combinations = self.generate_combinations()
-        prefix = f"CalculationBucket ({len(combinations)})["
+        combinations, count_label, has_more = self._str_combinations_preview(PRINT_MAX)
+        prefix = f"CalculationBucket ({count_label})["
         main = ",".join(
-            [
-                f"{self._manager_class.__name__}(**{comb})"
-                for comb in combinations[:PRINT_MAX]
-            ]
+            [f"{self._manager_class.__name__}(**{comb})" for comb in combinations]
+        )
+        suffix = "]"
+        if has_more:
+            suffix = ", ...]"
+
+        return f"{prefix}{main}{suffix}"
+
+    def _str_combinations_preview(
+        self, limit: int
+    ) -> tuple[list[Combination], str, bool]:
+        """
+        Return combinations, count label, and overflow flag for ``__str__``.
+
+        Sorted or reversed buckets use normal materialization so the preview
+        reflects the final global ordering. Unsorted uncached buckets read at
+        most ``limit + 1`` matching combinations and leave ``_data`` untouched.
+        """
+        if self._data is not None:
+            return self._data[:limit], str(len(self._data)), len(self._data) > limit
+
+        if self._normalized_sort_key() is not None or self.reverse:
+            combinations = self.generate_combinations()
+            return (
+                combinations[:limit],
+                str(len(combinations)),
+                len(combinations) > limit,
+            )
+
+        from general_manager.cache.run_context import ensure_calculation_run_context
+
+        with ensure_calculation_run_context():
+            sorted_inputs = self.topological_sort_inputs()
+            sorted_filters = self._sort_filters(sorted_inputs)
+            if self._uses_static_iterator_possible_values(sorted_inputs):
+                combinations = self.generate_combinations()
+                return (
+                    combinations[:limit],
+                    str(len(combinations)),
+                    len(combinations) > limit,
+                )
+            snapshot_iterables = self._uses_dependent_possible_values(sorted_inputs)
+            preview_iterator = self._iter_input_combinations(
+                sorted_inputs,
+                sorted_filters["input_filters"],
+                sorted_filters["input_excludes"],
+                snapshot_iterables=snapshot_iterables,
+            )
+            if sorted_filters["prop_filters"] or sorted_filters["prop_excludes"]:
+                preview_iterator = self._iter_prop_filtered_identifications(
+                    preview_iterator,
+                    sorted_filters["prop_filters"],
+                    sorted_filters["prop_excludes"],
+                )
+            preview = list(islice(preview_iterator, limit + 1))
+
+        has_more = len(preview) > limit
+        if has_more:
+            preview = preview[:limit]
+        count_label = f"{limit}+" if has_more else str(len(preview))
+        return preview, count_label, has_more
+
+    def _uses_static_iterator_possible_values(self, sorted_inputs: list[str]) -> bool:
+        """Return whether previewing would consume a one-shot static iterator."""
+        return any(
+            isinstance(self.input_fields[input_name].possible_values, Iterator)
+            for input_name in sorted_inputs
         )
-        sufix = "]"
-        if len(combinations) > PRINT_MAX:
-            sufix = ", ...]"
 
-        return f"{prefix}{main}{sufix}"
+    def _uses_dependent_possible_values(self, sorted_inputs: list[str]) -> bool:
+        """Return whether previewing should snapshot values before dependencies."""
+        return any(
+            bool(self.input_fields[input_name].depends_on)
+            and self.input_fields[input_name].possible_values is not None
+            for input_name in sorted_inputs
+        )
 
     def __repr__(self) -> str:
         """
@@ -549,12 +630,14 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         self,
         combinations: list[Combination],
     ) -> list[GeneralManagerType]:
+        """Instantiate managers for each raw input-combination dictionary."""
         return [self._manager_class(**combo) for combo in combinations]
 
     @staticmethod
     def _manager_identifications(
         managers: list[GeneralManagerType],
     ) -> list[Combination]:
+        """Return the identification dictionaries from manager instances."""
         return [manager.identification for manager in managers]
 
     def generate_combinations(self) -> List[Combination]:
@@ -730,22 +813,25 @@ class CalculationBucket(Bucket[GeneralManagerType]):
             raise InvalidPossibleValuesError(key_name)
         return possible_values
 
-    def _generate_input_combinations(
+    def _iter_input_combinations(
         self,
         sorted_inputs: List[str],
         filters: ParsedFilters,
         excludes: ParsedFilters,
-    ) -> List[Combination]:
+        *,
+        snapshot_iterables: bool,
+    ) -> Generator[Combination, None, None]:
         """
-        Generate all valid assignments of input fields that satisfy the provided per-field filters and exclusions.
+        Yield valid assignments of input fields satisfying filters and excludes.
 
         Parameters:
             sorted_inputs (list[str]): Input names in dependency-respecting order.
             filters (dict[str, dict]): Per-input filter definitions (may include `filter_funcs` or `filter_kwargs`).
             excludes (dict[str, dict]): Per-input exclusion definitions (may include `filter_funcs` or `filter_kwargs`).
 
-        Returns:
-            list[Combination]: Completed input-to-value mappings that meet the filters and excludes.
+        Yields:
+            Combination: Completed input-to-value mappings that meet the
+                filters and excludes.
         """
 
         def input_passes_filters(
@@ -812,10 +898,10 @@ class CalculationBucket(Bucket[GeneralManagerType]):
                 exclude_funcs = field_excludes.get("filter_funcs", [])
                 for exclude_func in exclude_funcs:
                     possible_values = filter(
-                        lambda x: not exclude_func(x), possible_values
+                        _build_exclude_filter(exclude_func), possible_values
                     )
-
-                possible_values = list(possible_values)
+                if snapshot_iterables:
+                    possible_values = list(possible_values)
 
             for value in possible_values:
                 if not isinstance(value, input_field.type):
@@ -824,7 +910,52 @@ class CalculationBucket(Bucket[GeneralManagerType]):
                 yield from helper(index + 1, current_combo)
                 del current_combo[input_name]
 
-        return list(helper(0, {}))
+        yield from helper(0, {})
+
+    def _generate_input_combinations(
+        self,
+        sorted_inputs: List[str],
+        filters: ParsedFilters,
+        excludes: ParsedFilters,
+    ) -> List[Combination]:
+        """
+        Generate all valid assignments of input fields that satisfy filters.
+
+        Parameters:
+            sorted_inputs (list[str]): Input names in dependency-respecting order.
+            filters (dict[str, dict]): Per-input filter definitions.
+            excludes (dict[str, dict]): Per-input exclusion definitions.
+
+        Returns:
+            list[Combination]: Completed input-to-value mappings that meet the
+                filters and excludes.
+        """
+        return list(
+            self._iter_input_combinations(
+                sorted_inputs,
+                filters,
+                excludes,
+                snapshot_iterables=True,
+            )
+        )
+
+    def _iter_prop_filtered_identifications(
+        self,
+        combinations: Iterable[Combination],
+        prop_filters: ParsedFilters,
+        prop_excludes: ParsedFilters,
+    ) -> Generator[Combination, None, None]:
+        """
+        Lazily apply property filters and yield manager identifications.
+
+        This mirrors the property-filter materialization path used by
+        :meth:`generate_combinations`, but lets ``__str__`` stop after enough
+        matching combinations have been found.
+        """
+        for combo in combinations:
+            manager = self._manager_class(**combo)
+            if self._filter_prop_combinations([manager], prop_filters, prop_excludes):
+                yield manager.identification
 
     def _filter_prop_combinations(
         self,

{generalmanager-0.57.2 → generalmanager-0.57.4}/src/general_manager/factory/auto_factory.py

@@ -105,12 +105,12 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
 
     The factory inspects the bound ORM interface, fills missing model fields with
     generated values or declared defaults, applies many-to-many relations after
-    model construction, and wraps created objects back into GeneralManager
-    instances. Build strategy returns Django model instances; create strategy
-    returns manager wrappers. Subclasses are generated with an ORM interface that
-    provides ``handle_custom_fields()``, ``input_fields``,
-    ``format_identification()``, and ``_parent_class`` for created-object
-    wrapping.
+    saved creation, and wraps created objects back into GeneralManager instances.
+    Build strategy returns unsaved Django model instances and skips
+    many-to-many assignment; create strategy returns manager wrappers.
+    Subclasses are generated with an ORM interface that provides
+    ``handle_custom_fields()``, ``input_fields``, ``format_identification()``,
+    and ``_parent_class`` for created-object wrapping.
     """
 
     interface: type[OrmInterfaceBase[models.Model]]
@@ -127,14 +127,11 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         caller-supplied values already present in `params` win. factory_boy then
         dispatches to `_build()` or `_create()`, where many-to-many values are
         stripped from constructor kwargs and foreign-key/one-to-one values are
-        coerced before `_adjustmentMethod` is called. After model construction,
-        this hook applies many-to-many assignments from the original `params`
-        and wraps created models into manager instances for create strategy.
-
-        Many-to-many assignment is attempted for both build and create strategy.
-        Django requires saved instances for many-to-many `.set(...)`; therefore
-        build calls with explicit or generated many-to-many values are
-        unsupported and may raise Django's unsaved-instance relation error.
+        coerced before `_adjustmentMethod` is called. Create strategy then
+        applies many-to-many assignments from the original `params` to saved
+        models and wraps them into manager instances. Build strategy returns the
+        unsaved model instance(s) without attempting many-to-many assignment,
+        even when explicit or declared many-to-many values were supplied.
 
         Parameters:
             strategy (Literal["build", "create"]): "build" returns unsaved model instance(s); "create" saves model instance(s) and returns GeneralManager wrapper(s).
@@ -202,8 +199,10 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
             for item in obj:
                 if not isinstance(item, models.Model):
                     raise InvalidGeneratedObjectError()
-                cls._handle_many_to_many_fields_after_creation(item, params)
-        else:
+            if strategy == "create":
+                for item in obj:
+                    cls._handle_many_to_many_fields_after_creation(item, params)
+        elif strategy == "create":
             cls._handle_many_to_many_fields_after_creation(obj, params)
         if strategy == "create":
             return cls._wrap_generated_objects(obj)
@@ -214,7 +213,11 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         cls, obj: models.Model, attrs: FactoryParams
     ) -> None:
         """
-        Assign related objects to many-to-many fields after creation/building.
+        Assign related objects to many-to-many fields after saved creation.
+
+        Build strategy returns unsaved models and must skip this method because
+        Django many-to-many managers require the source instance to have a
+        primary key before `.set(...)` can be used.
 
         Parameters:
             obj (models.Model): Instance whose many-to-many relations should be populated.