GeneralManager 0.86.2__tar.gz → 0.86.4__tar.gz

{generalmanager-0.86.2/src/GeneralManager.egg-info → generalmanager-0.86.4}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.86.2
+Version: 0.86.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.86.2 → generalmanager-0.86.4}/src/general_manager/permission/manager_based_permission.py

@@ -220,6 +220,20 @@ class _ConfiguredManagerPermission(BasePermission):
             return None
 
         basis_object = getattr(self.instance, __based_on__, notExistent)
+        normalized_basis = False
+        if (
+            isinstance(self.instance, PermissionDataManager)
+            and isinstance(self.instance.permission_data, dict)
+            and self.instance.manager is not None
+            and f"{__based_on__}_id" in self.instance.permission_data
+        ):
+            field_type = self.instance.manager.Interface.get_field_type(__based_on__)
+            if isinstance(field_type, type) and issubclass(field_type, GeneralManager):
+                # Match ORM payload normalization: the last relation alias wins.
+                for key, value in self.instance.permission_data.items():
+                    if key in (__based_on__, f"{__based_on__}_id"):
+                        basis_object = value
+                        normalized_basis = key != __based_on__
         if (
             basis_object is not None
             and basis_object is not notExistent
@@ -232,6 +246,24 @@ class _ConfiguredManagerPermission(BasePermission):
                 if isinstance(basis_object, dict):
                     basis_object = field_type(**basis_object)
                 else:
+                    if normalized_basis:
+                        from django.db.models import ForeignKey
+                        from general_manager.interface.orm_interface import (
+                            OrmInterfaceBase,
+                        )
+
+                        interface = self.instance.manager.Interface
+                        if issubclass(interface, OrmInterfaceBase):
+                            relation = interface._model._meta.get_field(__based_on__)
+                            if (
+                                isinstance(relation, ForeignKey)
+                                and not relation.target_field.primary_key
+                            ):
+                                # A normalized FK value can target a unique non-PK field.
+                                related = relation.related_model._default_manager.get(
+                                    **{relation.target_field.name: basis_object}
+                                )
+                                basis_object = related.pk
                     basis_object = field_type(id=basis_object)
         if basis_object is notExistent:
             if self._is_class_context:

{generalmanager-0.86.2 → generalmanager-0.86.4}/src/general_manager/permission/permission_data_manager.py

@@ -110,7 +110,11 @@ class PermissionDataManager(Generic[GeneralManagerData]):
         Returns:
             Wrapper exposing the merged permission state.
         """
-        merged_data: dict[str, object] = {**dict(base_data), **update_data}
+        # Keep explicit updates after existing state, including relation aliases.
+        merged_data: dict[str, object] = {
+            key: value for key, value in base_data if key not in update_data
+        }
+        merged_data.update(update_data)
         return cls(merged_data, base_data.__class__)
 
     @property

{generalmanager-0.86.2 → generalmanager-0.86.4}/src/general_manager/search/backends/meilisearch.py

@@ -171,7 +171,10 @@ class MeilisearchBackend:
         Non-iterable setting values and strings/bytes are ignored; iterable
         values such as lists, tuples, and sets are converted to strings. This
         method creates the index with primary key ``id`` if it does not exist
-        and waits for each settings update task to complete before returning.
+        and compares current effective settings before writing changes. Ranking
+        rules and searchable fields retain their order; plain filterable and
+        sortable fields are compared by membership. Each submitted settings
+        task completes before the next update or return.
 
         Raises:
             MeilisearchTaskFailedError: A create-index or settings task fails,
@@ -205,23 +208,31 @@ class MeilisearchBackend:
                 *sorted(shadow_fields - set(filterable_fields)),
             ]
         sortable_fields = self._string_sequence_setting(settings, "sortable_fields")
-        ranking_rules = self._ranking_rules_with_sort_first(index, settings)
-        task = index.update_settings({"rankingRules": ranking_rules})
-        self._wait_for_task(task)
-        if searchable_fields is not None:
-            task = index.update_settings(
-                {"searchableAttributes": list(searchable_fields)}
-            )
-            self._wait_for_task(task)
-        if filterable_fields is not None:
-            task = index.update_settings(
-                {"filterableAttributes": list(filterable_fields)}
-            )
-            self._wait_for_task(task)
-        if sortable_fields is not None:
-            task = index.update_settings({"sortableAttributes": list(sortable_fields)})
+        current = self._as_mapping(index.get_settings())
+        desired = {
+            "rankingRules": self._ranking_rules_with_sort_first(current, settings),
+            "searchableAttributes": searchable_fields,
+            "filterableAttributes": filterable_fields,
+            "sortableAttributes": sortable_fields,
+        }
+        for key, fields in desired.items():
+            if fields is None or self._settings_match(key, current.get(key), fields):
+                continue
+            task = index.update_settings({key: fields})
             self._wait_for_task(task)
 
+    @staticmethod
+    def _settings_match(key: str, current: object, desired: list[str]) -> bool:
+        """Compare ordered rules/search fields and unordered plain field lists."""
+        if not isinstance(current, Sequence) or isinstance(current, (str, bytes)):
+            return False
+        # Structured filter rules have different semantics from plain names.
+        if not all(isinstance(field, str) for field in current):
+            return False
+        if key in {"filterableAttributes", "sortableAttributes"}:
+            return set(current) == set(desired)
+        return list(current) == desired
+
     def upsert(self, index_name: str, documents: Sequence[SearchDocument]) -> None:
         """
         Ensure the index exists, then index or update the given documents and wait for the indexing task to complete.
@@ -419,7 +430,7 @@ class MeilisearchBackend:
 
     @staticmethod
     def _ranking_rules_with_sort_first(
-        index: _MeilisearchIndex, settings: Mapping[str, object]
+        current: Mapping[str, object], settings: Mapping[str, object]
     ) -> list[str]:
         configured = settings.get("ranking_rules")
         if isinstance(configured, Sequence) and not isinstance(
@@ -427,8 +438,7 @@ class MeilisearchBackend:
         ):
             rules = [str(rule) for rule in configured]
         else:
-            payload = MeilisearchBackend._as_mapping(index.get_settings())
-            raw_rules = payload.get("rankingRules", ())
+            raw_rules = current.get("rankingRules", ())
             rules = (
                 [str(rule) for rule in raw_rules]
                 if isinstance(raw_rules, Sequence)