GeneralManager 0.37.2__tar.gz → 0.37.4__tar.gz

{generalmanager-0.37.2/src/GeneralManager.egg-info → generalmanager-0.37.4}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.37.2
+Version: 0.37.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.37.2 → generalmanager-0.37.4}/src/GeneralManager.egg-info/SOURCES.txt

@@ -166,6 +166,7 @@ src/general_manager/utils/none_to_zero.py
 src/general_manager/utils/path_mapping.py
 src/general_manager/utils/public_api.py
 src/general_manager/utils/testing.py
+src/general_manager/utils/type_checks.py
 src/general_manager/workflow/__init__.py
 src/general_manager/workflow/actions.py
 src/general_manager/workflow/backend_registry.py

{generalmanager-0.37.2 → generalmanager-0.37.4}/src/general_manager/api/graphql.py

@@ -39,6 +39,7 @@ from general_manager.interface.base_interface import InterfaceBase
 from general_manager.logging import get_logger
 from general_manager.manager.general_manager import GeneralManager
 from general_manager.measurement.measurement import Measurement
+from general_manager.utils.type_checks import safe_issubclass
 
 from graphql import GraphQLError
 
@@ -404,7 +405,7 @@ class GraphQL:
             field_info,
         ) in generalManagerClass.Interface.get_attribute_types().items():
             field_type = field_info["type"]
-            if issubclass(field_type, GeneralManager):
+            if safe_issubclass(field_type, GeneralManager):
                 continue
             else:
                 sort_options.append(field_name)
@@ -546,9 +547,9 @@ class GraphQL:
         Returns:
             Any: Graphene field or type configured for the attribute.
         """
-        if issubclass(field_type, Measurement):
+        if safe_issubclass(field_type, Measurement):
             return graphene.Field(MeasurementType, target_unit=graphene.String())
-        elif issubclass(field_type, GeneralManager):
+        elif safe_issubclass(field_type, GeneralManager):
             if field_name.endswith("_list"):
                 attributes: dict[str, Any] = {
                     "reverse": graphene.Boolean(),
@@ -714,7 +715,7 @@ class GraphQL:
             input_field_name,
             input_field,
         ) in generalManagerClass.Interface.input_fields.items():
-            if issubclass(input_field.type, GeneralManager):
+            if safe_issubclass(input_field.type, GeneralManager):
                 key = f"{input_field_name}_id"
                 identification_fields[key] = graphene.Argument(
                     graphene.ID, required=input_field.required

{generalmanager-0.37.2 → generalmanager-0.37.4}/src/general_manager/api/graphql_mutations.py

@@ -19,6 +19,7 @@ from django.db.models import NOT_PROVIDED
 
 from general_manager.interface.base_interface import InterfaceBase
 from general_manager.manager.general_manager import GeneralManager
+from general_manager.utils.type_checks import safe_issubclass
 from general_manager.api.graphql_errors import (
     HANDLED_MANAGER_ERRORS,
     MissingManagerIdentifierError,
@@ -30,6 +31,36 @@ if TYPE_CHECKING:
     from graphene import ResolveInfo as GraphQLResolveInfo
 
 
+def _normalize_mutation_kwargs_for_manager(
+    general_manager_class: type[GeneralManager],
+    kwargs: dict[str, Any],
+) -> dict[str, Any]:
+    """Normalize GraphQL relation aliases to the ORM mutation contract."""
+    interface_cls = getattr(general_manager_class, "Interface", None)
+    if interface_cls is None:
+        return dict(kwargs)
+
+    attribute_types = interface_cls.get_attribute_types()
+    normalized = dict(kwargs)
+
+    for key in list(kwargs.keys()):
+        if key.endswith("_list") and not key.endswith("_id_list"):
+            base_key = key.removesuffix("_list")
+            if base_key in attribute_types:
+                normalized.setdefault(f"{base_key}_id_list", normalized[key])
+                normalized.pop(key, None)
+                continue
+
+        if key.startswith("_") and not key.endswith("_id"):
+            type_info = attribute_types.get(key)
+            relation_type = type_info["type"] if type_info is not None else None
+            if safe_issubclass(relation_type, GeneralManager):
+                normalized.setdefault(f"{key}_id", normalized[key])
+                normalized.pop(key, None)
+
+    return normalized
+
+
 # ---------------------------------------------------------------------------
 # Write-field helpers
 # ---------------------------------------------------------------------------
@@ -64,7 +95,7 @@ def create_write_fields(interface_cls: InterfaceBase) -> dict[str, Any]:
         default = info["default"]
 
         fld: Any
-        if issubclass(typ, GeneralManager):
+        if safe_issubclass(typ, GeneralManager):
             if name.endswith("_list"):
                 fld = graphene.List(graphene.ID, required=req, default_value=default)
             else:
@@ -125,6 +156,7 @@ def generate_create_mutation_class(
                 for field_name, value in kwargs.items()
                 if value is not NOT_PROVIDED
             }
+            kwargs = _normalize_mutation_kwargs_for_manager(generalManagerClass, kwargs)
             instance = generalManagerClass.create(
                 **kwargs, creator_id=info.context.user.id
             )
@@ -184,6 +216,12 @@ def generate_update_mutation_class(
         if manager_id is None:
             raise handle_graph_ql_error(MissingManagerIdentifierError())
         try:
+            kwargs = {
+                field_name: value
+                for field_name, value in kwargs.items()
+                if value is not NOT_PROVIDED
+            }
+            kwargs = _normalize_mutation_kwargs_for_manager(generalManagerClass, kwargs)
             instance = generalManagerClass(id=manager_id).update(
                 creator_id=info.context.user.id, **kwargs
             )

{generalmanager-0.37.2 → generalmanager-0.37.4}/src/general_manager/api/graphql_resolvers.py

@@ -20,6 +20,7 @@ from general_manager.bucket.base_bucket import Bucket
 from general_manager.manager.general_manager import GeneralManager
 from general_manager.measurement.measurement import Measurement
 from general_manager.api.graphql_errors import get_read_permission_filter
+from general_manager.utils.type_checks import safe_issubclass
 
 if TYPE_CHECKING:
     from graphene import ResolveInfo as GraphQLResolveInfo
@@ -505,10 +506,10 @@ def create_resolver(field_name: str, field_type: type) -> Callable[..., Any]:
     :class:`~general_manager.measurement.Measurement` fields, and
     :func:`create_normal_resolver` for everything else.
     """
