openedx-plugin-sample 3.8.0__py3-none-any.whl

openedx_plugin_sample/__init__.py

@@ -0,0 +1,7 @@
+"""
+A sample backend plugin for the Open edX Platform.
+"""
+
+from importlib.metadata import version as get_version
+
+__version__ = get_version(__package__)

openedx_plugin_sample/admin.py

@@ -0,0 +1,55 @@
+"""
+Django admin configuration for openedx_plugin_sample.
+
+This module demonstrates how to expose plugin models in the Django admin
+site provided by Open edX (LMS and CMS each have their own admin under
+``/admin/``). Defining a ``ModelAdmin`` for each model gives operators a
+ready-made UI to inspect and manage plugin data without needing custom
+tooling.
+
+Django Documentation:
+- ModelAdmin: https://docs.djangoproject.com/en/stable/ref/contrib/admin/
+"""
+
+from django.contrib import admin
+
+from openedx_plugin_sample.models import CourseArchiveStatus
+
+
+@admin.register(CourseArchiveStatus)
+class CourseArchiveStatusAdmin(admin.ModelAdmin):
+    """
+    Admin configuration for the CourseArchiveStatus model.
+    """
+
+    list_display = (
+        "course_key",
+        "user",
+        "is_archived",
+        "archive_date",
+        "updated_at",
+    )
+    list_filter = ("is_archived",)
+    # Search by the related CourseRun's course_key and the user's username/email.
+    search_fields = (
+        "course_run__course_key",
+        "user__username",
+        "user__email",
+    )
+    # FKs use raw id widgets (lookup popup) rather than a <select>, since the
+    # CourseRun and User tables can have many thousands of rows on a real
+    # Open edX deployment.
+    raw_id_fields = ("course_run", "user")
+    readonly_fields = ("created_at", "updated_at")
+    ordering = ("-updated_at",)
+
+    @admin.display(description="Course key", ordering="course_run__course_key")
+    def course_key(self, obj: CourseArchiveStatus) -> str:
+        """
+        Show the course's course_key string in list_display.
+
+        We never expose CourseRun's internal integer PK in the admin; the
+        course_key (e.g. "course-v1:edX+DemoX+Demo_Course") is the identifier
+        operators recognize.
+        """
+        return str(obj.course_run.course_key)

openedx_plugin_sample/apps.py

