GeneralManager 0.41.7__tar.gz → 0.41.9__tar.gz

{generalmanager-0.41.7/src/GeneralManager.egg-info → generalmanager-0.41.9}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.41.7
+Version: 0.41.9
 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.7 → generalmanager-0.41.9}/src/general_manager/bootstrap.py

@@ -298,6 +298,31 @@ def initialize_general_manager_classes(
             if isinstance(field_type, type) and issubclass(field_type, _GM):
                 yield attribute_name, field_type
 
+    def _has_reverse_relation_attribute(
+        manager_class: Type[_GM],
+        related_manager_class: Type[_GM],
+    ) -> bool:
+        get_attribute_types = getattr(
+            manager_class.Interface, "get_attribute_types", None
+        )
+        if not callable(get_attribute_types):
+            return False
+        try:
+            attribute_types = get_attribute_types()
+        except NotImplementedError:
+            return False
+        return any(
+            metadata.get("is_derived", False)
+            and metadata.get("relation_kind") in {"collection", "direct"}
+            and metadata.get("type") is related_manager_class
+            for metadata in attribute_types.values()
+        )
+
+    def _to_snake_case(name: str) -> str:
+        snake = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
+        snake = re.sub("([a-z0-9])([A-Z])", r"\1_\2", snake)
+        return snake.lower()
+
     logger.debug(
         "creating manager attributes",
         context={"pending_attributes": len(pending_attribute_initialization)},
@@ -323,13 +348,18 @@ def initialize_general_manager_classes(
         for attribute_name, connected_manager in _iter_manager_relation_fields(
             general_manager_class
         ):
+            if _has_reverse_relation_attribute(
+                connected_manager,
+                general_manager_class,
+            ):
+                continue
             resolver = _build_connection_resolver(attribute_name, general_manager_class)
             relation_property = GraphQLProperty(resolver)
             marked_relation_property: Any = relation_property
             marked_relation_property._general_manager_generated_relation = True
             setattr(
                 connected_manager,
-                f"{general_manager_class.__name__.lower()}_list",
+                f"{_to_snake_case(general_manager_class.__name__)}_list",
                 relation_property,
             )
     for general_manager_class in all_classes:

{generalmanager-0.41.7 → generalmanager-0.41.9}/src/general_manager/bucket/group_bucket.py

@@ -1,11 +1,71 @@
 """Grouping bucket implementation for aggregating GeneralManager instances."""
 
 from __future__ import annotations
-from typing import Any, Generator, Generic, Type
+from typing import Any, Generator, Generic, Type, cast
 from general_manager.manager.group_manager import GroupManager
+from general_manager.manager.general_manager import GeneralManager
 from general_manager.bucket.base_bucket import Bucket, GeneralManagerType
 
 
+def _freeze_group_value(value: Any) -> Any:
+    """Return a hashable identity for values used to distinguish groups."""
+    if isinstance(value, GeneralManager):
+        return (
+            value.__class__,
+            tuple(
+                sorted(
+                    (
+                        key,
+                        _freeze_group_value(identifier),
+                    )
+                    for key, identifier in value.identification.items()
+                )
+            ),
+        )
+    if isinstance(value, dict):
+        return tuple(
+            sorted(
+                (
+                    _freeze_group_value(key),
+                    _freeze_group_value(item),
+                )
+                for key, item in value.items()
+            )
+        )
+    if isinstance(value, (list, tuple)):
+        return tuple(_freeze_group_value(item) for item in value)
+    if isinstance(value, set):
+        return frozenset(_freeze_group_value(item) for item in value)
+    return value
+
+
+def _group_filter_kwargs(
+    manager_class: Type[GeneralManagerType],
+    group_by_value: tuple[tuple[str, Any], ...],
+) -> dict[str, Any]:
+    """Translate grouped manager values into backend-neutral relation lookups."""
+    filters: dict[str, Any] = {}
+    get_attribute_types = getattr(
+        manager_class.Interface,
+        "get_attribute_types",
+        None,
+    )
+    attributes = get_attribute_types() if callable(get_attribute_types) else {}
+    for key, value in group_by_value:
+        attribute_info = cast(dict[str, Any], attributes.get(key, {}))
+        filter_key = attribute_info.get("filter_lookup", key)
+        if isinstance(value, GeneralManager):
+            filters.update(
+                {
+                    f"{filter_key}__{identifier_key}": identifier_value
+                    for identifier_key, identifier_value in value.identification.items()
+                }
+            )
+            continue
+        filters[filter_key] = value
+    return filters
+
+
 class InvalidGroupByKeyTypeError(TypeError):
     """Raised when a non-string value is provided as a group-by key."""
 
@@ -191,15 +251,25 @@ class GroupBucket(Generic[GeneralManagerType]):
         Returns:
             list[GroupManager[GeneralManagerType]]: A list of GroupManager objects, one per unique tuple of group-by key values; groups are produced in order sorted by the string representation of their key tuples.
         """
-        group_by_values: set[tuple[tuple[str, Any], ...]] = set()
+        group_by_values: dict[
+            tuple[tuple[str, Any], ...],
+            tuple[tuple[str, Any], ...],
+        ] = {}
         for entry in data:
-            key = tuple((arg, getattr(entry, arg)) for arg in self._group_by_keys)
-            group_by_values.add(key)
+            group_by_value = tuple(
+                (arg, getattr(entry, arg)) for arg in self._group_by_keys
+            )
+            group_identity = tuple(
+                (arg, _freeze_group_value(value)) for arg, value in group_by_value
+            )
+            group_by_values.setdefault(group_identity, group_by_value)
 
         groups: list[GroupManager[GeneralManagerType]] = []
-        for group_by_value in sorted(group_by_values, key=str):
+        for group_by_value in sorted(group_by_values.values(), key=str):
             group_by_dict = {key: value for key, value in group_by_value}
-            grouped_manager_objects = data.filter(**group_by_dict)
+            grouped_manager_objects = data.filter(
+                **_group_filter_kwargs(self._manager_class, group_by_value)
+            )
             groups.append(
                 GroupManager(
                     self._manager_class, group_by_dict, grouped_manager_objects

{generalmanager-0.41.7 → generalmanager-0.41.9}/src/general_manager/interface/capabilities/orm_utils/field_descriptors.py

@@ -567,6 +567,10 @@ def _iter_foreign_key_fields(
         An iterable of Django `Field` objects for each many-to-one or one-to-one relation on the model, excluding `GenericForeignKey` fields.
     """
     for field in model._meta.get_fields():
+        if getattr(field, "auto_created", False) and not getattr(
+            field, "concrete", False
+        ):
+            continue
         if not field.is_relation:
             continue
         if isinstance(field, GenericForeignKey):

{generalmanager-0.41.7 → generalmanager-0.41.9}/src/general_manager/manager/group_manager.py

@@ -12,6 +12,35 @@ from general_manager.bucket.base_bucket import (
 )
 
 
+def _freeze_manager_value(value: Any) -> Any:
+    """Return a hashable representation for manager-backed group state."""
+    if isinstance(value, GeneralManager):
+        return tuple(
+            sorted(
+                (
+                    key,
+                    _freeze_manager_value(identifier),
+                )
+                for key, identifier in value.identification.items()
+            )
+        )
+    if isinstance(value, dict):
+        return tuple(
+            sorted(
+                (
+                    _freeze_manager_value(key),
+                    _freeze_manager_value(item),
+                )
+                for key, item in value.items()
+            )
+        )
+    if isinstance(value, (list, tuple)):
+        return tuple(_freeze_manager_value(item) for item in value)
+    if isinstance(value, set):
+        return frozenset(_freeze_manager_value(item) for item in value)
+    return value
+
+
 class MissingGroupAttributeError(AttributeError):
     """Raised when a GroupManager access attempts to use an undefined attribute."""
 
@@ -61,8 +90,8 @@ class GroupManager(Generic[GeneralManagerType]):
         return hash(
             (
                 self._manager_class,
-                tuple(self._group_by_value.items()),
-                frozenset(self._data),
+                _freeze_manager_value(self._group_by_value),
+                frozenset(_freeze_manager_value(entry) for entry in self._data),
             )
         )
 
@@ -80,7 +109,8 @@ class GroupManager(Generic[GeneralManagerType]):
             isinstance(other, self.__class__)
             and self._manager_class == other._manager_class
             and self._group_by_value == other._group_by_value
-            and frozenset(self._data) == frozenset(other._data)
+            and frozenset(_freeze_manager_value(entry) for entry in self._data)
+            == frozenset(_freeze_manager_value(entry) for entry in other._data)
         )
 
     def __repr__(self) -> str: