GeneralManager 0.41.4__tar.gz → 0.41.6__tar.gz

{generalmanager-0.41.4/src/GeneralManager.egg-info → generalmanager-0.41.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.41.4
+Version: 0.41.6
 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.41.4 → generalmanager-0.41.6}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.41.4
+Version: 0.41.6
 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.41.4 → generalmanager-0.41.6}/src/general_manager/bucket/database_bucket.py

@@ -140,6 +140,57 @@ class NonSortablePropertyError(ValueError):
         )
 
 
+class DuplicateDatabaseBucketSnapshotError(ValueError):
+    """Raised when a database bucket snapshot contains duplicate primary keys."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            "DatabaseBucket snapshots cannot contain duplicate primary keys."
+        )
+
+
+def _ensure_unique_primary_keys(primary_keys: tuple[Any, ...]) -> None:
+    if len(primary_keys) != len(set(primary_keys)):
+        raise DuplicateDatabaseBucketSnapshotError()
+
+
+def _restore_database_bucket_from_primary_keys(
+    model: type[models.Model],
+    manager_class: Type[GeneralManagerType],
+    primary_keys: tuple[Any, ...],
+    filter_definitions: dict[str, list[Any]],
+    exclude_definitions: dict[str, list[Any]],
+    database_alias: str | None,
+    search_date: datetime | date | None,
+    sort_keys: tuple[str, ...] | None,
+    sort_reverse: bool,
+) -> DatabaseBucket[GeneralManagerType]:
+    _ensure_unique_primary_keys(primary_keys)
+    manager = model._default_manager
+    if database_alias is not None:
+        manager = manager.db_manager(database_alias)
+    if not primary_keys:
+        queryset = manager.none()
+    else:
+        preserved_order = models.Case(
+            *(
+                models.When(pk=primary_key, then=position)
+                for position, primary_key in enumerate(primary_keys)
+            ),
+            output_field=models.IntegerField(),
+        )
+        queryset = manager.filter(pk__in=primary_keys).order_by(preserved_order)
+    return DatabaseBucket(
+        queryset,
+        manager_class,
+        filter_definitions,
+        exclude_definitions,
+        search_date=search_date,
+        sort_keys=sort_keys,
+        sort_reverse=sort_reverse,
+    )
+
+
 class DatabaseBucket(Bucket[GeneralManagerType]):
     """Bucket implementation backed by Django ORM querysets."""
 
@@ -175,6 +226,28 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         self._sort_keys = sort_keys
         self._sort_reverse = sort_reverse
 
+    def __reduce__(self) -> str | tuple[Any, ...]:
+        """
+        Preserve a result snapshot without serializing the queryset object.
+        """
+        self._track_effective_dependencies()
+        primary_keys = tuple(self._data.values_list("pk", flat=True))
+        _ensure_unique_primary_keys(primary_keys)
+        return (
+            _restore_database_bucket_from_primary_keys,
+            (
+                self._data.model,
+                self._manager_class,
+                primary_keys,
+                self.filters,
+                self.excludes,
+                self._data.db,
+                self._search_date,
+                self._sort_keys,
+                self._sort_reverse,
+            ),
+        )
+
     def _build_manager(self, pk: Any) -> GeneralManagerType:
         if self._search_date is None:
             return self._manager_class(pk)

{generalmanager-0.41.4 → generalmanager-0.41.6}/src/general_manager/interface/capabilities/orm_utils/field_descriptors.py

@@ -270,10 +270,27 @@ class _FieldDescriptorBuilder:
         Iterates the model's many-to-many and reverse (one-to-many) relations and registers a collection descriptor for each, deriving descriptor names from each relation's base name and accessor name.
         """
         for m2m_field in _iter_many_to_many_fields(self.model):
+            if getattr(m2m_field, "auto_created", False) and not getattr(
+                m2m_field, "concrete", False
+            ):
+                relation_field_name = getattr(
+                    getattr(m2m_field, "field", None),
+                    "name",
+                    None,
+                )
+                relation_filter_name = None
+            else:
+                relation_field_name = None
+                relation_filter_name = _many_to_many_relation_filter_name(
+                    m2m_field,
+                    self.model,
+                )
             self._register_collection_field(
                 field=m2m_field,
                 base_name=m2m_field.name,
                 accessor_name=m2m_field.name,
+                relation_field_name=relation_field_name,
+                relation_filter_name=relation_filter_name,
             )
         for reverse_relation in _iter_reverse_relations(self.model):
             accessor_name = (
@@ -305,6 +322,7 @@ class _FieldDescriptorBuilder:
         base_name: str,
         accessor_name: str,
         relation_field_name: str | None = None,
+        relation_filter_name: str | None = None,
     ) -> None:
         """
         Register a collection relation as a FieldDescriptor under the generated "<base>_list" attribute.
@@ -341,6 +359,7 @@ class _FieldDescriptorBuilder:
                 general_manager_class=general_manager_class,
                 source_model=self.model,
                 relation_field_name=relation_field_name,
+                relation_filter_name=relation_filter_name,
             )
             relation_type = cast(type, general_manager_class)
         else:
@@ -675,6 +694,7 @@ def _general_manager_many_accessor(
     general_manager_class: type,
     source_model: type[models.Model],
     relation_field_name: str | None = None,
+    relation_filter_name: str | None = None,
 ) -> DescriptorAccessor:
     """
     Create an accessor that returns a manager filtered to objects related to the given source model instance.
@@ -688,7 +708,9 @@ def _general_manager_many_accessor(
     Returns:
         DescriptorAccessor: A callable that accepts an OrmInterfaceBase instance and returns the manager/QuerySet of related_model instances whose foreign-key fields pointing to `source_model` match the instance's primary key.
     """
-    if relation_field_name is not None:
+    if relation_filter_name is not None:
+        related_fields: list[models.Field] = []
+    elif relation_field_name is not None:
         related_fields = [
             cast(models.Field, related_model._meta.get_field(relation_field_name))
         ]
@@ -706,7 +728,10 @@ def _general_manager_many_accessor(
         Returns:
             A manager or queryset containing related model instances whose foreign-key fields equal this interface instance's primary key.
         """
-        filter_kwargs = {field.name: self.pk for field in related_fields}
+        if relation_filter_name is not None:
+            filter_kwargs = {relation_filter_name: self.pk}
+        else:
+            filter_kwargs = {field.name: self.pk for field in related_fields}
         manager_cls = cast(Any, general_manager_class)
         if not filter_kwargs:
             raise MissingRelatedFieldsError(
@@ -719,6 +744,29 @@ def _general_manager_many_accessor(
     return getter
 
 
+def _many_to_many_relation_filter_name(
+    field: models.Field,
+    source_model: type[models.Model],
+) -> str | None:
+    """Return the target-side query lookup for a direct many-to-many field."""
+    remote_field = getattr(field, "remote_field", None)
+    related_query_name = getattr(remote_field, "related_query_name", None)
+    if callable(related_query_name):
+        related_query_name = related_query_name()
+    if isinstance(related_query_name, str) and related_query_name:
+        return related_query_name
+    related_name = getattr(remote_field, "related_name", None)
+    if related_name == "+":
+        return None
+    if isinstance(related_name, str) and related_name:
+        return related_name
+    source_meta = getattr(source_model, "_meta", None)
+    source_model_name = getattr(source_meta, "model_name", None)
+    if isinstance(source_model_name, str) and source_model_name:
+        return source_model_name
+    return None
+
+
 def _direct_many_accessor(
     resolver: Callable[["OrmInterfaceBase", str, str], Any],
     field_call: str,