@@ -0,0 +1,134 @@
+"""
+openedx_plugin_sample Django application initialization.
+"""
+
+from django.apps import AppConfig
+from edx_django_utils.plugins.constants import PluginSettings, PluginURLs
+
+
+class SamplePluginConfig(AppConfig):
+    """
+    Django App Plugin configuration for Open edX platform integration.
+
+    This class demonstrates the complete Django App Plugin pattern, which allows
+    you to add new functionality to edx-platform without modifying core code.
+
+    Key Features Demonstrated:
+    - URL configuration for both LMS and CMS
+    - Settings integration across environments (common, test, production)
+    - Signal handler registration for Open edX Events
+    - Proper plugin app structure following Open edX patterns
+
+    Official Documentation:
+    - Plugin Creation: https://docs.openedx.org/projects/edx-django-utils/en/latest/plugins/how_tos/how_to_create_a_plugin_app.html
+    - Plugin Overview: https://docs.openedx.org/projects/edx-django-utils/en/latest/plugins/readme.html
+    - Hooks Framework: https://docs.openedx.org/en/latest/developers/concepts/hooks_extension_framework.html
+
+    Real-World Usage:
+    This pattern is used when you need to:
+    - Add new models and database tables
+    - Provide new REST API endpoints
+    - Integrate with external systems via events
+    - Modify platform behavior with filters
+    - Add custom business logic
+
+    Entry Point Configuration:
+    This plugin is registered in pyproject.toml as::
+
+        [project.entry-points."lms.djangoapp"]
+        openedx_plugin_sample = "openedx_plugin_sample.apps:SamplePluginConfig"
+
+        [project.entry-points."cms.djangoapp"]
+        openedx_plugin_sample = "openedx_plugin_sample.apps:SamplePluginConfig"
+
+    The platform automatically discovers and loads plugins registered in these entry points.
+    """  # pylint: disable=line-too-long # noqa: E501
+
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "openedx_plugin_sample"
+    plugin_app = {
+        "url_config": {
+            "lms.djangoapp": {
+                PluginURLs.NAMESPACE: "openedx_plugin_sample",
+                PluginURLs.REGEX: r"^sample-plugin/",
+                PluginURLs.RELATIVE_PATH: "urls",
+            },
+            "cms.djangoapp": {
+                PluginURLs.NAMESPACE: "openedx_plugin_sample",
+                PluginURLs.REGEX: r"^sample-plugin/",
+                PluginURLs.RELATIVE_PATH: "urls",
+            },
+        },
+        PluginSettings.CONFIG: {
+            "lms.djangoapp": {
+                "common": {
+                    PluginURLs.RELATIVE_PATH: "settings.common",
+                },
+                "test": {
+                    PluginURLs.RELATIVE_PATH: "settings.test",
+                },
+                "production": {
+                    PluginURLs.RELATIVE_PATH: "settings.production",
+                },
+            },
+            "cms.djangoapp": {
+                "common": {
+                    PluginURLs.RELATIVE_PATH: "settings.common",
+                },
+                "test": {
+                    PluginURLs.RELATIVE_PATH: "settings.test",
+                },
+                "production": {
+                    PluginURLs.RELATIVE_PATH: "settings.production",
+                },
+            },
+        },
+        # Alternative: PluginSignals.CONFIG
+        # You can define signal connections here instead of in ready(), but the
+        # ready() method approach is more flexible for complex signal handling.
+        #
+        # Example PluginSignals configuration:
+        # PluginSignals.CONFIG: {
+        #     "lms.djangoapp": {
+        #         "relative_path": "signals",
+        #         "receivers": [{
+        #             "receiver_func_name": "unarchive_on_verified_upgrade",
+        #             "signal_path": "openedx_events.learning.signals.COURSE_ENROLLMENT_CHANGED",
+        #         }]
+        #     }
+        # }
+        #
+        # Documentation:
+        # - PluginSignals: https://docs.openedx.org/projects/edx-django-utils/en/latest/plugins/how_tos/how_to_create_a_plugin_app.html#plugin-signals  # noqa: E501
+        # - Open edX Events: https://docs.openedx.org/projects/openedx-events/en/latest/
+    }
+
+    def ready(self):
+        """
+        Initialize the plugin when Django starts.
+
+        This method is called when Django initializes this app. It's the proper
+        place to import signal handlers, register filters, and perform other
+        startup tasks.
+
+        Key Responsibilities:
+        - Import signal handlers to register Open edX Event receivers
+        - Register Open edX Filters (if not done via settings)
+        - Initialize any plugin-specific configuration
+        - Perform validation checks
+
+        Django Documentation:
+        - AppConfig.ready(): https://docs.djangoproject.com/en/stable/ref/applications/#django.apps.AppConfig.ready
+
+        Open edX Documentation:
+        - Events: https://docs.openedx.org/projects/openedx-events/en/latest/how-tos/consume-an-event.html
+        - Filters: https://docs.openedx.org/projects/openedx-filters/en/latest/how-tos/using-filters.html
+
+        Why Import in ready():
+        Signal handlers must be imported for the @receiver decorators to register
+        with Django's signal dispatcher. Importing in ready() ensures this happens
+        when the app initializes, not when modules are first loaded.
+        """
+        # Import signal handlers to register Open edX Event receivers
+        # This import registers all @receiver decorated functions in signals.py
+        from . import signals  # pylint: disable=import-outside-toplevel,unused-import

openedx_plugin_sample/conf/locale/config.yaml

