djanquiltdb 3.0.0__tar.gz

djanquiltdb-3.0.0/LICENSE

@@ -0,0 +1,28 @@
+Copyright (c) 2017-2023, Patchman B.V.
+Copyright (c) 2023-2025, Cloud Linux Software, Inc.
+Copyright (c) 2025-2026, DjanQuiltDB Project
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the names of Patchman B.V., Cloud Linux Software, Inc. or
+      DjanQuiltDB, nor the names of their contributors may be used to
+      endorse or promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL PATCHMAN B.V., CLOUD LINUX SOFTWARE, INC., OR
+THE DJANQUILTDB PROJECT BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

djanquiltdb-3.0.0/MANIFEST.in

@@ -0,0 +1,7 @@
+include LICENSE
+include README.rst
+include MANIFEST.in
+exclude .DS_Store
+
+# Django template files (including contrib apps like quilt_admin)
+recursive-include djanquiltdb *.html

djanquiltdb-3.0.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: djanquiltdb
+Version: 3.0.0
+Summary: Library to shard a database on the hierarchy's top level table.
+Home-page: https://www.github.com/DjanQuiltDB/djanquiltdb
+Author: DjanQuiltDB Project; Cloud Linux Software, Inc.; Patchman B.V.
+Author-email: djanquiltdb@portal42.net; info@cloudlinux.com; hello@patchman.co
+License: BSD-3-Clause
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 6.0
+License-File: LICENSE
+Requires-Dist: django<7.0,>=6.0
+Requires-Dist: psycopg[binary]>=3.0.0
+Requires-Dist: progressbar2
+Provides-Extra: test
+Requires-Dist: tox==4.12.1; extra == "test"
+Requires-Dist: pluggy; extra == "test"
+Requires-Dist: dj-database-url==2.1.0; extra == "test"
+Requires-Dist: django-braces==1.15.0; extra == "test"
+Requires-Dist: tblib; extra == "test"
+Requires-Dist: filelock; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: PyYAML; extra == "test"
+Provides-Extra: dev
+Requires-Dist: tox==4.12.1; extra == "dev"
+Requires-Dist: pluggy; extra == "dev"
+Requires-Dist: dj-database-url==2.1.0; extra == "dev"
+Requires-Dist: django-braces==1.15.0; extra == "dev"
+Requires-Dist: tblib; extra == "dev"
+Requires-Dist: filelock; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: PyYAML; extra == "dev"
+Requires-Dist: sphinx==1.8.1; extra == "dev"
+Requires-Dist: Jinja2<2.11,>=2.3; extra == "dev"
+Requires-Dist: sphinx_rtd_theme==0.4.2; extra == "dev"
+Requires-Dist: MarkupSafe<2.1.0,>=0.23; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary

djanquiltdb-3.0.0/README.rst

@@ -0,0 +1,60 @@
+DjanQuiltDB - Django Database Sharding
+======================================
+
+**DjanQuiltDB** is an extension to the Django web framework that provides helper functions to split a database based on
+top level hierarchy. It is specifically designed to support horizontal sharding not just within a single database
+cluster, but also across multiple database clusters, thus allowing you to scale database capacity both vertically and
+horizontally as your dataset grows.
+
+This library attempts to combine the best of as many worlds as possible. Tenant-specific data is kept in tenant-specific
+PostgreSQL schemas, while data that is tenant-agnostic or shared can be kept in public schemas, so as to deduplicate.
+There are helpers to split data off from one shard to another, to migrate a shard across nodes, to synchronize changes
+across nodes, etc.
+
+As the name suggests, this approach provides an interface to data, that may in reality be scattered across various
+schemas in various database clusters, and presents it as a coherent and easily accessible patchwork of tables, resulting
+in a database resembling a quilt.
+
+Development
+===========
+
+To setup your development environment it is important to install the development requirements first::
+
+    pip install -e .[dev]
+
+Next, copy the example secrets file in the ``djanquiltdb`` directory and adjust the parameters::
+
+    cp secrets.json.example secrets.json
+
+Tests
+-----
+
+Tox can be used to run the test suite against multiple Python and Django versions::
+
+    tox
+
+Building
+--------
+
+To build the library, simply run::
+
+    python setup.py build
+
+And to make a distribution, run ::
+
+    python setup.py sdist
+
+The result is then bound in the /dist folder
+
+Documentation
+-------------
+
+Documentation can be found in the `/docs` directory. Build the documentation with::
+
+    python setup.py build_sphinx
+
+Attribution
+===========
+
+This is an independently maintained fork of the patchman-django-sharding library originally created and maintained by
+Patchman B.V. (2017-2023) and Cloud Linux Software, Inc. (2023-2025).

djanquiltdb-3.0.0/djanquiltdb/djanquiltdb/__init__.py

@@ -0,0 +1,26 @@
+from enum import Enum
+
+__version__ = '3.0.0'
+
+
+default_app_config = 'djanquiltdb.apps.DjanQuiltDBConfig'
+
+
+class ShardingMode(Enum):
+    MIRRORED = 'M'
+    PUBLIC = 'P'
+    SHARDED = 'S'
+
+
+public_modes = (ShardingMode.MIRRORED, ShardingMode.PUBLIC)
+
+
+class State(object):
+    ACTIVE = 'A'
+    MAINTENANCE = 'M'
+
+
+STATES = (
+    (State.ACTIVE, 'Active'),
+    (State.MAINTENANCE, 'Maintenance'),
+)

djanquiltdb-3.0.0/djanquiltdb/djanquiltdb/apps.py

@@ -0,0 +1,202 @@
+import functools
+import inspect
+import types
+
+from django.apps import AppConfig
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from django.core.exceptions import ImproperlyConfigured
+from django.utils.module_loading import import_string
+
+from djanquiltdb import ShardingMode
+from djanquiltdb.db import connection
+from djanquiltdb.decorators import class_method_use_shard, class_method_use_shard_from_db_arg
+from djanquiltdb.options import ShardOptions
+from djanquiltdb.postgresql_backend.base import ShardDatabaseWrapper
+from djanquiltdb.utils import get_all_mirrored_models, get_all_public_models, get_all_sharded_models
+
+
+class DjanQuiltDBConfig(AppConfig):
+    name = 'djanquiltdb'
+    verbose_name = 'DjanQuiltDB'
+
+    def ready(self):
+        from .models import BaseShard
+
+        if 'QUILT_DB' not in dir(settings) or not isinstance(settings.QUILT_DB, dict):
+            raise ImproperlyConfigured('Missing or incorrect type of a setting QUILT_DB.')
+
+        # Validate shard and node class settings
+        if 'SHARD_CLASS' not in settings.QUILT_DB:
+            raise ImproperlyConfigured('Missing or incorrect type of a setting QUILT_DB["{}"].'.format('SHARD_CLASS'))
+        class_ = import_string(settings.QUILT_DB['SHARD_CLASS'])
+        if not issubclass(class_, BaseShard):
+            raise ImproperlyConfigured(
+                'The type {} should inherit from {}.'.format(settings.QUILT_DB['SHARD_CLASS'], BaseShard.__name__)
+            )
+        if hasattr(class_, '__sharding_mode') and getattr(class_, '__sharding_mode') == ShardingMode.SHARDED:
+            raise ImproperlyConfigured(
+                'The Shard model cannot itself be sharded. It can only be non-sharded or mirrored.'
+            )
+
+        override_sharding_mode = settings.QUILT_DB.setdefault('OVERRIDE_SHARDING_MODE', {})
+        if not isinstance(override_sharding_mode, dict):
+            raise ImproperlyConfigured("Incorrect setting value of QUILT_DB['OVERRIDE_SHARDING_MODE'].")
+
+        for key, value in override_sharding_mode.items():
+            _validate_override_sharding_mode_entry(key, value)
+
+        # Convert app and model names to lowercase
+        settings.QUILT_DB['OVERRIDE_SHARDING_MODE'] = dict(
+            (tuple(x.lower() for x in k), v) for k, v in override_sharding_mode.items()
+        )
+
+        if (
+            'DATABASE_ROUTERS' not in dir(settings)
+            or 'djanquiltdb.router.DynamicDbRouter' not in settings.DATABASE_ROUTERS
+        ):
+            raise ImproperlyConfigured(
+                'djanquiltdb.router.DynamicDbRouter must be present in the DATABASE_ROUTERS setting.'
+            )
+
+        if (
+            'SESSION_ENGINE' in dir(settings)
+            and settings.SESSION_ENGINE == 'django.contrib.sessions.backends.cached_db'
+            and getattr(get_user_model(), '__sharding_mode', False) in [ShardingMode.MIRRORED, ShardingMode.SHARDED]
+        ):
+            raise ImproperlyConfigured(
+                'When the user model is sharded, you cannot use django.contrib.sessions.backends.cached_db '
+                "to store sessions. It references the user table and won't know where to find it."
+            )
+
+        if (
+            'PRIMARY_DB_ALIAS' not in settings.QUILT_DB or not settings.QUILT_DB.get('PRIMARY_DB_ALIAS', None)
+        ) and get_all_mirrored_models():
+            raise ImproperlyConfigured("There are MIRRORED models, but QUILT_DB['PRIMARY_DB_ALIAS'] is not set.")
+
+        _validate_public_models()
+        _patch_connections()
+        _patch_transactions()
+        _initialize_sharded_models()
+
+
+def _validate_public_models():
+    for model in get_all_public_models():
+        if not hasattr(model._meta, 'unique_together') or not model._meta.unique_together:
+            raise ImproperlyConfigured(
+                f'{model._meta.app_label}.{model.__name__} must have "unique_together" meta attribute set.'
+            )
+
+        if not hasattr(model, 'natural_key'):
+            raise ImproperlyConfigured(f'{model._meta.app_label}.{model.__name__} must define "natural_key" method.')
+
+        if not hasattr(model._default_manager, 'get_by_natural_key'):
+            raise ImproperlyConfigured(
+                f'The default manager for {model._meta.app_label}.{model.__name__} must'
+                'define "get_by_natural_key" method.'
+            )
+
+
+def _validate_override_sharding_mode_entry(key, value):
+    if not (isinstance(key, tuple) and len(key) in (1, 2) and isinstance(value, ShardingMode)):
+        raise ImproperlyConfigured(
+            'The override sharding mode entry is improperly configured: {{ {}: {} }}'.format(repr(key), repr(value))
+        )
+
+
+def _initialize_sharded_models():
+    """
+    Initialize sharded models by overriding all methods to add a use_shard context manager that makes sure all queries
+    are done in that same shard as the object is living in.
+    """
+    from_db_functions = {model: model.from_db for model in get_all_sharded_models(include_proxy=True)}
+
+    for model in get_all_sharded_models(include_proxy=True):
+        for attr, func in inspect.getmembers(model, inspect.isfunction):
+            # getattr(model, attr) will trigger dynamic lookup via the descriptor protocol,  __getattr__ or
+            # __getattribute__. Therefore, we use inspect.getattr_static to strip out staticmethods (which we don't want
+            # to decorate).
+            if isinstance(inspect.getattr_static(model, attr), types.FunctionType):
+                # And decorate all model methods so that the methods will all run in the same shard context as the
+                # instance is living in
+                setattr(model, attr, class_method_use_shard(func))
+
+        # Setting the from_db function for a Model that is the parent of a ProxyModel will corrupt the ProxyModels
+        # version of the same function. So we have saved the original from_db function at the start, and use that.
+        model.add_to_class('from_db', class_method_use_shard_from_db_arg(from_db_functions[model]))
+
+        _initialize_sharded_model_querysets(model)
+
+
+def post_init(func):
+    @functools.wraps(func)
+    def inner(self, *args, hints=None, **kwargs):
+        hints = hints or {}
+
+        if '_shard_options' not in hints and not connection.is_public_schema():
+            hints['_shard_options'] = connection.shard_options
+
+        func(self, *args, hints=hints, **kwargs)
+
+    inner.__decorator__ = post_init
+    return inner
+
+
+def _initialize_sharded_model_querysets(model):
+    """
+    Override all the querysets of the managers, so they can remember the shard where they are initialized on
+    """
+    for instance in model._meta.managers:
+        if (
+            hasattr(instance._queryset_class.__init__, '__decorator__')
+            and instance._queryset_class.__init__.__decorator__ == post_init
+        ):
+            continue
+        setattr(instance._queryset_class, '__init__', post_init(instance._queryset_class.__init__))
+
+
+def patch_getitem(func):
+    @functools.wraps(func)
+    def inner(self, alias):
+        # If we're planning to just go into the public schema, then we're going to use the normal connection for that
+        if isinstance(alias, str) and '|' not in alias or isinstance(alias, ShardOptions) and alias.is_public_schema():
+            return func(self, alias if isinstance(alias, str) else alias.node_name)
+
+        options = ShardOptions.from_alias(alias)
+
+        # Retrieves the main connection to the database, so we can still do connection pooling
+        connection_ = func(self, options.node_name)
+
+        # Sets up the sharded connection
+        return ShardDatabaseWrapper(connection_, options)
+
+    return inner
+
+
+def _patch_connections():
+    """
+    Monkeypatch django.db.connection and django.db.connections to accept:
+
+      * node_name
+      * node_name|schema_name
+      * tuple (node_name, schema_name)
+      * ShardOptions instance
+      * Shard model instance
+    """
+    import django.db
+    from django.db.utils import ConnectionHandler
+
+    setattr(ConnectionHandler, '__getitem__', patch_getitem(ConnectionHandler.__getitem__))
+    setattr(django.db, 'connection', connection)
+
+
+def _patch_transactions():
+    """
+    Monkeypatch django.db.transaction.get_connection to use the active node, not always the default:
+    """
+    import django.db.transaction
+
+    from djanquiltdb.transaction import atomic, get_connection
+
+    setattr(django.db.transaction, 'get_connection', get_connection)
+    setattr(django.db.transaction, 'atomic', atomic)

djanquiltdb-3.0.0/djanquiltdb/djanquiltdb/collector.py

@@ -0,0 +1,103 @@
+import progressbar
+from django.db.models.deletion import Collector
+from django.db.models.deletion import get_candidate_relations_to_delete as get_candidate_relations_to_collect
+
+
+class SimpleCollector(Collector):
+    """
+    Simple collector does basically the same as the default Django collector, but also follows the on delete SET NULL
+    relations. We need this to move data from one shard to another.
+    """
+
+    def __init__(self, connection, verbose=False):
+        super().__init__(using=connection.alias)
+
+        self.connection = connection
+        self.verbose = verbose
+        self.data_points = 0
+
+        if self.verbose:
+            self.bar = progressbar.ProgressBar(
+                max_value=progressbar.UnknownLength,
+                widgets=[
+                    progressbar.RotatingMarker(),
+                    ' Collected ',
+                    progressbar.Counter(),
+                    ' datapoints; ',
+                    progressbar.Timer(),
+                ],
+            )
+
+    def add(self, *args, **kwargs):
+        new_objs = super().add(*args, **kwargs)
+
+        if self.verbose:
+            self.data_points += len(new_objs)
+            self.bar.update(self.data_points)
+
+        return new_objs
+
+    def get_batches(self, objs, field):
+        """
+        Returns the objs in suitably sized batches for the used connection.
+        """
+        conn_batch_size = max(self.connection.ops.bulk_batch_size([field.name], objs), 1)
+        if len(objs) > conn_batch_size:
+            return [objs[i : i + conn_batch_size] for i in range(0, len(objs), conn_batch_size)]
+        else:
+            return [objs]
+
+    def finish_bar(self):
+        if self.verbose:
+            self.bar.finish()
+
+    def collect(
+        self,
+        objs,
+        source=None,
+        nullable=False,
+        collect_related=True,
+        source_attr=None,
+        reverse_dependency=False,
+        keep_parents=False,
+        fail_on_restricted=True,
+    ):
+        """
+        Kind of the same as the original collector, but now also follows the on delete SET NULL relations.
+        """
+        new_objs = self.add(objs, source, nullable, reverse_dependency=reverse_dependency)
+
+        if not new_objs:
+            self.finish_bar()
+            return
+
+        model = new_objs[0].__class__
+
+        # Recursively collect concrete model's parent models, but not their
+        # related objects. These will be found by meta.get_fields()
+        concrete_model = model._meta.concrete_model
+        for ptr in concrete_model._meta.parents.values():
+            if ptr:
+                # FIXME: This seems to be buggy and execute a query for each
+                # parent object fetch. We have the parent data in the obj,
+                # but we don't have a nice way to turn that data into parent
+                # object instance.
+                parent_objs = [getattr(obj, ptr.name) for obj in new_objs]
+                self.collect(
+                    parent_objs, source=model, source_attr=ptr.remote_field.related_name, collect_related=False
+                )
+
+        if collect_related:
+            for related in get_candidate_relations_to_collect(model._meta):
+                field = related.field
+                batches = self.get_batches(new_objs, field)
+                for batch in batches:
+                    sub_objs = self.related_objects(related.related_model, [field], batch)
+                    if not sub_objs:
+                        continue
+                    self.collect(sub_objs, source=model, source_attr=field.name)
+            for field in model._meta.private_fields:
+                if hasattr(field, 'bulk_related_objects'):
+                    # It's something like generic foreign key.
+                    sub_objs = field.bulk_related_objects(new_objs, self.using)
+                    self.collect(sub_objs, source=model, nullable=True, fail_on_restricted=False)

djanquiltdb-3.0.0/djanquiltdb/djanquiltdb/contrib/quilt_admin/apps.py

@@ -0,0 +1,34 @@
+from typing import TYPE_CHECKING, Optional
+
+from django.apps import AppConfig
+from django.core.exceptions import ImproperlyConfigured
+
+if TYPE_CHECKING:
+    from djanquiltdb.contrib.quilt_admin.shard_selector import BaseAdminShardSelector
+
+ADMIN_SHARD_SELECTOR_CLASS: Optional[BaseAdminShardSelector] = None
+
+
+class ShardedAdminAppConfig(AppConfig):
+    name = 'djanquiltdb.contrib.quilt_admin'
+    verbose_name = 'DjanQuiltDB Admin Integration'
+
+    def ready(self):
+        from django.conf import settings
+        from django.utils.module_loading import import_string
+
+        from djanquiltdb.contrib.quilt_admin.shard_selector import BaseAdminShardSelector
+
+        global ADMIN_SHARD_SELECTOR_CLASS
+
+        if hasattr(settings, 'QUILT_ADMIN') and 'SHARD_SELECTOR_CLASS' in settings.QUILT_ADMIN:
+            shard_selector_class = settings.QUILT_ADMIN['SHARD_SELECTOR_CLASS']
+        else:
+            shard_selector_class = 'djanquiltdb.contrib.quilt_admin.shard_selector.AdminShardSelector'
+
+        ADMIN_SHARD_SELECTOR_CLASS = import_string(shard_selector_class)
+
+        if not issubclass(ADMIN_SHARD_SELECTOR_CLASS, BaseAdminShardSelector):
+            raise ImproperlyConfigured(
+                f"Shard selector class {ADMIN_SHARD_SELECTOR_CLASS} doesn't subclass BaseAdminShardSelector"
+            )

djanquiltdb-3.0.0/djanquiltdb/djanquiltdb/contrib/quilt_admin/context_processors.py

@@ -0,0 +1,85 @@
+from djanquiltdb.contrib.quilt_admin.apps import ADMIN_SHARD_SELECTOR_CLASS
+from djanquiltdb.utils import get_mapping_class, get_shard_class
+
+
+def admin_shard_context(request):
+    """
+    Context processor to provide shard information to admin templates.
+    Adds shard switcher context to admin templates.
+
+    If a mapping model is configured (QUILT_DB["MAPPING_MODEL"]), the selector lists
+    mapping entries (by mapping value) instead of shards (by shard id).
+    """
+    context = {
+        'available_shards': [],
+        'current_shard_id': None,  # kept for backwards compatibility
+        'shard_switcher_options': [],
+        'shard_switcher_field_name': 'shard_id',
+        'current_shard_switcher_value': '',
+        'shard_switcher_mode': 'shard',  # or 'mapping'
+        'shard_maintenance_mode': False,
+        'shard_maintenance_message': None,
+    }
+    # Add maintenance status if available
+    if hasattr(request, '_shard_maintenance_mode'):
+        context['shard_maintenance_mode'] = request._shard_maintenance_mode
+        context['shard_maintenance_message'] = getattr(request, '_shard_maintenance_message', None)
+    # Only add shard context if user is authenticated and in admin
+    if hasattr(request, 'user') and request.user.is_authenticated and request.path.startswith('/admin/'):
+        try:
+            mapping_class = get_mapping_class()
+            if mapping_class:
+                mapping_field = getattr(mapping_class, 'mapping_field', None)
+
+                qs = mapping_class.objects.using('default').select_related('shard').all()
+                if mapping_field:
+                    qs = qs.order_by(mapping_field)
+                else:
+                    qs = qs.order_by('pk')
+
+                mappings = list(qs)
+                context['available_shards'] = mappings
+                context['shard_switcher_mode'] = 'mapping'
+                context['shard_switcher_field_name'] = 'mapping_value'
+
+                current_value = ADMIN_SHARD_SELECTOR_CLASS.retrieve_override_value(request)
+                context['current_shard_switcher_value'] = '' if current_value is None else str(current_value)
+
+                options = []
+                for mapping in mappings:
+                    if mapping_field:
+                        mapping_value = getattr(mapping, mapping_field)
+                        mapping_value_str = '' if mapping_value is None else str(mapping_value)
+                    else:
+                        mapping_value = mapping.pk
+                        mapping_value_str = str(mapping.pk)
+
+                    shard = getattr(mapping, 'shard', None)
+                    label = ADMIN_SHARD_SELECTOR_CLASS.format_override_option(mapping_value, shard, mapping)
+
+                    options.append({'value': mapping_value_str, 'label': label})
+
+                context['shard_switcher_options'] = options
+            else:
+                shard_class = get_shard_class()
+                # Get all shards from the primary database
+                # Using .using('default') to ensure we query from the primary database
+                shards = list(shard_class.objects.using('default').all().order_by('alias'))
+                context['available_shards'] = shards
+
+                current_id = ADMIN_SHARD_SELECTOR_CLASS.retrieve_override_value(request)
+                context['current_shard_id'] = current_id
+                context['current_shard_switcher_value'] = '' if current_id is None else str(current_id)
+
+                context['shard_switcher_options'] = [
+                    {
+                        'value': str(shard.id),
+                        'label': ADMIN_SHARD_SELECTOR_CLASS.format_override_option(shard.id, shard),
+                    }
+                    for shard in shards
+                ]
+        except Exception:
+            # If there's any error (e.g., database not ready, no shards exist), just return empty context
+            pass
+
+    return context