cardo-python-utils 0.5.dev36__tar.gz → 0.5.dev38__tar.gz

{cardo_python_utils-0.5.dev36/cardo_python_utils.egg-info → cardo_python_utils-0.5.dev38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cardo-python-utils
-Version: 0.5.dev36
+Version: 0.5.dev38
 Summary: Python library enhanced with a wide range of functions for different scenarios.
 Author-email: CardoAI <hello@cardoai.com>
 License: MIT

{cardo_python_utils-0.5.dev36 → cardo_python_utils-0.5.dev38/cardo_python_utils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cardo-python-utils
-Version: 0.5.dev36
+Version: 0.5.dev38
 Summary: Python library enhanced with a wide range of functions for different scenarios.
 Author-email: CardoAI <hello@cardoai.com>
 License: MIT

{cardo_python_utils-0.5.dev36 → cardo_python_utils-0.5.dev38}/cardo_python_utils.egg-info/SOURCES.txt

@@ -37,6 +37,7 @@ python_utils/django/api/ninja.py
 python_utils/django/api/utils.py
 python_utils/django/auth/service.py
 python_utils/django/celery/__init__.py
+python_utils/django/celery/tenant_aware_database_scheduler.py
 python_utils/django/celery/tenant_aware_task.py
 python_utils/django/db/__init__.py
 python_utils/django/db/routers.py

{cardo_python_utils-0.5.dev36 → cardo_python_utils-0.5.dev38}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cardo-python-utils"
-version = "0.5.dev36"
+version = "0.5.dev38"
 description = "Python library enhanced with a wide range of functions for different scenarios."
 readme = "README.rst"
 requires-python = ">=3.8"

{cardo_python_utils-0.5.dev36 → cardo_python_utils-0.5.dev38}/python_utils/django/README.md

@@ -35,11 +35,17 @@ MIDDLEWARE = [
 
 # Include the database configuration for each tenant in the DATABASES setting.
 # You can use the get_database_configs() function from python_utils.django.db.utils as a helper.
-DATABASES = {
-    'tenant1': { ... },
-    'tenant2': { ... },
-    ...
-}
+from python_utils.django.db.utils import get_database_configs
+
+for tenant, tenant_db_config in get_database_configs().items():
+    DATABASES[tenant] = {
+        "ENGINE": "django.db.backends.postgresql",
+        "NAME": tenant_db_config["name"],
+        "USER": tenant_db_config["user"],
+        "PASSWORD": tenant_db_config["password"],
+        "HOST": tenant_db_config["host"],
+        "PORT": tenant_db_config.get("port", 5432),
+    }
 
 # If you want to override the database alias to use for local development (when DEBUG is True).
 # By default, the first database defined in DATABASES is used.

cardo_python_utils-0.5.dev38/python_utils/django/celery/__init__.py

@@ -0,0 +1,5 @@
+from .tenant_aware_task import TenantAwareTask
+from .tenant_aware_database_scheduler import TenantAwareDatabaseScheduler
+
+
+__all__ = ["TenantAwareTask", "TenantAwareDatabaseScheduler"]

cardo_python_utils-0.5.dev38/python_utils/django/celery/tenant_aware_database_scheduler.py

@@ -0,0 +1,207 @@
+"""
+Multi-tenant Celery Beat scheduler.
+
+Reads periodic tasks from every tenant database and injects the ``tenant``
+kwarg so that ``TenantAwareTask`` can route each execution to the correct
+database.  Static beat-schedule entries (``CELERY_BEAT_SCHEDULE``) are also
+run once per tenant.
+"""
+
+from contextlib import contextmanager
+
+from celery.utils.log import get_logger
+from django.db import close_old_connections, transaction
+from django.db.utils import DatabaseError, InterfaceError
+from django_celery_beat.models import PeriodicTask, PeriodicTasks
+from django_celery_beat.schedulers import DatabaseScheduler, ModelEntry
+
+from ..settings import TENANT_DATABASES, TENANT_KEY
+from ..tenant_context import TenantContext
+
+logger = get_logger(__name__)
+debug, info, warning = logger.debug, logger.info, logger.warning
+
+
+class TenantAwareModelEntry(ModelEntry):
+    """
+    A schedule entry that remembers which tenant it belongs to and
+    injects the tenant kwarg when the task is applied.
+    """
+
+    def __init__(self, model, app=None, tenant=None):
+        self.tenant = tenant
+        super().__init__(model, app=app)
+        # Prefix the name so entries from different tenants don't collide.
+        self.name = f"{self.tenant}::{self.name}"
+
+    @contextmanager
+    def _ensure_tenant_context(self):
+        """Set TenantContext only when not already active (TenantContext is not re-entrant)."""
+        if TenantContext.is_set():
+            yield
+        else:
+            with TenantContext(self.tenant):
+                yield
+
+    def _disable(self, model):
+        """Route the save to the correct tenant database."""
+        with self._ensure_tenant_context():
+            super()._disable(model)
+
+    def save(self):
+        """Persist last_run_at / total_run_count to the correct tenant database."""
+        with self._ensure_tenant_context():
+            super().save()
+
+    def __next__(self):
+        self.model.last_run_at = self._default_now()
+        self.model.total_run_count += 1
+        self.model.no_changes = True
+        return self.__class__(self.model, app=self.app, tenant=self.tenant)
+
+    next = __next__
+
+    def __repr__(self):
+        return f"<TenantAwareModelEntry: [{self.tenant}] {self.task} {self.schedule}>"
+
+
+class TenantAwareDatabaseScheduler(DatabaseScheduler):
+    """
+    ``DatabaseScheduler`` subclass that aggregates periodic tasks across
+    **all** tenant databases.
+
+    For every tick it:
+
+    1. Reads ``PeriodicTask`` rows from each tenant DB.
+    2. Wraps them in ``TenantAwareModelEntry`` (which carries the tenant name).
+    3. When a task is due, injects ``tenant=<name>`` into the task kwargs
+       so that ``TenantAwareTask`` can set the context on the worker side.
+    """
+
+    Entry = TenantAwareModelEntry
+
+    def __init__(self, *args, **kwargs):
+        self._last_timestamps: dict[str, object] = {}
+        super().__init__(*args, **kwargs)
+
+    @staticmethod
+    def _get_tenant_databases() -> set[str]:
+        return TENANT_DATABASES
+
+    def all_as_schedule(self):
+        """Build the combined schedule dict from all tenant databases."""
+        debug("TenantAwareDatabaseScheduler: Fetching schedule from all tenants")
+        combined: dict[str, TenantAwareModelEntry] = {}
+
+        for tenant in self._get_tenant_databases():
+            with TenantContext(tenant):
+                try:
+                    for model in PeriodicTask.objects.enabled():
+                        try:
+                            entry = TenantAwareModelEntry(model, app=self.app, tenant=tenant)
+                            combined[entry.name] = entry
+                        except ValueError as exc:
+                            logger.warning(
+                                "TenantAwareDatabaseScheduler: skipping malformed periodic task '%s' in tenant '%s': %r",
+                                model.name,
+                                tenant,
+                                exc,
+                            )
+                except Exception as exc:
+                    logger.exception(
+                        "TenantAwareDatabaseScheduler: error reading tenant %s: %r",
+                        tenant,
+                        exc,
+                    )
+
+        return combined
+
+    def schedule_changed(self):
+        """Check whether *any* tenant database has had a schedule change."""
+        changed = False
+        try:
+            close_old_connections()
+
+            for tenant in self._get_tenant_databases():
+                try:
+                    transaction.commit(using=tenant)
+                except transaction.TransactionManagementError:
+                    pass
+
+                try:
+                    with TenantContext(tenant):
+                        ts = PeriodicTasks.last_change()
+                    last = self._last_timestamps.get(tenant)
+                    if ts and ts > (last if last else ts):
+                        changed = True
+                    self._last_timestamps[tenant] = ts
+                except (DatabaseError, InterfaceError) as exc:
+                    logger.warning(
+                        "TenantAwareDatabaseScheduler: error checking schedule_changed for tenant %s: %r",
+                        tenant,
+                        exc,
+                    )
+        except (DatabaseError, InterfaceError) as exc:
+            logger.exception("Database error in schedule_changed: %r", exc)
+            return False
+
+        return changed
+
+    def is_due(self, entry):
+        """Wrap in TenantContext so that any model.save() calls within
+        (e.g. disabling one-off tasks) are routed to the correct tenant DB."""
+        tenant = getattr(entry, "tenant", None)
+        if tenant:
+            with TenantContext(tenant):
+                return entry.is_due()
+        return entry.is_due()
+
+    def apply_entry(self, entry, producer=None):
+        """Inject the ``tenant`` kwarg before dispatching the task so that
+        ``TenantAwareTask.__call__`` can set the tenant context on the worker.
+
+        Built-in tasks like ``celery.backend_cleanup`` are skipped because
+        they are not ``TenantAwareTask`` subclasses and don't accept the kwarg.
+        """
+        tenant = getattr(entry, "tenant", None)
+        if tenant and entry.task != "celery.backend_cleanup":
+            extra_kwargs = dict(entry.kwargs or {})
+            extra_kwargs[TENANT_KEY] = tenant
+            entry.kwargs = extra_kwargs
+        super().apply_entry(entry, producer=producer)
+
+    def setup_schedule(self):
+        # Skip install_default_entries: it calls update_from_dict →
+        # Entry.from_entry which writes via _default_manager (no tenant
+        # routing). The celery.backend_cleanup task can be added to
+        # CELERY_BEAT_SCHEDULE in settings if needed.
+        self._update_static_schedule_per_tenant()
+
+    def _update_static_schedule_per_tenant(self):
+        """
+        For each entry in ``app.conf.beat_schedule``, create a
+        ``PeriodicTask`` row in every tenant database so that static
+        cron jobs run once per tenant.
+
+        Uses ``TenantContext`` so that all DB operations inside
+        ``_unpack_fields`` (schedule model lookups and saves) are
+        routed to the correct tenant database.
+        """
+        beat_schedule = self.app.conf.beat_schedule or {}
+        if not beat_schedule:
+            return
+
+        for tenant in self._get_tenant_databases():
+            with TenantContext(tenant):
+                for name, entry_fields in beat_schedule.items():
+                    try:
+                        defaults = ModelEntry._unpack_fields(**entry_fields)
+                        PeriodicTask.objects.update_or_create(name=name, defaults=defaults)
+                    except Exception as exc:
+                        logger.exception(
+                            "TenantAwareDatabaseScheduler: could not create "
+                            "static schedule entry '%s' for tenant '%s': %r",
+                            name,
+                            tenant,
+                            exc,
+                        )

{cardo_python_utils-0.5.dev36 → cardo_python_utils-0.5.dev38}/python_utils/django/tenant_context.py

@@ -1,5 +1,4 @@
 import logging
-import sys
 from contextlib import ContextDecorator
 from contextvars import ContextVar
 from typing import Optional
@@ -9,7 +8,7 @@ from .settings import DATABASES
 logger = logging.getLogger(__name__)
 
 # ContextVar propagates automatically to async threads via sync_to_async
-_tenant_var: ContextVar[Optional[str]] = ContextVar('tenant', default=None)
+_tenant_var: ContextVar[Optional[str]] = ContextVar("tenant", default=None)
 
 
 class TenantContext(ContextDecorator):
@@ -19,7 +18,7 @@ class TenantContext(ContextDecorator):
     1. As a context manager (sync and async):
         with TenantContext('tenant'):
             # do something
-        
+
         async with TenantContext('tenant'):
             # do something async
 
@@ -77,16 +76,16 @@ class TenantContext(ContextDecorator):
             # The same applies to a single task, it is not allowed to set the
             # tenant in the same task to a different value.
             if TenantContext.get() != tenant:
-                logger.error("ERROR: TENANT CONTEXT ALREADY SET")
-                logger.error(f"Current tenant: {TenantContext.get()}, new tenant: {tenant}")
-                return sys.exit(1)
+                raise RuntimeError(
+                    f"Tenant context already set to '{TenantContext.get()}', "
+                    f"cannot change to '{tenant}' within the same request/task lifecycle."
+                )
             else:
                 # If the tenant is already set to the same value, we do nothing and return None.
                 return None
 
         if tenant not in DATABASES:
-            logger.error(f"Tenant '{tenant}' not found in DATABASES settings.")
-            return sys.exit(1)
+            raise ValueError(f"Tenant '{tenant}' not found in DATABASES settings.")
 
         token = _tenant_var.set(tenant)
         logger.info(f"Tenant context set to {tenant}")
@@ -99,4 +98,4 @@ class TenantContext(ContextDecorator):
                 _tenant_var.reset(token)
             else:
                 _tenant_var.set(None)
-            logger.info("Tenant context cleared")
+            logger.info("Tenant context cleared")

{cardo_python_utils-0.5.dev36 → cardo_python_utils-0.5.dev38}/python_utils/django/tests/conftest.py

@@ -80,7 +80,7 @@ def mock_verify_scopes_ninja():
     Patches AuthBearer._verify_scopes, so that no real scope checking is done during tests.
     This is done because scope checking uses route resolution, which the test client does not support.
     """
-    with patch("python_utils.keycloak.django.api.ninja.AuthBearer._verify_scopes") as mock_verify:
+    with patch("python_utils.django.api.ninja.AuthBearer._verify_scopes") as mock_verify:
         mock_verify.return_value = None
         yield mock_verify
 

cardo_python_utils-0.5.dev36/python_utils/django/celery/__init__.py

@@ -1,4 +0,0 @@
-from .tenant_aware_task import TenantAwareTask
-
-
-__all__ = ["TenantAwareTask"]