@@ -0,0 +1,85 @@
+# Configuration for i18n workflow.
+
+locales:
+    - en  # English - Source Language
+    - am  # Amharic
+    - ar  # Arabic
+    - az  # Azerbaijani
+    - bg_BG  # Bulgarian (Bulgaria)
+    - bn_BD  # Bengali (Bangladesh)
+    - bn_IN  # Bengali (India)
+    - bs  # Bosnian
+    - ca  # Catalan
+    - ca@valencia  # Catalan (Valencia)
+    - cs  # Czech
+    - cy  # Welsh
+    - da  # Danish
+    - de_DE  # German (Germany)
+    - el  # Greek
+    - en  # English
+    - en_GB  # English (United Kingdom)
+    # Don't pull these until we figure out why pages randomly display in these locales,
+    # when the user's browser is in English and the user is not logged in.
+    # - en@lolcat  # LOLCAT English
+    # - en@pirate  # Pirate English
+    - es_419  # Spanish (Latin America)
+    - es_AR  # Spanish (Argentina)
+    - es_EC  # Spanish (Ecuador)
+    - es_ES  # Spanish (Spain)
+    - es_MX  # Spanish (Mexico)
+    - es_PE  # Spanish (Peru)
+    - et_EE  # Estonian (Estonia)
+    - eu_ES  # Basque (Spain)
+    - fa  # Persian
+    - fa_IR  # Persian (Iran)
+    - fi_FI  # Finnish (Finland)
+    - fil  # Filipino
+    - fr  # French
+    - gl  # Galician
+    - gu  # Gujarati
+    - he  # Hebrew
+    - hi  # Hindi
+    - hr  # Croatian
+    - hu  # Hungarian
+    - hy_AM  # Armenian (Armenia)
+    - id  # Indonesian
+    - it_IT  # Italian (Italy)
+    - ja_JP  # Japanese (Japan)
+    - kk_KZ  # Kazakh (Kazakhstan)
+    - km_KH  # Khmer (Cambodia)
+    - kn  # Kannada
+    - ko_KR  # Korean (Korea)
+    - lt_LT  # Lithuanian (Lithuania)
+    - ml  # Malayalam
+    - mn  # Mongolian
+    - mr  # Marathi
+    - ms  # Malay
+    - nb  # Norwegian Bokmål
+    - ne  # Nepali
+    - nl_NL  # Dutch (Netherlands)
+    - or  # Oriya
+    - pl  # Polish
+    - pt_BR  # Portuguese (Brazil)
+    - pt_PT  # Portuguese (Portugal)
+    - ro  # Romanian
+    - ru  # Russian
+    - si  # Sinhala
+    - sk  # Slovak
+    - sl  # Slovenian
+    - sq  # Albanian
+    - sr  # Serbian
+    - ta  # Tamil
+    - te  # Telugu
+    - th  # Thai
+    - tr_TR  # Turkish (Turkey)
+    - uk  # Ukrainian
+    - ur  # Urdu
+    - uz  # Uzbek
+    - vi  # Vietnamese
+    - zh_CN  # Chinese (China)
+    - zh_HK  # Chinese (Hong Kong)
+    - zh_TW  # Chinese (Taiwan)
+
+# The locales used for fake-accented English, for testing.
+dummy_locales:
+    - eo

openedx_plugin_sample/migrations/0001_initial.py

@@ -0,0 +1,36 @@
+# Generated by Django 5.2.13 on 2026-05-14 01:13
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('openedx_catalog', '0001_initial'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='CourseArchiveStatus',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('is_archived', models.BooleanField(db_index=True, default=False, help_text='Whether the course is archived.')),
+                ('archive_date', models.DateTimeField(blank=True, help_text='The date and time when the course was archived.', null=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('course_run', models.ForeignKey(help_text='The course run that this archive status is for.', on_delete=django.db.models.deletion.CASCADE, related_name='archive_statuses', to='openedx_catalog.courserun')),
+                ('user', models.ForeignKey(help_text='The user who this archive status is for.', on_delete=django.db.models.deletion.CASCADE, related_name='course_archive_statuses', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'verbose_name': 'Course Archive Status',
+                'verbose_name_plural': 'Course Archive Statuses',
+                'ordering': ['-updated_at'],
+                'constraints': [models.UniqueConstraint(fields=('course_run', 'user'), name='unique_user_course_archive_status')],
+            },
+        ),
+    ]

openedx_plugin_sample/models.py

@@ -0,0 +1,70 @@
+"""
+Database models for openedx_plugin_sample.
+"""
+
+from django.contrib.auth import get_user_model
+from django.db import models
+from openedx_catalog.models import CourseRun
+
+
+class CourseArchiveStatus(models.Model):
+    """
+    Model to track the archive status of a course.
+
+    Stores information about whether a course has been archived and when it was archived.
+
+    .. no_pii: This model does not store PII directly, only references to users via foreign keys.
+    """
+
+    course_run = models.ForeignKey(
+        CourseRun,
+        on_delete=models.CASCADE,
+        related_name="archive_statuses",
+        help_text="The course run that this archive status is for.",
+    )
+
+    user = models.ForeignKey(
+        get_user_model(),
+        on_delete=models.CASCADE,
+        related_name="course_archive_statuses",
+        help_text="The user who this archive status is for.",
+    )
+
+    is_archived = models.BooleanField(
+        default=False,
+        db_index=True,  # Add index for performance on this frequently filtered field
+        help_text="Whether the course is archived.",
+    )
+
+    archive_date = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="The date and time when the course was archived.",
+    )
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        """
+        Return a string representation of the course archive status.
+        """
+        # pylint: disable=no-member
+        # Identify the course by its course_key string, never by the internal PK.
+        archived = "Archived" if self.is_archived else "Not Archived"
+        return f"{self.course_run.course_key} - {self.user.username} - {archived}"
+
+    class Meta:
+        """
+        Meta options for the CourseArchiveStatus model.
+        """
+
+        verbose_name = "Course Archive Status"
+        verbose_name_plural = "Course Archive Statuses"
+        ordering = ["-updated_at"]
+        # Ensure combination of course_run and user is unique
+        constraints = [
+            models.UniqueConstraint(
+                fields=["course_run", "user"], name="unique_user_course_archive_status"
+            )
+        ]

openedx_plugin_sample/pipeline.py

@@ -0,0 +1,91 @@
+"""
+Open edX Filters implementation for the openedx_plugin_sample application.
+
+This module demonstrates how to use Open edX Filters to modify platform behavior
+without changing core code. Filters are part of the Hooks Extension Framework
+and allow you to intercept and modify data at specific points in the platform.
+
+What Are Open edX Filters?
+Filters are functions that can modify application behavior by altering input data
+or halting execution based on specific conditions. Unlike events (which only
+observe), filters can change what happens next in the platform.
+
+Key Concepts:
+- Filters receive data and return modified data
+- They run at specific pipeline steps during platform operations
+- Filters can halt execution by raising exceptions
+- Multiple filters can be chained together in a pipeline
+- Filters should be lightweight and handle errors gracefully
+
+Official Documentation:
+- Filters Overview: https://docs.openedx.org/projects/openedx-filters/en/latest/
+- Using Filters: https://docs.openedx.org/projects/openedx-filters/en/latest/how-tos/using-filters.html
+- Available Filters: https://docs.openedx.org/projects/openedx-filters/en/latest/reference/filters.html
+- Filter Tooling: https://docs.openedx.org/projects/openedx-filters/en/latest/reference/filters-tooling.html
+
+Registration Process:
+1. Create filter class inheriting from PipelineStep
+2. Implement run_filter() method with correct signature
+3. Register filter in Django settings OPEN_EDX_FILTERS_CONFIG
+4. Deploy and test the filter behavior
+
+Common Use Cases:
+- URL redirection and customization
+- Access control and permission checks
+- Data transformation and validation
+- Integration with external systems
+- Custom business logic implementation
+"""
+
+import logging
+
+import crum
+from openedx_filters.filters import PipelineStep
+
+from .models import CourseArchiveStatus
+
+logger = logging.getLogger(__name__)
+
+
+class AddArchiveStatusToLearnerHomeCourseRun(PipelineStep):
+    """
+    Customize each courseRun within a Learner Dashboard's /init API response to include the CourseArchiveStatus.
+    """  # noqa: E501
+
+    def run_filter(self, serialized_courserun, **kwargs):  # pylint: disable=arguments-differ
+        """
+        Insert `isArchivedByLearner` into one serialized courseRun for the Learner Home /init response.
+
+        Args:
+            serialized_courserun (dict): One courseRun from the serializer. Reads
+                `courseId` (a course key string, e.g. "course-v1:edX+DemoX+Demo_Course");
+                all other fields are passed through unchanged.
+
+        Returns:
+            dict: ``{"serialized_courserun": <updated dict>}``. The updated dict has the
+                same keys as the input plus `isArchivedByLearner` (bool) -- True iff a
+                CourseArchiveStatus row exists for the current request user and this
+                courseId with `is_archived=True`; False otherwise (including when no row
+                exists).
+
+        The current user is read from the active request via `crum`, so this filter only
+        runs meaningfully inside a request cycle. Note that `isArchivedByLearner` is
+        distinct from `isArchived`, which the platform sets based on whether the course
+        run itself has ended.
+        """  # noqa: E501
+        request = crum.get_current_request()
+        if not (request and request.user):
+            return serialized_courserun
+        try:
+            is_archived_by_learner = CourseArchiveStatus.objects.get(
+                user=request.user,
+                course_run__course_key=serialized_courserun["courseId"],
+            ).is_archived
+        except CourseArchiveStatus.DoesNotExist:
+            is_archived_by_learner = False
+        return {
+            "serialized_courserun": {
+                **serialized_courserun,
+                "isArchivedByLearner": is_archived_by_learner,
+            },
+        }

openedx_plugin_sample/serializers.py

@@ -0,0 +1,61 @@
+"""
+Serializers for the openedx_plugin_sample app.
+"""
+
+from django.contrib.auth import get_user_model
+from openedx_catalog.models import CourseRun
+from rest_framework import serializers
+
+from openedx_plugin_sample.models import CourseArchiveStatus
+
+User = get_user_model()
+
+
+class CourseArchiveStatusSerializer(serializers.ModelSerializer):
+    """
+    Serializer for the CourseArchiveStatus model.
+    """
+
+    user = serializers.PrimaryKeyRelatedField(
+        queryset=User.objects.all(),
+        default=serializers.CurrentUserDefault(),
+        required=False,
+    )
+
+    # The model stores a FK to CourseRun, but APIs should identify courses by
+    # their full course key string (e.g. "course-v1:edX+DemoX+Demo_Course"),
+    # never by CourseRun's internal integer PK. The slug field looks up the
+    # related CourseRun by its `course_key` for both reads and writes.
+    course_id = serializers.SlugRelatedField(
+        source="course_run",
+        slug_field="course_key",
+        queryset=CourseRun.objects.all(),
+    )
+
+    class Meta:
+        """
+        Meta class for CourseArchiveStatusSerializer.
+        """
+
+        model = CourseArchiveStatus
+        fields = [
+            "id",
+            "course_id",
+            "user",
+            "is_archived",
+            "archive_date",
+            "created_at",
+            "updated_at",
+        ]
+        read_only_fields = ["id", "created_at", "updated_at", "archive_date"]
+
+    def to_representation(self, instance):
+        """
+        Serialize the instance, casting course_id to a string.
+
+        CourseRun.course_key returns a CourseLocator (not a string), which the
+        default JSON encoder can't serialize, so we coerce to str on output.
+        """
+        data = super().to_representation(instance)
+        data["course_id"] = str(data["course_id"])
+        return data

openedx_plugin_sample/settings/common.py

@@ -0,0 +1,136 @@
+"""
+Common settings for the openedx_plugin_sample application.
+
+This module demonstrates how Django App Plugins integrate with the platform's
+settings system. Plugin settings are merged with the main settings during
+platform initialization.
+
+Plugin Settings Integration:
+The plugin_settings function is called during Django startup and receives
+the main settings object. You can modify this object to add plugin-specific
+configuration that integrates seamlessly with the platform.
+
+Official Documentation:
+- Plugin Settings:
+  https://docs.openedx.org/projects/edx-django-utils/en/latest/plugins/how_tos/how_to_create_a_plugin_app.html#plugin-settings
+- Django Settings: https://docs.djangoproject.com/en/stable/topics/settings/
+
+Settings Organization:
+- common.py: Settings for all environments
+- production.py: Production-specific overrides
+- test.py: Test environment optimizations
+
+Integration Points:
+- OPEN_EDX_FILTERS_CONFIG: Register filters with the platform
+- API rate limiting and throttling configuration
+- Database connection settings for plugin models
+- External service integration parameters
+- Feature flags and environment-specific toggles
+"""  # noqa: E501
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def plugin_settings(settings):
+    """
+    Configure plugin-specific Django settings.
+
+    This function is called during Django startup to merge plugin settings
+    with the main platform configuration. All settings added here become
+    available throughout the Django application.
+
+    Args:
+        settings (dict): Main Django settings object to modify
+
+    Common Settings Patterns:
+
+    # Plugin-specific configuration
+    settings.SAMPLE_PLUGIN_API_RATE_LIMIT = "60/minute"
+    settings.SAMPLE_PLUGIN_ARCHIVE_RETENTION_DAYS = 365
+
+    # External service integration
+    settings.SAMPLE_PLUGIN_EXTERNAL_API_URL = "https://api.example.com"
+    settings.SAMPLE_PLUGIN_API_KEY = "your-api-key"
+
+    # Feature flags
+    settings.SAMPLE_PLUGIN_ENABLE_ARCHIVING = True
+    settings.SAMPLE_PLUGIN_ENABLE_NOTIFICATIONS = False
+
+    Environment-Specific Settings:
+    Different environment files can override these settings:
+    - production.py: Stricter rate limits, external API endpoints
+    - test.py: Faster timeouts, mock services, in-memory databases
+    - development.py: Debug logging, local service endpoints
+
+    Security Considerations:
+    - Never commit API keys or secrets to version control
+    - Use environment variables for sensitive configuration
+    - Validate setting values to prevent configuration errors
+    """
+    # Plugin is configured but no additional settings needed for this basic example
+    # Uncomment and modify the examples below for your use case:
+
+    # Plugin-specific configuration
+    # settings.SAMPLE_PLUGIN_API_RATE_LIMIT = "60/minute"
+    # settings.SAMPLE_PLUGIN_ARCHIVE_RETENTION_DAYS = 365
+
+    # Register Open edX Filters (additive approach)
+    _configure_openedx_filters(settings)
+
+
+def _configure_openedx_filters(settings):
+    """
+    Configure Open edX Filters for the sample plugin.
+
+    This function demonstrates the proper way to register filters by:
+    1. Preserving existing filter configuration from other plugins
+    2. Adding our filter configuration additively
+    3. Avoiding duplicate pipeline steps
+    4. Logging configuration state for debugging
+
+    Args:
+        settings (dict): Django settings object
+    """
+    # Get existing filter configuration (may be from other plugins or platform)
+    filters_config = getattr(settings, 'OPEN_EDX_FILTERS_CONFIG', {})
+
+    # Filter we want to register
+    filter_name = "org.openedx.learning.home.courserun.api.rendered.started.v1"
+    our_pipeline_step = "openedx_plugin_sample.pipeline.AddArchiveStatusToLearnerHomeCourseRun"
+
+    # Check if this filter already has configuration
+    if filter_name in filters_config:
+        logger.debug(f"Filter {filter_name} already configured, adding our pipeline step")
+
+        # Get existing pipeline steps
+        existing_pipeline = filters_config[filter_name].get("pipeline", [])
+
+        # Check if our pipeline step is already registered
+        if our_pipeline_step in existing_pipeline:
+            logger.info(
+                f"Pipeline step {our_pipeline_step} already registered for filter {filter_name}. "
+                "This may indicate the plugin is being loaded multiple times or another plugin "
+                "has registered the same pipeline step."
+            )
+        else:
+            # Add our pipeline step to existing configuration
+            existing_pipeline.append(our_pipeline_step)
+            filters_config[filter_name]["pipeline"] = existing_pipeline
+            logger.debug(f"Added {our_pipeline_step} to existing filter configuration")
+    else:
+        # Create new filter configuration
+        logger.debug(f"Creating new filter configuration for {filter_name}")
+        filters_config[filter_name] = {
+            "pipeline": [our_pipeline_step],
+            "fail_silently": False,
+        }
+
+    # Update the settings object
+    settings.OPEN_EDX_FILTERS_CONFIG = filters_config
+
+    logger.debug(
+        f"Final filter configuration for {filter_name}: "
+        f"{filters_config.get(filter_name, {})}"
+    )