-    if field_name.endswith("_list") and issubclass(field_type, GeneralManager):
+    if field_name.endswith("_list") and safe_issubclass(field_type, GeneralManager):
         return create_list_resolver(
             lambda self, _include_inactive: getattr(self, field_name), field_type
         )
-    if issubclass(field_type, Measurement):
+    if safe_issubclass(field_type, Measurement):
         return create_measurement_resolver(field_name)
     return create_normal_resolver(field_name)

{generalmanager-0.37.2 → generalmanager-0.37.4}/src/general_manager/api/graphql_search.py

@@ -31,6 +31,7 @@ from django.utils import timezone
 from general_manager.logging import get_logger
 from general_manager.manager.general_manager import GeneralManager
 from general_manager.measurement.measurement import Measurement
+from general_manager.utils.type_checks import safe_issubclass
 from general_manager.search.backend_registry import get_search_backend
 from general_manager.search.registry import (
     get_search_config,
@@ -318,28 +319,30 @@ def get_filter_options(
         "endswith",
     ]
 
-    if issubclass(attribute_type, GeneralManager):
+    normalized_type = attribute_type if isinstance(attribute_type, type) else str
+
+    if safe_issubclass(normalized_type, GeneralManager):
         yield attribute_name, None
-    elif issubclass(attribute_type, Measurement):
+    elif safe_issubclass(normalized_type, Measurement):
         yield attribute_name, MeasurementScalar()
         for option in number_options:
             yield f"{attribute_name}__{option}", MeasurementScalar()
     else:
         yield (
             attribute_name,
-            map_field_to_graphene_read(attribute_type, attribute_name, attr_info),
+            map_field_to_graphene_read(normalized_type, attribute_name, attr_info),
         )
-        if issubclass(attribute_type, (int, float, Decimal, date, datetime)):
+        if safe_issubclass(normalized_type, (int, float, Decimal, date, datetime)):
             for option in number_options:
                 yield (
                     f"{attribute_name}__{option}",
                     map_field_to_graphene_read(
-                        attribute_type, attribute_name, attr_info
+                        normalized_type, attribute_name, attr_info
                     ),
                 )
-        elif issubclass(attribute_type, str):
+        elif safe_issubclass(normalized_type, str):
             base_type = map_field_to_graphene_base_type(
-                attribute_type,
+                normalized_type,
                 attr_info.get("graphql_scalar") if attr_info else None,
             )
             for option in string_options:
@@ -349,7 +352,7 @@ def get_filter_options(
                     yield (
                         f"{attribute_name}__{option}",
                         map_field_to_graphene_read(
-                            attribute_type, attribute_name, attr_info
+                            normalized_type, attribute_name, attr_info
                         ),
                     )
 

{generalmanager-0.37.2 → generalmanager-0.37.4}/src/general_manager/interface/capabilities/orm_utils/field_descriptors.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
+import re
 from typing import TYPE_CHECKING, Any, Callable, Iterable, Optional, cast
 from uuid import UUID
 
@@ -75,6 +76,13 @@ def _graphql_scalar_hint(raw_type: type) -> str | None:
     return None
 
 
+def _to_snake_case(name: str) -> str:
+    """Convert a CamelCase class name into snake_case."""
+    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()
+
+
 def build_field_descriptors(
     interface_cls: type["OrmInterfaceBase"],
     resolve_many: Callable[["OrmInterfaceBase", str, str], Any] | None = None,
@@ -214,9 +222,21 @@ class _FieldDescriptorBuilder:
             accessor_name = (
                 reverse_relation.get_accessor_name() or reverse_relation.name
             )
+            explicit_accessor = getattr(reverse_relation.field, "_related_name", None)
+            related_model = getattr(reverse_relation, "related_model", None)
+            if (
+                isinstance(explicit_accessor, str)
+                and explicit_accessor
+                and explicit_accessor != "+"
+            ):
+                base_name = explicit_accessor
+            elif related_model is not None:
+                base_name = _to_snake_case(related_model.__name__)
+            else:
+                base_name = reverse_relation.name
             self._register_collection_field(
                 field=reverse_relation,
-                base_name=reverse_relation.name,
+                base_name=base_name,
                 accessor_name=accessor_name,
                 relation_field_name=getattr(reverse_relation.field, "name", None),
             )

{generalmanager-0.37.2 → generalmanager-0.37.4}/src/general_manager/interface/capabilities/orm_utils/payload_normalizer.py

@@ -23,6 +23,11 @@ class PayloadNormalizer:
         self._attributes = set(vars(model).keys())
         self._field_names = {field.name for field in model._meta.get_fields()}
         self._many_to_many_fields = {field.name for field in model._meta.many_to_many}
+        self._relation_fields = {
+            field.name
+            for field in model._meta.get_fields()
+            if isinstance(field, (models.ForeignKey, models.OneToOneField))
+        }
 
     # region filter/exclude helpers
     def normalize_filter_kwargs(self, kwargs: dict[str, Any]) -> dict[str, Any]:
@@ -51,8 +56,11 @@ class PayloadNormalizer:
             UnknownFieldError: If any key's base name is not an attribute of the model instance and not a model field name.
         """
         for key in kwargs:
-            base_key = key.split("_id_list")[0]
-            if base_key not in self._attributes and base_key not in self._field_names:
+            candidate_key = self._key_for_validation(key)
+            if (
+                candidate_key not in self._attributes
+                and candidate_key not in self._field_names
+            ):
                 raise UnknownFieldError(key, self.model.__name__)
 
     def split_many_to_many(
@@ -72,9 +80,9 @@ class PayloadNormalizer:
         """
         many_kwargs: dict[str, Any] = {}
         for key, _value in list(kwargs.items()):
-            base_key = key.split("_id_list")[0]
+            base_key = self._m2m_alias_base_key(key)
             if base_key in self._many_to_many_fields:
-                many_kwargs[key] = kwargs.pop(key)
+                many_kwargs[f"{base_key}_id_list"] = kwargs.pop(key)
         return kwargs, many_kwargs
 
     def normalize_simple_values(self, kwargs: dict[str, Any]) -> dict[str, Any]:
@@ -99,6 +107,13 @@ class PayloadNormalizer:
                 normalized_value = manager_value
             elif manager_value is not None:
                 normalized_value = manager_value
+            elif (
+                key in self._relation_fields
+                and not key.endswith("_id")
+                and not isinstance(value, models.Model)
+                and value is not None
+            ):
+                normalized_key = f"{key}_id"
             normalized[normalized_key] = normalized_value
         return normalized
 
@@ -133,6 +148,15 @@ class PayloadNormalizer:
 
     # endregion
 
+    def _key_for_validation(self, key: str) -> str:
+        """Resolve relation list aliases only when they target real M2M fields."""
+        base_key = self._m2m_alias_base_key(key)
+        return base_key if base_key in self._many_to_many_fields else key
+
+    def _m2m_alias_base_key(self, key: str) -> str:
+        """Return the base key for M2M alias forms, or the original key."""
+        return _base_field_name(key)
+
     @staticmethod
     def _unwrap_manager(value: Any) -> Any:
         """
@@ -200,3 +224,16 @@ def _general_manager_base() -> type | None:
     except ImportError:  # pragma: no cover - defensive
         return None
     return GeneralManager
+
+
+def _base_field_name(key: str) -> str:
+    """
+    Normalize payload key suffixes used for relation list fields.
+
+    Accepts both canonical (`*_id_list`) and GraphQL-facing (`*_list`) spellings.
+    """
+    if key.endswith("_id_list"):
+        return key[: -len("_id_list")]
+    if key.endswith("_list"):
+        return key[: -len("_list")]
+    return key

generalmanager-0.37.4/src/general_manager/utils/type_checks.py

@@ -0,0 +1,8 @@
+"""Type-checking helpers shared across the codebase."""
+
+from __future__ import annotations
+
+
+def safe_issubclass(candidate: object, parent: type | tuple[type, ...]) -> bool:
+    """Return True when *candidate* is a class and a subclass of *parent*."""
+    return isinstance(candidate, type) and issubclass(candidate, parent)