GeneralManager 0.40.2__tar.gz → 0.40.4__tar.gz

{generalmanager-0.40.2/src/GeneralManager.egg-info → generalmanager-0.40.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.40.2
+Version: 0.40.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.40.2 → generalmanager-0.40.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.40.2"
+version = "0.40.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.40.2 → generalmanager-0.40.4/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.40.2
+Version: 0.40.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.40.2 → generalmanager-0.40.4}/src/general_manager/bucket/calculation_bucket.py

@@ -453,6 +453,51 @@ class CalculationBucket(Bucket[GeneralManagerType]):
             "input_excludes": input_excludes,
         }
 
+    def _normalized_sort_key(self) -> tuple[str, ...] | None:
+        """Return the configured sort key as a tuple, or None when unsorted."""
+        if self.sort_key is None:
+            return None
+        if isinstance(self.sort_key, str):
+            return (self.sort_key,)
+        return self.sort_key
+
+    def _sort_uses_only_inputs(self, sort_key: tuple[str, ...] | None) -> bool:
+        """Return whether a sort can be applied to raw input dictionaries."""
+        if sort_key is None:
+            return True
+        return all(key in self.input_fields for key in sort_key)
+
+    def _sort_dict_combinations(
+        self,
+        combinations: list[dict[str, Any]],
+        sort_key: tuple[str, ...],
+    ) -> list[dict[str, Any]]:
+        """
+        Sort input dictionaries while tolerating missing optional inputs.
+
+        Present values sort before missing values in ascending order. Missing
+        keys use None as the explicit placeholder, guarded by a presence flag so
+        they are not compared directly with concrete input values.
+        """
+        return sorted(
+            combinations,
+            key=lambda combo: tuple(
+                (key not in combo, combo.get(key, None)) for key in sort_key
+            ),
+        )
+
+    def _manager_combinations(
+        self,
+        combinations: list[dict[str, Any]],
+    ) -> list[GeneralManagerType]:
+        return [self._manager_class(**combo) for combo in combinations]
+
+    @staticmethod
+    def _manager_identifications(
+        managers: list[GeneralManagerType],
+    ) -> list[dict[str, Any]]:
+        return [manager.identification for manager in managers]
+
     def generate_combinations(self) -> List[dict[str, Any]]:
         """
         Compute (and cache) the list of valid input combinations.
@@ -461,10 +506,6 @@ class CalculationBucket(Bucket[GeneralManagerType]):
             list[dict[str, Any]]: Cached list of input dictionaries satisfying filters, excludes, and ordering.
         """
 
-        def key_func(manager_obj: GeneralManagerType) -> tuple:
-            getters = [attrgetter(key) for key in sort_key]
-            return tuple(getter(manager_obj) for getter in getters)
-
         if self._data is None:
             sorted_inputs = self.topological_sort_inputs()
             sorted_filters = self._sort_filters(sorted_inputs)
@@ -473,23 +514,40 @@ class CalculationBucket(Bucket[GeneralManagerType]):
                 sorted_filters["input_filters"],
                 sorted_filters["input_excludes"],
             )
