cardo-python-utils 0.5.dev30__tar.gz → 0.5.dev31__tar.gz

{cardo_python_utils-0.5.dev30 → cardo_python_utils-0.5.dev31}/MANIFEST.in

@@ -1,4 +1,5 @@
 include LICENSE
 include README.rst
 include python_utils/keycloak/django/admin/user_groups_changelist.html
+include python_utils/multi_tenancy/README.md
 recursive-exclude tests *

{cardo_python_utils-0.5.dev30/cardo_python_utils.egg-info → cardo_python_utils-0.5.dev31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cardo-python-utils
-Version: 0.5.dev30
+Version: 0.5.dev31
 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.dev30 → cardo_python_utils-0.5.dev31/cardo_python_utils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cardo-python-utils
-Version: 0.5.dev30
+Version: 0.5.dev31
 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.dev30 → cardo_python_utils-0.5.dev31}/cardo_python_utils.egg-info/SOURCES.txt

@@ -33,4 +33,25 @@ python_utils/keycloak/django/api/utils.py
 python_utils/keycloak/django/models/__init__.py
 python_utils/keycloak/django/models/user_group.py
 python_utils/keycloak/django/tests/__init__.py
-python_utils/keycloak/django/tests/conftest.py
+python_utils/keycloak/django/tests/conftest.py
+python_utils/multi_tenancy/README.md
+python_utils/multi_tenancy/__init__.py
+python_utils/multi_tenancy/apps.py
+python_utils/multi_tenancy/settings.py
+python_utils/multi_tenancy/tenant_context.py
+python_utils/multi_tenancy/celery/__init__.py
+python_utils/multi_tenancy/celery/tenant_aware_task.py
+python_utils/multi_tenancy/db/__init__.py
+python_utils/multi_tenancy/db/routers.py
+python_utils/multi_tenancy/db/transaction.py
+python_utils/multi_tenancy/db/utils.py
+python_utils/multi_tenancy/management/__init__.py
+python_utils/multi_tenancy/management/commands/__init__.py
+python_utils/multi_tenancy/management/commands/migrateall.py
+python_utils/multi_tenancy/management/commands/tenant_aware_command.py
+python_utils/multi_tenancy/middleware/__init__.py
+python_utils/multi_tenancy/middleware/tenant_http_middleware.py
+python_utils/multi_tenancy/redis/__init__.py
+python_utils/multi_tenancy/redis/key_function.py
+python_utils/multi_tenancy/storage/__init__.py
+python_utils/multi_tenancy/storage/tenant_aware_storage.py

{cardo_python_utils-0.5.dev30 → cardo_python_utils-0.5.dev31}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cardo-python-utils"
-version = "0.5.dev30"
+version = "0.5.dev31"
 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.dev30 → cardo_python_utils-0.5.dev31}/python_utils/keycloak/django/admin/user_group.py

@@ -134,7 +134,7 @@ class UserGroupAdminBase(admin.ModelAdmin, metaclass=UserGroupAdminMetaclass):
         ]
 
     @staticmethod
-    def sync_groups_with_keycloak(request):  # noqa
+    def sync_groups_with_keycloak(request):
         """Syncs user groups with Keycloak"""
 
         try:

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/README.md

