GeneralManager 0.63.0__tar.gz → 0.63.2__tar.gz

{generalmanager-0.63.0/src/GeneralManager.egg-info → generalmanager-0.63.2}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.63.0"
+version = "0.63.2"
 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" }]
@@ -93,8 +93,6 @@ major_on_zero = false
 version_toml = ["pyproject.toml:project.version"]
 branch = "main"
 build_command = "python -m build"
-upload_to_PyPI = true
-upload_to_release = true
 
 [tool.semantic_release.remote]
 ignore_token_for_push = true

{generalmanager-0.63.0 → generalmanager-0.63.2/src/GeneralManager.egg-info}/PKG-INFO

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

@@ -173,6 +173,7 @@ src/general_manager/interface/manifests/capability_models.py
 src/general_manager/interface/utils/__init__.py
 src/general_manager/interface/utils/database_interface_protocols.py
 src/general_manager/interface/utils/errors.py
+src/general_manager/interface/utils/history.py
 src/general_manager/interface/utils/models.py
 src/general_manager/management/commands/chat_cleanup.py
 src/general_manager/management/commands/cleanup_upload_intents.py

{generalmanager-0.63.0 → generalmanager-0.63.2}/src/general_manager/interface/capabilities/existing_model/resolution.py

@@ -6,13 +6,18 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, ClassVar, cast
 
 from django.apps import apps
-from django.db import models
+from django.db import DEFAULT_DB_ALIAS, models
 from simple_history import register
 
 from general_manager.factory.auto_factory import AutoFactory
 from general_manager.interface.utils.errors import (
     InvalidModelReferenceError,
     MissingModelConfigurationError,
+    UnsafeHistoryConfigurationError,
+)
+from general_manager.interface.utils.history import (
+    DATABASE_AWARE_HISTORY_MARKER,
+    DatabaseAwareHistoricalRecords,
 )
 from general_manager.interface.utils.models import get_full_clean_methode
 
@@ -127,14 +132,36 @@ class ExistingModelResolutionCapability(BaseCapability):
 
         def _perform() -> None:
             """
-            Register simple history for the captured Django model if history is not already present.
+            Ensure the captured model has history tracking compatible with its interface database alias.
 
-            If the model's _meta already exposes the simple_history manager attribute, no action is taken. Otherwise, collects the model's local many-to-many field names and registers the model with simple_history including those m2m fields.
+            An untracked model is registered with database-aware history and all local many-to-many fields. An existing tracker is accepted for the default alias; a non-default alias requires GeneralManager's database-aware marker and otherwise raises `UnsafeHistoryConfigurationError`.
             """
             if hasattr(model._meta, "simple_history_manager_attribute"):
+                database_alias = (
+                    getattr(interface_cls, "database", None) if interface_cls else None
+                )
+                if database_alias and database_alias != DEFAULT_DB_ALIAS:
+                    assert interface_cls is not None
+                    manager_name = model._meta.simple_history_manager_attribute
+                    history_model = getattr(model, manager_name).model
+                    if not getattr(
+                        history_model,
+                        DATABASE_AWARE_HISTORY_MARKER,
+                        False,
+                    ):
+                        raise UnsafeHistoryConfigurationError(
+                            model.__name__,
+                            interface_cls.__name__,
+                            database_alias,
+                        )
                 return
             m2m_fields = [field.name for field in model._meta.local_many_to_many]
-            register(model, m2m_fields=m2m_fields)
+            register(
+                model,
+                m2m_fields=m2m_fields,
+                records_class=DatabaseAwareHistoricalRecords,
+                use_base_model_db=True,
+            )
 
         target = interface_cls or model
         return call_with_observability(

{generalmanager-0.63.0 → generalmanager-0.63.2}/src/general_manager/interface/capabilities/orm/__init__.py

@@ -5,7 +5,9 @@ from __future__ import annotations
 from general_manager.interface.capabilities.core.utils import (
     with_observability as with_observability,
 )
-from simple_history.utils import update_change_reason as update_change_reason
+from general_manager.interface.utils.history import (
+    update_change_reason as update_change_reason,
+)
 
 from .history import HistoryNotSupportedError, OrmHistoryCapability
 from .lifecycle import OrmLifecycleCapability

{generalmanager-0.63.0 → generalmanager-0.63.2}/src/general_manager/interface/capabilities/orm/_compat.py

@@ -52,8 +52,8 @@ def call_update_change_reason(instance: models.Model, reason: str) -> None:
     Delegate invocation to the package-level `update_change_reason` callable.
 
     This resolves the callable from `general_manager.interface.capabilities.orm` at call time so that runtime patches to that attribute are respected.
-    The default package-level callable is django-simple-history's
-    `update_change_reason`. If simple-history is absent from the model, if a
+    The default package-level callable is GeneralManager's database-aware
+    change-reason wrapper. If simple-history is absent from the model, if a
     patched callable is missing expected behavior, or if the callable raises,
     that exception propagates unchanged.
 

{generalmanager-0.63.0 → generalmanager-0.63.2}/src/general_manager/interface/capabilities/orm/mutations.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar
 from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from django.contrib.auth import get_user_model
@@ -48,6 +51,21 @@ type MutationPayload = dict[str, object]
 type ManyToManyPayload = dict[str, list[object]]
 type MutationResult = dict[str, object]
 
+_save_with_history_savepoint = ContextVar(
+    "save_with_history_savepoint",
+    default=True,
+)
+
+
+@contextmanager
+def _without_save_with_history_savepoint() -> Iterator[None]:
+    """Suppress the nested savepoint within an encompassing mutation atomic."""
+    token = _save_with_history_savepoint.set(False)
+    try:
+        yield
+    finally:
+        _save_with_history_savepoint.reset(token)
+
 
 class OrmMutationCapability(BaseCapability):
     """Common utilities to modify ORM instances."""
@@ -156,11 +174,19 @@ class OrmMutationCapability(BaseCapability):
             database_alias = support.get_database_alias(interface_cls)
             if database_alias:
                 instance._state.db = database_alias
-            atomic_context = (
-                transaction.atomic(using=database_alias)
-                if database_alias
-                else transaction.atomic()
-            )
+            savepoint = _save_with_history_savepoint.get()
+            if database_alias:
+                atomic_context = (
+                    transaction.atomic(using=database_alias)
+                    if savepoint
+                    else transaction.atomic(using=database_alias, savepoint=False)
+                )
+            else:
+                atomic_context = (
+                    transaction.atomic()
+                    if savepoint
+                    else transaction.atomic(savepoint=False)
+                )
             with atomic_context:
                 _assign_history_actor(
                     instance,
@@ -360,18 +386,27 @@ class OrmCreateCapability(BaseCapability):
             instance = mutation.assign_simple_attributes(
                 interface_cls, interface_cls._model(), normalized_simple
             )
-            pk = mutation.save_with_history(
-                interface_cls,
-                instance,
-                creator_id=creator_id,
-                history_comment=history_comment,
-            )
-            mutation.apply_many_to_many(
-                interface_cls,
-                instance,
-                many_to_many_kwargs=normalized_many,
-                history_comment=history_comment,
+            support = get_support_capability(interface_cls)
+            database_alias = support.get_database_alias(interface_cls)
+            atomic_context = (
+                transaction.atomic(using=database_alias)
+                if database_alias
+                else transaction.atomic()
             )
+            with atomic_context:
+                with _without_save_with_history_savepoint():
+                    pk = mutation.save_with_history(
+                        interface_cls,
+                        instance,
+                        creator_id=creator_id,
+                        history_comment=history_comment,
+                    )
+                mutation.apply_many_to_many(
+                    interface_cls,
+                    instance,
+                    many_to_many_kwargs=normalized_many,
+                    history_comment=history_comment,
+                )
             return {"id": pk}
 
         return call_with_observability(
@@ -502,19 +537,27 @@ class OrmUpdateCapability(BaseCapability):
             instance = mutation.assign_simple_attributes(
                 interface_instance.__class__, instance, normalized_simple
             )
-            pk = mutation.save_with_history(
-                interface_instance.__class__,
-                instance,
-                creator_id=creator_id,
-                history_comment=history_comment,
+            database_alias = support.get_database_alias(interface_instance.__class__)
+            atomic_context = (
+                transaction.atomic(using=database_alias)
+                if database_alias
+                else transaction.atomic()
             )
+            with atomic_context:
+                with _without_save_with_history_savepoint():
+                    pk = mutation.save_with_history(
+                        interface_instance.__class__,
+                        instance,
+                        creator_id=creator_id,
+                        history_comment=history_comment,
+                    )
+                mutation.apply_many_to_many(
+                    interface_instance.__class__,
+                    instance,
+                    many_to_many_kwargs=normalized_many,
+                    history_comment=history_comment,
+                )
             discard_orm_instance_cache(interface_instance.__class__, pk)
-            mutation.apply_many_to_many(
-                interface_instance.__class__,
-                instance,
-                many_to_many_kwargs=normalized_many,
-                history_comment=history_comment,
-            )
             return {"id": pk}
 
         return call_with_observability(

{generalmanager-0.63.0 → generalmanager-0.63.2}/src/general_manager/interface/capabilities/orm/support.py

@@ -9,7 +9,7 @@ from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, Type, cast
 
 from django.core.exceptions import FieldDoesNotExist
-from django.db import models
+from django.db import DEFAULT_DB_ALIAS, connections, models
 from django.db.models import Subquery
 from django.utils import timezone
 from general_manager.bucket.database_bucket import DatabaseBucket
@@ -303,14 +303,22 @@ class OrmReadCapability(BaseCapability):
             raise model_cls.DoesNotExist
 
         context = current_calculation_run_context()
-        read_func = (
-            _perform
-            if context is None
-            else lambda: context.get_or_set(
-                _orm_instance_cache_key(interface_instance),
-                _perform,
+        if context is None:
+            read_func = _perform
+        else:
+            interface_cls = interface_instance.__class__
+            support = get_support_capability(interface_cls)
+            database_alias = (
+                support.get_database_alias(interface_cls) or DEFAULT_DB_ALIAS
+            )
+            read_func = (
+                _perform
+                if _connection_has_application_atomic_block(database_alias)
+                else lambda: context.get_or_set(
+                    _orm_instance_cache_key(interface_instance),
+                    _perform,
+                )
             )
-        )
 
         return call_with_observability(
             interface_instance,
@@ -1072,6 +1080,25 @@ def _orm_instance_cache_key(
     )
 
 
+def _connection_has_application_atomic_block(database_alias: str) -> bool:
+    """Return whether a connection is inside a non-TestCase atomic block."""
+    connection = connections[database_alias]
+    try:
+        blocks = getattr(connection, "atomic_blocks")  # noqa: B009
+    except (AttributeError, TypeError):
+        return bool(getattr(connection, "in_atomic_block", False))
+    if not isinstance(blocks, (list, tuple)) or not blocks:
+        return bool(getattr(connection, "in_atomic_block", False))
+
+    def _is_testcase_wrapper(block: object) -> bool:
+        try:
+            return getattr(block, "_from_testcase") is True  # noqa: B009
+        except (AttributeError, TypeError):
+            return False
+
+    return any(not _is_testcase_wrapper(block) for block in blocks)
+
+
 def discard_orm_instance_cache(
     interface_cls: OrmInterfaceClass,
     pk: object,

{generalmanager-0.63.0 → generalmanager-0.63.2}/src/general_manager/interface/interfaces/existing_model.py

@@ -28,13 +28,15 @@ class ExistingModelInterface(OrmInterfaceBase[ExistingModelT]):
     string accepted by ``django.apps.apps.get_model()``, such as
     ``settings.AUTH_USER_MODEL``. During manager class creation the
     ``existing_model_resolution`` lifecycle capability resolves that reference,
-    caches the resolved model on the concrete interface, registers history when
-    needed, applies interface rules, and builds a factory for the legacy model.
-    History registration is skipped when the model already exposes a
-    ``model._meta.simple_history_manager_attribute`` marker; otherwise local
-    many-to-many fields are included in the registration. Interface rules are
-    the optional ``Meta.rules`` sequence on the interface. Soft delete is
-    enabled when the resolved model exposes an ``is_active`` attribute.
+    caches the resolved model on the concrete interface, auto-registers
+    database-aware history when needed, applies interface rules, and builds a
+    factory for the legacy model. Auto-registration includes local many-to-many
+    fields. A pre-registered tracker remains compatible on the default database;
+    on a configured non-default alias, its generated history model must carry
+    GeneralManager's database-aware marker or manager creation raises
+    ``UnsafeHistoryConfigurationError``. Interface rules are the optional
+    ``Meta.rules`` sequence on the interface. Soft delete is enabled when the
+    resolved model exposes an ``is_active`` attribute.
 
     Construction and row loading are inherited from ``OrmInterfaceBase``: the
     default public input is the wrapped row ``id`` parsed by ``Input(int)`` plus

{generalmanager-0.63.0 → generalmanager-0.63.2}/src/general_manager/interface/utils/errors.py

@@ -16,6 +16,7 @@ __all__ = [
     "MissingUniqueFieldError",
     "ReadOnlyRelationLookupError",
     "UnknownFieldError",
+    "UnsafeHistoryConfigurationError",
 ]
 
 
@@ -226,3 +227,14 @@ class InvalidModelReferenceError(TypeError):
             `Invalid model reference '{reference}'.`
         """
         super().__init__(f"Invalid model reference '{reference}'.")
+
+
+class UnsafeHistoryConfigurationError(ValueError):
+    """Raised when pre-registered history cannot follow an interface alias."""
+
+    def __init__(self, model_name: str, interface_name: str, alias: str) -> None:
+        """Build guidance for replacing an unsafe simple-history tracker."""
+        super().__init__(
+            f"{model_name} must use DatabaseAwareHistoricalRecords before "
+            f"{interface_name} configures non-default database alias '{alias}'."
+        )

generalmanager-0.63.2/src/general_manager/interface/utils/history.py

@@ -0,0 +1,139 @@
+"""Database-aware django-simple-history integration helpers."""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+from django.db import DEFAULT_DB_ALIAS, models
+from django.db.models.fields.related import ForeignKey
+from simple_history import utils as simple_history_utils
+from simple_history.models import HistoricalRecords
+from simple_history.signals import (
+    post_create_historical_m2m_records,
+    pre_create_historical_m2m_records,
+)
+from simple_history.utils import get_history_manager_for_model
+
+
+DATABASE_AWARE_HISTORY_MARKER = "_general_manager_database_aware_history"
+
+
+class DatabaseAwareHistoricalRecords(HistoricalRecords):  # type: ignore[misc]
+    """Store generated history records on the base model's database alias."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        kwargs["use_base_model_db"] = True
+        super().__init__(*args, **kwargs)
+
+    def create_history_model(
+        self,
+        model: type[models.Model],
+        inherited: bool,
+    ) -> type[models.Model]:
+        """Mark the generated model as safe for non-default database aliases."""
+        history_model = cast(
+            type[models.Model],
+            super().create_history_model(model, inherited),
+        )
+        setattr(history_model, DATABASE_AWARE_HISTORY_MARKER, True)
+        return history_model
+
+    def create_historical_record(
+        self,
+        instance: models.Model,
+        history_type: str,
+        using: str | None = None,
+    ) -> None:
+        """Route base history even when an M2M signal omits ``using``."""
+        database_alias = using or instance._state.db or DEFAULT_DB_ALIAS
+        super().create_historical_record(
+            instance,
+            history_type,
+            using=database_alias,
+        )
+
+    def create_historical_record_m2ms(
+        self,
+        history_instance: models.Model,
+        instance: models.Model,
+    ) -> None:
+        """Snapshot tracked many-to-many rows on the base instance alias."""
+        database_alias = instance._state.db or history_instance._state.db
+        database_alias = database_alias or DEFAULT_DB_ALIAS
+        history_fields = cast(
+            list[Any],
+            history_instance._history_m2m_fields,  # type: ignore[attr-defined]
+        )
+        for field in history_fields:
+            m2m_history_model = self.m2m_models[field]
+            original_instance = history_instance.instance  # type: ignore[attr-defined]
+            through_model = getattr(original_instance, field.name).through
+            through_model_field_names = [
+                model_field.name for model_field in through_model._meta.fields
+            ]
+            through_model_fk_field_names = [
+                model_field.name
+                for model_field in through_model._meta.fields
+                if isinstance(model_field, ForeignKey)
+            ]
+
+            through_field_name = simple_history_utils.get_m2m_field_name(field)
+            rows = through_model.objects.using(database_alias).filter(
+                **{through_field_name: instance}
+            )
+            rows = rows.select_related(*through_model_fk_field_names)
+            insert_rows = []
+            for row in rows:
+                insert_row = m2m_history_model(
+                    history_id=history_instance.pk,
+                    **{
+                        field_name: getattr(row, field_name)
+                        for field_name in through_model_field_names
+                    },
+                )
+                insert_row._state.db = database_alias
+                insert_rows.append(insert_row)
+
+            pre_create_historical_m2m_records.send(
+                sender=m2m_history_model,
+                rows=insert_rows,
+                history_instance=history_instance,
+                instance=instance,
+                field=field,
+            )
+            created_rows = m2m_history_model.objects.using(database_alias).bulk_create(
+                insert_rows
+            )
+            post_create_historical_m2m_records.send(
+                sender=m2m_history_model,
+                created_rows=created_rows,
+                history_instance=history_instance,
+                instance=instance,
+                field=field,
+            )
+
+
+def update_change_reason(instance: models.Model, reason: str) -> None:
+    """Update the latest history row on the model instance's database alias."""
+    manager_owner: models.Model | type[models.Model]
+    manager_owner = instance if instance.pk is not None else type(instance)
+    history = get_history_manager_for_model(manager_owner)
+    database_alias = instance._state.db
+    if database_alias:
+        history = history.using(database_alias)
+
+    history_fields = {field.attname for field in history.model._meta.fields}
+    attrs: dict[str, object] = {}
+    for field in instance._meta.fields:
+        if field.attname not in history_fields:
+            continue
+        value = getattr(instance, field.attname)
+        if not field.primary_key or value is not None:
+            attrs[field.attname] = value
+
+    record = history.filter(**attrs).order_by("-history_date").first()
+    record.history_change_reason = reason
+    if database_alias:
+        record.save(using=database_alias)
+    else:
+        record.save()

{generalmanager-0.63.0 → generalmanager-0.63.2}/src/general_manager/interface/utils/models.py

@@ -7,9 +7,10 @@ from typing import TYPE_CHECKING, Callable, ClassVar, Protocol, TypeVar, cast
 from django.db import models
 from django.contrib.auth.models import AbstractBaseUser
 from django.core.exceptions import FieldDoesNotExist
-from simple_history.models import HistoricalRecords
 from django.core.exceptions import ValidationError
 
+from general_manager.interface.utils.history import DatabaseAwareHistoricalRecords
+
 
 if TYPE_CHECKING:
     from django.core.exceptions import ValidationErrorMessageArg
@@ -201,7 +202,7 @@ class GeneralManagerBasisModel(models.Model):
     """
 
     _general_manager_class: ClassVar[type[GeneralManager]]
-    history = HistoricalRecords(inherit=True)
+    history = DatabaseAwareHistoricalRecords(inherit=True)
 
     class Meta:
         abstract = True