-            manager_combinations = self._generate_prop_combinations(
-                current_combinations,
-                sorted_filters["prop_filters"],
-                sorted_filters["prop_excludes"],
+            sort_key = self._normalized_sort_key()
+            needs_manager_access = (
+                bool(sorted_filters["prop_filters"])
+                or bool(sorted_filters["prop_excludes"])
+                or not self._sort_uses_only_inputs(sort_key)
             )
 
-            if self.sort_key is not None:
-                sort_key = self.sort_key
-                if isinstance(sort_key, str):
-                    sort_key = (sort_key,)
-                manager_combinations = sorted(
+            if needs_manager_access:
+                manager_combinations = self._manager_combinations(current_combinations)
+                manager_combinations = self._filter_prop_combinations(
                     manager_combinations,
-                    key=key_func,
+                    sorted_filters["prop_filters"],
+                    sorted_filters["prop_excludes"],
                 )
+                if sort_key is not None:
+                    getters = [attrgetter(key) for key in sort_key]
+                    manager_combinations = sorted(
+                        manager_combinations,
+                        key=lambda manager_obj: tuple(
+                            getter(manager_obj) for getter in getters
+                        ),
+                    )
+                identifications = self._manager_identifications(manager_combinations)
+            else:
+                identifications = current_combinations
+                if sort_key is not None:
+                    identifications = self._sort_dict_combinations(
+                        identifications,
+                        sort_key,
+                    )
+
             if self.reverse:
-                manager_combinations.reverse()
-            self._data = [manager.identification for manager in manager_combinations]
+                identifications.reverse()
+            self._data = identifications
 
         return self._data
 
@@ -670,9 +728,9 @@ class CalculationBucket(Bucket[GeneralManagerType]):
 
         return list(helper(0, {}))
 
-    def _generate_prop_combinations(
+    def _filter_prop_combinations(
         self,
-        current_combos: list[dict[str, Any]],
+        manager_combinations: list[GeneralManagerType],
         prop_filters: dict[str, Any],
         prop_excludes: dict[str, Any],
     ) -> list[GeneralManagerType]:
@@ -680,23 +738,22 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         Apply property-level filters and excludes to manager combinations.
 
         Parameters:
-            current_combos (list[dict[str, Any]]): Input combinations already passing input filters.
+            manager_combinations (list[GeneralManagerType]): Managers built from
+                input combinations already passing input filters.
             prop_filters (dict[str, Any]): Filter definitions keyed by property name.
             prop_excludes (dict[str, Any]): Exclude definitions keyed by property name.
 
         Returns:
-            list[GeneralManagerType]: Manager instances that satisfy property constraints.
+            list[GeneralManagerType]: Manager instances that satisfy property
+            constraints.
         """
 
         prop_filter_needed = set(prop_filters.keys()) | set(prop_excludes.keys())
-        manager_combinations = [
-            self._manager_class(**combo) for combo in current_combos
-        ]
         if not prop_filter_needed:
             return manager_combinations
 
         # Apply property filters and exclusions
-        filtered_combos = []
+        filtered_combos: list[GeneralManagerType] = []
         for manager in manager_combinations:
             keep = True
             # include filters

{generalmanager-0.40.2 → generalmanager-0.40.4}/src/general_manager/factory/factories.py

@@ -7,6 +7,7 @@ from typing import Any, cast
 from factory.declarations import LazyFunction
 from factory.faker import Faker
 import exrex  # type: ignore[import-untyped]
+from django.apps import apps
 from django.core.validators import RegexValidator
 from django.db import models
 from datetime import date, datetime, timezone, timedelta
@@ -18,6 +19,7 @@ from general_manager.manager.general_manager import GeneralManager
 
 
 _RNG = SystemRandom()
+_NO_DEFAULT = object()
 
 
 class MissingFactoryOrInstancesError(ValueError):
@@ -96,6 +98,13 @@ 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.
     """
+    if (
+        getattr(field, "null", False)
+        and getattr(field, "default", _NO_DEFAULT) is None
+        and getattr(field, "is_relation", False)
+    ):
+        return None
+
     if field.null:
         if _RNG.choice([True] + 9 * [False]):
             return None
@@ -246,11 +255,11 @@ def get_related_model(
         MissingRelatedModelError: If the field does not declare a related model.
         InvalidRelatedModelTypeError: If the resolved related model is not a Django model class.
     """
-    related_model = field.related_model
+    related_model: object = field.related_model
     if related_model is None:
         raise MissingRelatedModelError(field.name)
-    if related_model == "self":
-        related_model = field.model
+    if isinstance(related_model, str):
+        related_model = _resolve_related_model_string(field, related_model)
     if not isinstance(related_model, type) or not issubclass(
         related_model, models.Model
     ):
@@ -258,6 +267,29 @@ def get_related_model(
     return cast(type[models.Model], related_model)
 
 
+def _resolve_related_model_string(
+    field: models.ForeignObjectRel | models.Field[Any, Any],
+    related_model: str,
+) -> object:
+    if related_model == "self":
+        return field.model
+    app_label: str | None
+    if "." in related_model:
+        app_label, model_name = related_model.split(".", 1)
+    else:
+        model = getattr(field, "model", None)
+        opts = getattr(model, "_meta", None)
+        app_label_value = getattr(opts, "app_label", None)
+        app_label = app_label_value if isinstance(app_label_value, str) else None
+        model_name = related_model
+    if not app_label:
+        return related_model
+    try:
+        return apps.get_model(app_label, model_name)
+    except LookupError:
+        return related_model
+
+
 def get_many_to_many_field_value(
     field: models.ManyToManyField,
 ) -> list[models.Model]: