GeneralManager 0.86.7__tar.gz → 0.86.9__tar.gz

{generalmanager-0.86.7/src/GeneralManager.egg-info → generalmanager-0.86.9}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.86.7
+Version: 0.86.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.86.7 → generalmanager-0.86.9}/src/general_manager/bucket/calculation_bucket.py

@@ -1283,11 +1283,27 @@ class CalculationBucket(Bucket[GeneralManagerType]):
                     **exclude_kwargs
                 )
             else:
-                filter_funcs = field_filters.get("filter_funcs", [])
+                filter_funcs = [
+                    *field_filters.get("filter_funcs", []),
+                    *(
+                        create_filter_function(lookup, expected)
+                        for lookup, expected in field_filters.get(
+                            "filter_kwargs", {}
+                        ).items()
+                    ),
+                ]
                 for filter_func in filter_funcs:
                     possible_values = filter(filter_func, possible_values)
 
-                exclude_funcs = field_excludes.get("filter_funcs", [])
+                exclude_funcs = [
+                    *field_excludes.get("filter_funcs", []),
+                    *(
+                        create_filter_function(lookup, expected)
+                        for lookup, expected in field_excludes.get(
+                            "filter_kwargs", {}
+                        ).items()
+                    ),
+                ]
                 for exclude_func in exclude_funcs:
                     possible_values = filter(
                         _build_exclude_filter(exclude_func), possible_values

{generalmanager-0.86.7 → generalmanager-0.86.9}/src/general_manager/interface/capabilities/orm/support.py

@@ -4,14 +4,13 @@ from __future__ import annotations
 
 import re
 from collections.abc import Hashable
-from datetime import date, datetime, timedelta
+from datetime import date, datetime
 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 DEFAULT_DB_ALIAS, connections, models
 from django.db.models import Subquery
-from django.utils import timezone
 from general_manager.as_of import (
     HistoricalReadNotSupportedError,
     InvalidSearchDateError,
@@ -347,54 +346,51 @@ class OrmReadCapability(BaseCapability):
                 instance = None
                 missing_error = error
             if search_date is not None:
-                if search_date <= timezone.now() - timedelta(
-                    seconds=interface_cls.historical_lookup_buffer_seconds
-                ):
-                    from .history import HistoryNotSupportedError
+                from .history import HistoryNotSupportedError
 
-                    if current_as_of_date() is not None and not hasattr(
-                        model_cls, "history"
-                    ):
-                        history_unavailable = HistoryNotSupportedError(
+                if current_as_of_date() is not None and not hasattr(
+                    model_cls, "history"
+                ):
+                    history_unavailable = HistoryNotSupportedError(
+                        interface_cls.__name__
+                    )
+                    raise HistoricalReadNotSupportedError(
+                        interface_cls.__name__
+                    ) from history_unavailable
+                historical: models.Model | None
+                try:
+                    history_handler = _history_capability_for(interface_cls)
+                except (NotImplementedError, TypeError) as error:
+                    if current_as_of_date() is not None:
+                        raise HistoricalReadNotSupportedError(
                             interface_cls.__name__
+                        ) from error
+                    history_error = HistoryNotSupportedError(interface_cls.__name__)
+                    raise history_error from error
+                try:
+                    if instance is not None:
+                        historical = history_handler.get_historical_record(
+                            interface_cls,
+                            instance,
+                            search_date,
                         )
+                    else:
+                        historical = history_handler.get_historical_record_by_pk(
+                            interface_cls,
+                            pk,
+                            search_date,
+                        )
+                except HistoryNotSupportedError as error:
+                    if current_as_of_date() is not None:
                         raise HistoricalReadNotSupportedError(
                             interface_cls.__name__
-                        ) from history_unavailable
-                    historical: models.Model | None
-                    try:
-                        history_handler = _history_capability_for(interface_cls)
-                    except (NotImplementedError, TypeError) as error:
-                        if current_as_of_date() is not None:
-                            raise HistoricalReadNotSupportedError(
-                                interface_cls.__name__
-                            ) from error
-                        history_error = HistoryNotSupportedError(interface_cls.__name__)
-                        raise history_error from error
-                    try:
-                        if instance is not None:
-                            historical = history_handler.get_historical_record(
-                                interface_cls,
-                                instance,
-                                search_date,
-                            )
-                        else:
-                            historical = history_handler.get_historical_record_by_pk(
-                                interface_cls,
-                                pk,
-                                search_date,
-                            )
-                    except HistoryNotSupportedError as error:
-                        if current_as_of_date() is not None:
-                            raise HistoricalReadNotSupportedError(
-                                interface_cls.__name__
-                            ) from error
-                        raise
-                    if historical is not None:
-                        return historical
-                    if missing_error is not None:
-                        raise missing_error
-                    raise model_cls.DoesNotExist
+                        ) from error
+                    raise
+                if historical is not None:
+                    return historical
+                if missing_error is not None:
+                    raise missing_error
+                raise model_cls.DoesNotExist
             if instance is not None:
                 return instance
             if missing_error is not None:
@@ -899,9 +895,7 @@ class OrmQueryCapability(BaseCapability):
         support = get_support_capability(interface_cls)
         if support.__class__ is not OrmPersistenceSupportCapability:
             return None
-        if search_date is not None and search_date <= timezone.now() - timedelta(
-            seconds=interface_cls.historical_lookup_buffer_seconds
-        ):
+        if search_date is not None:
             return None
         queryset_base = (
             support.get_manager(interface_cls, only_active=False).all()
@@ -993,9 +987,7 @@ class OrmQueryCapability(BaseCapability):
                     only_active=False,
                 ).all(),
             )
-        if search_date is not None and search_date <= timezone.now() - timedelta(
-            seconds=interface_cls.historical_lookup_buffer_seconds
-        ):
+        if search_date is not None:
             from .history import HistoryNotSupportedError
 
             try:

{generalmanager-0.86.7 → generalmanager-0.86.9}/src/general_manager/interface/interfaces/existing_model.py

@@ -41,8 +41,8 @@ class ExistingModelInterface(OrmInterfaceBase[ExistingModelT]):
     Construction and row loading are inherited from ``OrmInterfaceBase``: the
     default public input is the wrapped row ``id`` parsed by ``Input(int)`` plus
     optional ``search_date: datetime | None``. Naive search dates are made aware
-    with Django's current timezone, and historical lookups follow
-    ``OrmInterfaceBase.historical_lookup_buffer_seconds``. Missing rows
+    with Django's current timezone, and every supplied search date selects
+    history without a recency buffer. Missing rows
     propagate the wrapped model's ``DoesNotExist`` exception. Invalid or missing
     model declarations raise the existing-model configuration errors from the
     resolution capability. Creation, update, delete, query, history, and

{generalmanager-0.86.7 → generalmanager-0.86.9}/src/general_manager/interface/orm_interface.py

@@ -41,9 +41,9 @@ class OrmInterfaceBase(InterfaceBase, Generic[HistoryModelT]):
     lifecycle capability. Subclasses that override :attr:`input_fields` must keep
     an ``"id"`` field unless they also override initialization and row loading.
 
-    ``historical_lookup_buffer_seconds`` is consumed by ORM query support: a
-    ``search_date`` must be at least this many seconds before ``timezone.now()``
-    before history tables are queried instead of the current row.
+    Every non-null ``search_date`` reads the exact historical snapshot, including
+    recent timestamps. ``historical_lookup_buffer_seconds`` is retained only for
+    source compatibility and no longer permits a fallback to current rows.
     """
 
     _interface_type: ClassVar[str] = "database"