@@ -0,0 +1,62 @@
+This package adds multi-tenancy support to a Django application, with a separate database for each tenant.
+Several components are provided to facilitate this, including: database routing, middleware, celery tasks etc.
+
+It is heavily inspired by the implementation of multi-tenancy in the Mercury app by Klement Omeri.
+
+# Usage
+
+To use this package, add the following to your Django settings.py file:
+
+```python3
+INSTALLED_APPS = [
+    ...
+    "python_utils.multi_tenancy",
+    ...
+]
+
+MIDDLEWARE = [
+    "python_utils.multi_tenancy.middleware.TenantAwareHttpMiddleware",
+    ...
+]
+
+# Include the database configuration for each tenant in the DATABASES setting.
+# You can use the get_database_configs() function from python_utils.multi_tenancy.db.utils as a helper.
+DATABASES = {
+    'tenant1': { ... },
+    'tenant2': { ... },
+    ...
+}
+
+# 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.
+DEVELOPMENT_TENANT = "development"
+
+# This is required to use the tenant context when routing database queries
+DATABASE_ROUTERS = [
+    "python_utils.multi_tenancy.db.routers.TenantAwareRouter"
+]
+
+# If using celery, set the task class to TenantAwareTask:
+CELERY_TASK_CLS = "python_utils.multi_tenancy.celery.TenantAwareTask"
+
+# If using Redis caching, configure the cache backend as follows:
+CACHES = {
+    "default": {
+        "BACKEND": "django_redis.cache.RedisCache",
+        "LOCATION": REDIS_LOCATION,
+        "KEY_FUNCTION": "python_utils.multi_tenancy.redis.make_key",
+        **OPTIONS,
+    }
+}
+
+# If using Django Storages with S3, configure the storage backends as follows:
+STORAGES = {
+    "default": {
+        "BACKEND": "python_utils.multi_tenancy.storage.TenantAwarePrivateS3Storage",
+    },
+}
+
+# If you want to exclude certain paths from tenant processing, use TENANT_AWARE_EXCLUDED_PATHS:
+# They are considered as prefixes, so all paths starting with the given strings will be excluded.
+TENANT_AWARE_EXCLUDED_PATHS = ("/some/path",)
+```

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/__init__.py

@@ -0,0 +1 @@
+default_app_config = "python_utils.multi_tenancy.apps.MultiTenancyConfig"

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class MultiTenancyConfig(AppConfig):
+    name = "python_utils.multi_tenancy"
+    label = "multi_tenancy"
+    verbose_name = "Multi-Tenancy"

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/celery/__init__.py

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

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/celery/tenant_aware_task.py

@@ -0,0 +1,31 @@
+from celery import Task
+
+from ..settings import TENANT_KEY
+from ..tenant_context import TenantContext
+
+
+class TenantAwareTask(Task):
+    #: Enable argument checking.
+    #: You can set this to false if you don't want the signature to be
+    #: checked when calling the task.
+    #: Set to false because we are attaching a tenant to the task
+    #: and we don't want to check the signature.
+    #: Defaults to :attr:`app.strict_typing <@Celery.strict_typing>`.
+    typing = False
+
+    def __call__(self, *args, **kwargs):
+        """Override the __call__ method to set the tenant name in the thread namespace."""
+
+        # Celery backend_cleanup doesn't need a tenant and cannot be configured to pass the tenant kwarg
+        # because it is dynamically generated at @connect_on_app_finalize by celery itself
+        # ref: celery/app/builtins.py def add_backend_cleanup_task
+        if self.name != "celery.backend_cleanup":
+            tenant = kwargs.pop(TENANT_KEY)
+            TenantContext.set(tenant)
+
+        return self.run(*args, **kwargs)
+
+    def after_return(self, status, retval, task_id, args, kwargs, einfo):
+        """Clear the tenant from the thread namespace after the task has returned."""
+        TenantContext.clear()
+        super().after_return(status, retval, task_id, args, kwargs, einfo)

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/db/routers.py

@@ -0,0 +1,11 @@
+from ..tenant_context import TenantContext
+
+
+class TenantAwareRouter:
+    @staticmethod
+    def db_for_read(model, **hints):
+        return TenantContext.get()
+
+    @staticmethod
+    def db_for_write(model, **hints):
+        return TenantContext.get()

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/db/transaction.py

@@ -0,0 +1,26 @@
+from django.db.transaction import Atomic
+
+from ..tenant_context import TenantContext
+
+
+class TenantAtomic(Atomic):
+    """
+    A transaction that can be used in a multi-tenant application.
+    This transaction is bound to the current tenant.
+    The default implementation is to use the default database.
+    We want to override this by using the tenant database alias instead.
+    """
+
+    def __enter__(self):
+        self.using = TenantContext.get()
+        super().__enter__()
+
+
+def tenant_atomic(using=None, savepoint=True, durable=False):
+    # Bare decorator: @atomic -- although the first argument is called
+    # `using`, it's actually the function being decorated.
+    if callable(using):
+        return TenantAtomic(using=None, savepoint=savepoint, durable=durable)(using)
+    # Decorator: @atomic(...) or context manager: with atomic(...): ...
+    else:
+        return TenantAtomic(using, savepoint, durable)

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/db/utils.py

@@ -0,0 +1,66 @@
+from functools import reduce
+import json
+import os
+from typing import NotRequired, TypedDict
+from django.db import connections
+
+
+class DatabaseConfigData(TypedDict):
+    host: str
+    name: str
+    user: str
+    password: str
+    port: NotRequired[int]
+
+
+def get_connection(tenant: str = None):
+    """
+    Get the connection to the database with the given tenant or the default one.
+    Default value will be retrieved from TenantContext.get()
+    This uses the connections dict from django.db to get the required connection.
+
+    The default implementation of this function uses the 'default' alias
+    if not argument is given. We want to use the TenantContext class to
+    determine the correct alias.
+    Args:
+        tenant: Name of the tenant database alias
+
+    Returns:    The connection to the database
+
+    """
+    from ..tenant_context import TenantContext
+
+    database_alias = tenant or TenantContext.get()
+    connection = connections[database_alias]
+
+    return connection
+
+
+def get_database_configs() -> dict[str, DatabaseConfigData]:
+    """
+    The env variables prefixed with 'DATABASE_CONFIG' should be provided in the following format:
+    {
+        "tenant1": {
+            "host": "",
+            "name": "",
+            "user": "",
+            "password": "",
+            "port": 5432 / null
+        },
+        "tenant2": {
+            "host": "",
+            "name": "",
+            "user": "",
+            "password": ""
+        }
+    }
+    If multiple 'DATABASE_CONFIG'-prefixed variables are set, they will be merged into a single dictionary.
+    """
+    configs = [json.loads(v or "{}") for k, v in os.environ.items() if k.startswith("DATABASE_CONFIG")]
+    database_configs = reduce(lambda a, b: {**a, **b}, configs, {})
+    for tenant, db_config in database_configs.items():
+        for key in ["host", "name", "user", "password"]:
+            if key not in db_config:
+                raise ValueError(f"Missing required database config '{key}' for tenant {tenant}")
+
+    return database_configs

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/management/commands/migrateall.py

@@ -0,0 +1,25 @@
+from django.core.management.commands.migrate import Command as BaseMigrateCommand
+from django.db.models.signals import post_migrate, pre_migrate
+from django.dispatch import receiver
+
+from ...settings import TENANT_DATABASES
+from ...tenant_context import TenantContext
+
+
+@receiver(pre_migrate)
+def set_tenant_pre_migrate(sender, **kwargs):
+    database_alias = kwargs.get("using")
+    TenantContext.set(database_alias)
+
+
+@receiver(post_migrate)
+def clear_tenant_post_migrate(sender, **kwargs):
+    TenantContext.clear()
+
+
+class Command(BaseMigrateCommand):
+    def handle(self, *args, **options):
+        for tenant in TENANT_DATABASES:
+            self.stdout.write(f"Migrating tenant: {tenant}")
+            options["database"] = tenant
+            super().handle(*args, **options)

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/management/commands/tenant_aware_command.py

@@ -0,0 +1,74 @@
+from abc import abstractmethod
+from django.core.management import BaseCommand
+
+from ...settings import TENANT_DATABASES
+from ...tenant_context import TenantContext
+
+
+class TenantAwareCommand(BaseCommand):
+    """
+    Base class for all tenant aware commands.
+    The usage is like this:
+
+    class MyCommand(TenantAwareCommand):
+        def add_arguments(self, parser):
+            super().add_arguments(parser)
+            # add your own arguments here
+
+        def execute_command(self, *args, **options):
+            # logic to execute for each tenant
+    """
+
+    def add_arguments(self, parser):
+        """
+        Add the tenant argument to the command. The tenant argument is
+        required in a multi tenant environment.
+        The tenant value can either be a single tenant name or 'all' to run
+        the command for all tenants.
+        """
+        parser.add_argument(
+            "--tenant",
+            action="store",
+            dest="tenant",
+            help="Specify the tenant to run the command for, either a single tenant name or 'all'.",
+            required=True,
+            type=str,
+        )
+
+    def handle(self, *args, **options):
+        """
+        Get the tenant name from the command line arguments and set it as
+        the current tenant using TenantContext.set().
+        """
+        tenant = options["tenant"]
+        if tenant is None:
+            self.stdout.write(
+                self.style.ERROR(
+                    "Please provide --tenant in order to run this command, either a single tenant name or 'all'!"
+                )
+            )
+            exit()
+
+        if tenant.lower() == "all":
+            tenants_to_use = TENANT_DATABASES
+        else:
+            if tenant not in TENANT_DATABASES:
+                self.stdout.write(self.style.ERROR(f"Tenant '{tenant}' not found in DATABASES settings."))
+                exit()
+
+            tenants_to_use = [tenant]
+
+        for tenant in tenants_to_use:
+            self.stdout.write(f"Executing command for tenant: {tenant}")
+            options["database"] = tenant
+            with TenantContext(tenant):
+                self.execute_command(*args, **options)
+
+    @abstractmethod
+    def execute_command(self, *args, **options):
+        """
+        Abstract method to be implemented by the child class.
+        This method will be called by the handle() method after
+        setting the tenant context.
+        """
+        pass

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/middleware/__init__.py

@@ -0,0 +1,6 @@
+from .tenant_http_middleware import TenantAwareHttpMiddleware
+
+
+__all__ = [
+    "TenantAwareHttpMiddleware",
+]

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/middleware/tenant_http_middleware.py

@@ -0,0 +1,120 @@
+import logging
+from typing import Callable, Optional
+
+from django.conf import settings
+from django.core.handlers.wsgi import WSGIRequest
+from django.http import HttpResponse
+
+from ..settings import DEVELOPMENT_TENANT, TENANT_AWARE_EXCLUDED_PATHS, TENANT_DATABASES
+from ..tenant_context import TenantContext
+
+logger = logging.getLogger(__name__)
+
+
+class TenantAwareHttpMiddleware:
+    """
+    Middleware that sets the thread local variable `tenant`.
+    This middleware must be placed before any other middleware that
+    executes queries on the database.
+    In this way, the database alias is set before any other middleware is
+    called and it is removed after all of them are called.
+
+    Tenant detection:
+    - Production (DEBUG=False): Subdomain pattern <app>.<tenant>.domain.com
+    - Development (DEBUG=True): Uses DEVELOPMENT_TENANT setting directly
+
+    The subdomain pattern expects: <app>.<tenant>.<domain>
+    where <app> can be any value (e.g., app, portal, dashboard)
+    and <tenant> can contain alphanumeric characters and hyphens.
+    The -internal suffix is stripped from tenant names.
+    """
+
+    def __init__(self, get_response: Callable):
+        """
+        Middleware initialization. Only called once per Django application initialization.
+        Args:
+            get_response: Callable to get the response of the view.
+        """
+        self.get_response = get_response
+
+    def __call__(self, request: WSGIRequest) -> HttpResponse:
+        """
+        Called by Django for each http request to process it and return a response.
+        Everything that should be done before the view is called is done before
+        the get_response method is called and everything that should be done
+        after the view is called is done after the get_response method is called.
+        Args:
+            request: Django request object.
+
+        Returns:    HttpResponse object.
+        """
+        if self._is_excluded_path(request.path):
+            return self.get_response(request)
+
+        if TenantContext.is_set():
+            raise Exception("Tenant context already set")
+
+        # In DEBUG mode, use DEVELOPMENT_TENANT directly
+        # In production, extract tenant from subdomain
+        if settings.DEBUG:
+            tenant = DEVELOPMENT_TENANT
+            logger.debug(f"Using development tenant: {tenant}")
+        else:
+            tenant = self._get_tenant_from_subdomain(request)
+            if tenant is None:
+                raise Exception(f"Could not determine tenant from subdomain. Host: {request.get_host()}")
+
+        # Validate tenant exists in configured databases
+        if not self._is_valid_tenant(tenant):
+            raise Exception(f"Unknown tenant: {tenant}")
+
+        # Call the next middleware in the chain until the response is returned.
+        # After that, the database alias is removed from the thread local variable.
+        with TenantContext(tenant):
+            response = self.get_response(request)
+
+        return response
+
+    def _is_excluded_path(self, path: str) -> bool:
+        """
+        Check if the path should be excluded from tenant handling.
+        """
+        for excluded_path in TENANT_AWARE_EXCLUDED_PATHS:
+            if path.startswith(excluded_path):
+                return True
+
+        return False
+
+    def _get_tenant_from_subdomain(self, request: WSGIRequest) -> Optional[str]:
+        """
+        Extract tenant from subdomain.
+
+        Expected formats:
+        - <app>.tenant.domain.com -> tenant
+        - <app>.tenant-internal.domain.com -> tenant (strips -internal suffix)
+        """
+        host = request.get_host().split(":")[0]  # Remove port if present
+        parts = host.split(".")
+
+        # Need at least 3 parts: <app>.<tenant>.<domain>
+        if len(parts) >= 3:
+            tenant = self._normalize_tenant(parts[1])
+            logger.debug(f"Tenant '{tenant}' extracted from subdomain: {host}")
+            return tenant
+
+        return None
+
+    @staticmethod
+    def _normalize_tenant(tenant: str) -> str:
+        # Remove -internal suffix if present
+        if tenant.endswith("-internal"):
+            return tenant[: -len("-internal")]
+        return tenant
+
+    @staticmethod
+    def _is_valid_tenant(tenant: str) -> bool:
+        """
+        Validate that the tenant exists in configured databases.
+        Skip 'default' as it's typically a placeholder.
+        """
+        return tenant in TENANT_DATABASES

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/redis/__init__.py

@@ -0,0 +1,4 @@
+from .key_function import make_key
+
+
+__all__ = ["make_key"]

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/redis/key_function.py

@@ -0,0 +1,5 @@
+from ..tenant_context import TenantContext
+
+
+def make_key(key, key_prefix, version):
+    return ":".join([TenantContext.get(), key_prefix, str(version), key])

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/settings.py

@@ -0,0 +1,17 @@
+from django.conf import settings
+
+TENANT_DATABASES = set(settings.DATABASES.keys()) - {"default"}
+TENANT_KEY = "tenant"
+
+TENANT_AWARE_EXCLUDED_PATHS = getattr(settings, "TENANT_AWARE_EXCLUDED_PATHS", ())
+TENANT_AWARE_EXCLUDED_PATHS = (
+    *TENANT_AWARE_EXCLUDED_PATHS,
+    "/health",
+    "/healthz",
+    "/static",
+    "/staticfiles",
+    "/media",
+    "/mediafiles",
+)
+
+DEVELOPMENT_TENANT = getattr(settings, "DEVELOPMENT_TENANT", list(TENANT_DATABASES)[0])

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/storage/__init__.py

@@ -0,0 +1,6 @@
+from .tenant_aware_storage import TenantAwareS3Storage, TenantAwarePrivateS3Storage
+
+__all__ = [
+    "TenantAwareS3Storage",
+    "TenantAwarePrivateS3Storage",
+]

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/storage/tenant_aware_storage.py

@@ -0,0 +1,86 @@
+import json
+import os
+from typing import Optional
+
+from django.conf import settings
+from storages.backends.s3boto3 import S3Boto3Storage
+
+from ..tenant_context import TenantContext
+
+
+def get_tenant_bucket_names() -> dict:
+    """
+    Retrieve the tenant bucket names from the environment variable.
+    The environment variable AWS_STORAGE_TENANT_BUCKET_NAMES should be a JSON
+    dictionary where each key is the tenant name and the value is the bucket name.
+
+    Returns:
+        A dictionary mapping tenant names to their S3 bucket names.
+    """
+    bucket_names_raw = os.getenv("AWS_STORAGE_TENANT_BUCKET_NAMES", "{}")
+    try:
+        return json.loads(bucket_names_raw)
+    except json.JSONDecodeError:
+        return {}
+
+
+def get_bucket_name_for_tenant(tenant: Optional[str] = None) -> str:
+    """
+    Get the S3 bucket name for a specific tenant.
+
+    Args:
+        tenant: The tenant name. If None, uses the current tenant from context.
+
+    Returns:
+        The S3 bucket name for the tenant.
+
+    Raises:
+        ValueError: If no bucket is configured for the tenant.
+    """
+    if tenant is None:
+        tenant = TenantContext.get()
+
+    tenant_buckets = get_tenant_bucket_names()
+
+    if tenant not in tenant_buckets:
+        raise ValueError(
+            f"No S3 bucket configured for tenant '{tenant}'. "
+            f"Please set AWS_STORAGE_TENANT_BUCKET_NAMES environment variable."
+        )
+
+    return tenant_buckets[tenant]
+
+
+class TenantAwareS3Storage(S3Boto3Storage):
+    """
+    A tenant-aware S3 storage backend that dynamically selects the bucket
+    based on the current tenant context.
+    """
+
+    def __init__(self, *args, **kwargs):
+        # Don't set bucket_name here; it will be resolved dynamically
+        super().__init__(*args, **kwargs)
+
+    @property
+    def bucket_name(self):
+        """Dynamically resolve the bucket name based on current tenant."""
+        try:
+            return get_bucket_name_for_tenant()
+        except (RuntimeError, ValueError):
+            # Fallback to default bucket if tenant context is not set
+            return getattr(settings, "AWS_STORAGE_BUCKET_NAME", None)
+
+    @bucket_name.setter
+    def bucket_name(self, value):
+        # Allow setting bucket_name but it will be overridden by the property getter
+        self._bucket_name_override = value
+
+
+class TenantAwarePrivateS3Storage(TenantAwareS3Storage):
+    """
+    Tenant-aware private media storage with file overwrite disabled.
+    """
+
+    location = "private"
+    file_overwrite = False
+    custom_domain = False

cardo_python_utils-0.5.dev31/python_utils/multi_tenancy/tenant_context.py

@@ -0,0 +1,89 @@
+import logging
+import sys
+from contextlib import ContextDecorator
+from threading import local
+from typing import Optional
+
+from .settings import TENANT_DATABASES
+
+logger = logging.getLogger(__name__)
+thread_namespace = local()
+
+
+class TenantContext(ContextDecorator):
+    """
+    Context manager that sets the current tenant.
+    This class can be used in several ways:
+    1. As a context manager:
+        with TenantContext('tenant'):
+            # do something
+
+    2. As a decorator:
+        @TenantContext('tenant')
+        def some_function():
+            # do something
+
+    3. Directly using static methods:
+        TenantContext.set('tenant')
+        # do something
+        TenantContext.clear()
+    """
+
+    field_name = "tenant"
+
+    def __init__(self, tenant: str):
+        self.tenant = tenant
+
+    def __enter__(self):
+        TenantContext.set(self.tenant)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        TenantContext.clear()
+
+    @staticmethod
+    def is_set() -> bool:
+        return hasattr(thread_namespace, TenantContext.field_name)
+
+    @staticmethod
+    def get() -> Optional[str]:
+        try:
+            return getattr(thread_namespace, TenantContext.field_name)
+        except AttributeError as e:
+            raise RuntimeError("Tenant context is not set.") from e
+
+    @staticmethod
+    def set(tenant):
+        if TenantContext.is_set():
+            # If the tenant is already set, we do not allow to set it
+            # again unless it is the same value.
+            # This is to prevent the tenant to be set to a different
+            # value in the same thread.
+            # A request-response cycle is required to set the tenant
+            # only once and operate on the same tenant in its lifecycle.
+            # 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)
+
+            else:
+                # Normally in a request-response cycle, or a single task, the
+                # tenant context is set only once. But there is an exception
+                # for the migrate command, which sets the tenant context
+                # multiple times to the same value.
+                logger.info("Tenant context already set to %s", tenant)
+                return
+        
+        if tenant not in TENANT_DATABASES:
+            logger.error(f"Tenant '{tenant}' not found in DATABASES settings.")
+            return sys.exit(1)
+
+        setattr(thread_namespace, TenantContext.field_name, tenant)
+        logger.info(f"Tenant context set to {tenant}")
+
+    @staticmethod
+    def clear():
+        if TenantContext.is_set():
+            delattr(thread_namespace, TenantContext.field_name)
+            logger.info("Tenant context cleared")