ol-openedx-auto-select-language 0.1.0__tar.gz

ol_openedx_auto_select_language-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+# Build artifacts
+/dist/
+/.pids
+# Python files
+/.venv/
+/.idea/
+__pycache__/
+*.egg-info/
+*.DS_Store
+# Test Runtime
+ol_test_requirements.txt
+**/.coverage
+**/test_root
+coverage.xml

ol_openedx_auto_select_language-0.1.0/LICENSE.txt

@@ -0,0 +1,28 @@
+Copyright (C) 2022  MIT Open Learning
+
+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 name of the copyright holder nor the names of its
+  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 THE COPYRIGHT HOLDER OR CONTRIBUTORS 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.

ol_openedx_auto_select_language-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: ol-openedx-auto-select-language
+Version: 0.1.0
+Summary: An Open edX plugin to auto-select the language based on course language settings.
+Author: MIT Office of Digital Learning
+License-Expression: BSD-3-Clause
+License-File: LICENSE.txt
+Keywords: Python,edx
+Requires-Python: >=3.11
+Requires-Dist: django>=4.0
+Requires-Dist: djangorestframework>=3.14.0
+Requires-Dist: edx-opaque-keys
+Description-Content-Type: text/x-rst
+
+OL Open edX Auto Select Language
+================================
+
+An Open edX plugin to auto select the Open edX platform language based on the course language.
+
+Purpose
+*******
+
+Auto select the Open edX platform language based on the course language. When enabled, users will see the static site content in the course's configured language.
+
+Setup
+=====
+
+For detailed installation instructions, please refer to the `plugin installation guide <../../docs#installation-guide>`_.
+
+Installation required in:
+
+* Studio (CMS)
+* LMS
+
+Configuration
+=============
+
+- Add the following configuration values to the config file in Open edX. For any release after Juniper, that config file is ``/edx/etc/lms.yml`` and ``/edx/etc/cms.yml``. If you're using ``private.py``, add these values to ``lms/envs/private.py`` and ``cms/envs/private.py``. These should be added to the top level. **Ask a fellow developer for these values.**
+
+  .. code-block:: python
+
+       # Enable auto language selection
+       ENABLE_AUTO_LANGUAGE_SELECTION: true
+
+- For Tutor installations, these values can also be managed through a `custom Tutor plugin <https://docs.tutor.edly.io/tutorials/plugin.html#plugin-development-tutorial>`_.
+
+Auto Language Selection
+=======================
+
+The plugin includes an auto language selection feature that automatically sets the user's language preference based on the course language. When enabled, users will see the static site content in the course's configured language.
+
+To enable auto language selection:
+
+1. Set ``ENABLE_AUTO_LANGUAGE_SELECTION`` to ``true`` in your settings.
+
+2. Set ``SHARED_COOKIE_DOMAIN`` to your domain (e.g., ``.local.openedx.io`` for local tutor setup) to allow cookies to be shared between LMS and CMS.
+
+**How it works:**
+
+- **LMS**: The ``CourseLanguageCookieMiddleware`` automatically detects course URLs and sets the language preference based on the course's configured language.
+- **CMS**: The ``CourseLanguageCookieResetMiddleware`` ensures Studio always uses English for the authoring interface.
+- **Admin areas**: Admin URLs (``/admin``, ``/sysadmin``, instructor dashboards) are forced to use English regardless of course language.
+
+MFE Integration
+===============
+
+To make auto language selection work with Micro-Frontends (MFEs), you need to use a custom Footer component that handles language detection and switching.
+
+**Setup:**
+
+1. Use the Footer component from `src/bridge/settings/openedx/mfe/slot_config/Footer.jsx <https://github.com/mitodl/ol-infrastructure/blob/main/src/bridge/settings/openedx/mfe/slot_config/Footer.jsx>`_ in the `ol-infrastructure <https://github.com/mitodl/ol-infrastructure>`_ repository.
+
+2. Enable auto language selection in each MFE by adding the following to their ``.env.development`` file:
+
+   .. code-block:: bash
+
+       ENABLE_AUTO_LANGUAGE_SELECTION="true"
+
+3. This custom Footer component:
+   - Detects the current course context in MFEs
+   - Automatically switches the MFE language based on the course's configured language
+   - Ensures consistent language experience across the platform
+
+4. Configure your MFE slot overrides to use this custom Footer component instead of the default one.
+
+**Note:** The custom Footer is required because MFEs run as separate applications and need their own mechanism to detect and respond to course language settings. The environment variable must be set in each MFE's configuration for the feature to work properly.
+
+License
+*******
+
+The code in this repository is licensed under the AGPL 3.0 unless
+otherwise noted.
+
+Please see `LICENSE.txt <LICENSE.txt>`_ for details.

ol_openedx_auto_select_language-0.1.0/README.rst

@@ -0,0 +1,80 @@
+OL Open edX Auto Select Language
+================================
+
+An Open edX plugin to auto select the Open edX platform language based on the course language.
+
+Purpose
+*******
+
+Auto select the Open edX platform language based on the course language. When enabled, users will see the static site content in the course's configured language.
+
+Setup
+=====
+
+For detailed installation instructions, please refer to the `plugin installation guide <../../docs#installation-guide>`_.
+
+Installation required in:
+
+* Studio (CMS)
+* LMS
+
+Configuration
+=============
+
+- Add the following configuration values to the config file in Open edX. For any release after Juniper, that config file is ``/edx/etc/lms.yml`` and ``/edx/etc/cms.yml``. If you're using ``private.py``, add these values to ``lms/envs/private.py`` and ``cms/envs/private.py``. These should be added to the top level. **Ask a fellow developer for these values.**
+
+  .. code-block:: python
+
+       # Enable auto language selection
+       ENABLE_AUTO_LANGUAGE_SELECTION: true
+
+- For Tutor installations, these values can also be managed through a `custom Tutor plugin <https://docs.tutor.edly.io/tutorials/plugin.html#plugin-development-tutorial>`_.
+
+Auto Language Selection
+=======================
+
+The plugin includes an auto language selection feature that automatically sets the user's language preference based on the course language. When enabled, users will see the static site content in the course's configured language.
+
+To enable auto language selection:
+
+1. Set ``ENABLE_AUTO_LANGUAGE_SELECTION`` to ``true`` in your settings.
+
+2. Set ``SHARED_COOKIE_DOMAIN`` to your domain (e.g., ``.local.openedx.io`` for local tutor setup) to allow cookies to be shared between LMS and CMS.
+
+**How it works:**
+
+- **LMS**: The ``CourseLanguageCookieMiddleware`` automatically detects course URLs and sets the language preference based on the course's configured language.
+- **CMS**: The ``CourseLanguageCookieResetMiddleware`` ensures Studio always uses English for the authoring interface.
+- **Admin areas**: Admin URLs (``/admin``, ``/sysadmin``, instructor dashboards) are forced to use English regardless of course language.
+
+MFE Integration
+===============
+
+To make auto language selection work with Micro-Frontends (MFEs), you need to use a custom Footer component that handles language detection and switching.
+
+**Setup:**
+
+1. Use the Footer component from `src/bridge/settings/openedx/mfe/slot_config/Footer.jsx <https://github.com/mitodl/ol-infrastructure/blob/main/src/bridge/settings/openedx/mfe/slot_config/Footer.jsx>`_ in the `ol-infrastructure <https://github.com/mitodl/ol-infrastructure>`_ repository.
+
+2. Enable auto language selection in each MFE by adding the following to their ``.env.development`` file:
+
+   .. code-block:: bash
+
+       ENABLE_AUTO_LANGUAGE_SELECTION="true"
+
+3. This custom Footer component:
+   - Detects the current course context in MFEs
+   - Automatically switches the MFE language based on the course's configured language
+   - Ensures consistent language experience across the platform
+
+4. Configure your MFE slot overrides to use this custom Footer component instead of the default one.
+
+**Note:** The custom Footer is required because MFEs run as separate applications and need their own mechanism to detect and respond to course language settings. The environment variable must be set in each MFE's configuration for the feature to work properly.
+
+License
+*******
+
+The code in this repository is licensed under the AGPL 3.0 unless
+otherwise noted.
+
+Please see `LICENSE.txt <LICENSE.txt>`_ for details.

ol_openedx_auto_select_language-0.1.0/ol_openedx_auto_select_language/__init__.py

@@ -0,0 +1,3 @@
+"""
+MIT's Open edX auto language selection plugin
+"""

ol_openedx_auto_select_language-0.1.0/ol_openedx_auto_select_language/apps.py

@@ -0,0 +1,34 @@
+"""
+ol_openedx_auto_select_language Django application initialization.
+"""
+
+from django.apps import AppConfig
+from edx_django_utils.plugins import PluginSettings, PluginURLs
+from openedx.core.djangoapps.plugins.constants import ProjectType, SettingsType
+
+
+class OLOpenEdxAutoSelectLanguageConfig(AppConfig):
+    """
+    Configuration for the ol_openedx_auto_select_language Django application.
+    """
+
+    name = "ol_openedx_auto_select_language"
+    verbose_name = "OL Auto Select Language"
+
+    plugin_app = {
+        PluginURLs.CONFIG: {
+            ProjectType.LMS: {
+                PluginURLs.NAMESPACE: "",
+                PluginURLs.REGEX: "",
+                PluginURLs.RELATIVE_PATH: "urls",
+            }
+        },
+        PluginSettings.CONFIG: {
+            ProjectType.CMS: {
+                SettingsType.COMMON: {PluginSettings.RELATIVE_PATH: "settings.cms"},
+            },
+            ProjectType.LMS: {
+                SettingsType.COMMON: {PluginSettings.RELATIVE_PATH: "settings.lms"},
+            },
+        },
+    }

ol_openedx_auto_select_language-0.1.0/ol_openedx_auto_select_language/constants.py

@@ -0,0 +1,3 @@
+"""Constants for ol_openedx_auto_select_language."""
+
+ENGLISH_LANGUAGE_CODE = "en"

ol_openedx_auto_select_language-0.1.0/ol_openedx_auto_select_language/filters.py

@@ -0,0 +1,58 @@
+"""
+Filters for Open edX auto select language.
+"""
+
+from openedx_filters import PipelineStep
+from xmodule.modulestore.django import modulestore
+
+from ol_openedx_auto_select_language.constants import (
+    ENGLISH_LANGUAGE_CODE,
+)
+from ol_openedx_auto_select_language.utils import LanguageCode
+
+VIDEO_BLOCK_TYPE = "video"
+
+
+class AddDestLangForVideoBlock(PipelineStep):
+    """
+    Pipeline step to add destination language for video transcripts
+    """
+
+    def run_filter(self, context, student_view_context):
+        """
+        Add the destination language to the student view context if a video block
+        with transcripts in the course language is found among the child blocks.
+        """
+
+        def set_dest_lang_for_video_block(block_key):
+            """
+            Set the destination language for video blocks with
+            transcripts in the course language.
+            """
+            student_view_context["dest_lang"] = (
+                ENGLISH_LANGUAGE_CODE  # default to English
+            )
+            video_block = modulestore().get_item(block_key)
+            transcripts_info = video_block.get_transcripts_info()
+            dest_lang = getattr(
+                context.get("course", None), "language", ENGLISH_LANGUAGE_CODE
+            )
+            dest_lang = LanguageCode(dest_lang).to_bcp47()
+            if (
+                transcripts_info
+                and transcripts_info.get("transcripts", {})
+                and dest_lang in transcripts_info["transcripts"]
+            ):
+                student_view_context["dest_lang"] = dest_lang
+
+        block = dict(context)["block"]
+        block_usage_key = block.usage_key
+        block_type = block_usage_key.block_type
+        if block_type == "vertical":
+            for child in getattr(block, "children", []):
+                if child.block_type == VIDEO_BLOCK_TYPE:
+                    set_dest_lang_for_video_block(child)
+        elif block_type == VIDEO_BLOCK_TYPE:
+            set_dest_lang_for_video_block(block_usage_key)
+
+        return {"context": context, "student_view_context": student_view_context}

ol_openedx_auto_select_language-0.1.0/ol_openedx_auto_select_language/middleware.py

@@ -0,0 +1,145 @@
+"""
+Middleware to set/reset language preference cookie and
+user preference based on course language.
+"""
+
+import re
+
+from django.conf import settings
+from django.http import HttpResponseRedirect
+from django.utils.deprecation import MiddlewareMixin
+from opaque_keys.edx.keys import CourseKey
+from openedx.core.djangoapps.content.course_overviews.models import CourseOverview
+from openedx.core.djangoapps.lang_pref import LANGUAGE_KEY
+from openedx.core.djangoapps.lang_pref import helpers as lang_pref_helpers
+from openedx.core.djangoapps.user_api.preferences.api import set_user_preference
+
+from ol_openedx_auto_select_language.constants import ENGLISH_LANGUAGE_CODE
+from ol_openedx_auto_select_language.utils import LanguageCode
+
+
+def should_process_request(request):
+    """
+    Return True if language auto-selection should run for this request.
+    """
+    return (
+        settings.ENABLE_AUTO_LANGUAGE_SELECTION
+        and hasattr(request, "user")
+        and request.user.is_authenticated
+    )
+
+
+def set_language(request, response, language):
+    """
+    Set both cookie and user preference for language.
+    """
+    lang_pref_helpers.set_language_cookie(request, response, language)
+    set_user_preference(request.user, LANGUAGE_KEY, language)
+
+
+def redirect_current_path(request):
+    """
+    Redirect to the same URL to ensure language change takes effect.
+    """
+    return HttpResponseRedirect(request.get_full_path())
+
+
+class CourseLanguageCookieMiddleware(MiddlewareMixin):
+    """
+    LMS middleware that:
+    - Sets language based on course language
+    - Forces English for exempt paths and authoring MFEs
+    """
+
+    COURSE_URL_REGEX = re.compile(
+        rf"^/courses/(?P<course_key>{settings.COURSE_KEY_REGEX})(?:/|$)",
+        re.IGNORECASE,
+    )
+
+    def process_response(self, request, response):
+        """
+        Process the response to set/reset language cookie based on course language.
+        """
+        if not should_process_request(request):
+            return response
+
+        path = getattr(request, "path_info", request.path)
+
+        if self._should_force_english(request, path):
+            return self._force_english_if_needed(request, response)
+
+        course_language = self._get_course_language(path)
+        if not course_language:
+            return response
+
+        return self._apply_course_language(request, response, course_language)
+
+    def _should_force_english(self, request, path):
+        """
+        Determine if English should be forced based on request origin or exempt paths.
+        """
+        return request.META.get(
+            "HTTP_ORIGIN"
+        ) == settings.COURSE_AUTHORING_MICROFRONTEND_URL or any(
+            exempt_path in path
+            for exempt_path in settings.AUTO_LANGUAGE_SELECTION_EXEMPT_PATHS
+        )
+
+    def _force_english_if_needed(self, request, response):
+        """
+        Force language to English if not already set.
+        """
+        cookie_val = lang_pref_helpers.get_language_cookie(request)
+
+        if cookie_val != ENGLISH_LANGUAGE_CODE:
+            set_language(request, response, ENGLISH_LANGUAGE_CODE)
+            return redirect_current_path(request)
+
+        return response
+
+    def _get_course_language(self, path):
+        """
+        Extract course language from the course URL path.
+        """
+        match = self.COURSE_URL_REGEX.match(path)
+        if not match:
+            return None
+
+        try:
+            course_key = CourseKey.from_string(match.group("course_key"))
+            overview = CourseOverview.get_from_id(course_key)
+        except Exception:  # noqa: BLE001
+            return None
+
+        return getattr(overview, "language", None)
+
+    def _apply_course_language(self, request, response, language):
+        """
+        Apply the course language if it differs from the current cookie value.
+        """
+        language = LanguageCode(language).to_bcp47()
+        cookie_val = lang_pref_helpers.get_language_cookie(request)
+        if cookie_val != language:
+            set_language(request, response, language)
+            return redirect_current_path(request)
+
+        return response
+
+
+class CourseLanguageCookieResetMiddleware(MiddlewareMixin):
+    """
+    CMS middleware that always resets language to English.
+    """
+
+    def process_response(self, request, response):
+        """
+        Process the response to reset language cookie to English.
+        """
+        if not should_process_request(request):
+            return response
+
+        cookie_val = lang_pref_helpers.get_language_cookie(request)
+        if cookie_val and cookie_val != ENGLISH_LANGUAGE_CODE:
+            set_language(request, response, ENGLISH_LANGUAGE_CODE)
+
+        return response

ol_openedx_auto_select_language-0.1.0/ol_openedx_auto_select_language/settings/cms.py

@@ -0,0 +1,17 @@
+# noqa: INP001
+
+"""Settings to provide to edX"""
+
+from ol_openedx_auto_select_language.settings.common import apply_common_settings
+
+
+def plugin_settings(settings):
+    """
+    Populate cms settings
+    """
+    apply_common_settings(settings)
+    settings.MIDDLEWARE.extend(
+        [
+            "ol_openedx_auto_select_language.middleware.CourseLanguageCookieResetMiddleware"
+        ]
+    )

ol_openedx_auto_select_language-0.1.0/ol_openedx_auto_select_language/settings/common.py

@@ -0,0 +1,14 @@
+# noqa: INP001
+
+"""Common settings for LMS and CMS to provide to edX"""
+
+
+def apply_common_settings(settings):
+    """
+    Apply custom settings function for LMS and CMS settings.
+
+    Args:
+        settings: Django settings object to modify
+    """
+    settings.ENABLE_AUTO_LANGUAGE_SELECTION = False
+    settings.AUTO_LANGUAGE_SELECTION_EXEMPT_PATHS = ["admin", "sysadmin", "instructor"]

ol_openedx_auto_select_language-0.1.0/ol_openedx_auto_select_language/settings/lms.py

@@ -0,0 +1,38 @@
+# noqa: INP001
+
+"""Settings to provide to edX"""
+
+from ol_openedx_auto_select_language.settings.common import apply_common_settings
+
+
+def plugin_settings(settings):
+    """
+    Populate lms settings
+    """
+    apply_common_settings(settings)
+    settings.MIDDLEWARE.extend(
+        ["ol_openedx_auto_select_language.middleware.CourseLanguageCookieMiddleware"]
+    )
+    VIDEO_TRANSCRIPT_LANGUAGE_FILTERS = {
+        "org.openedx.learning.xblock.render.started.v1": {
+            "pipeline": [
+                "ol_openedx_auto_select_language.filters.AddDestLangForVideoBlock"
+            ],
+            "fail_silently": False,
+        }
+    }
+    existing_filters = getattr(settings, "OPEN_EDX_FILTERS_CONFIG", {})
+
+    # Merge pipeline lists instead of overwriting
+    for filter_name, config in VIDEO_TRANSCRIPT_LANGUAGE_FILTERS.items():
+        if filter_name not in existing_filters:
+            existing_filters[filter_name] = config
+        else:
+            existing_filters[filter_name]["pipeline"].extend(config.get("pipeline", []))
+            # do not override fail_silently
+            if "fail_silently" in config:
+                existing_filters[filter_name].setdefault(
+                    "fail_silently", config["fail_silently"]
+                )
+
+    settings.OPEN_EDX_FILTERS_CONFIG = existing_filters

ol_openedx_auto_select_language-0.1.0/ol_openedx_auto_select_language/urls.py

@@ -0,0 +1,23 @@
+"""
+URL configuration for ol_openedx_auto_select_language app.
+"""
+
+from django.conf import settings
+from django.urls import re_path
+
+from ol_openedx_auto_select_language.views import CourseLanguageView
+
+urlpatterns = [
+    re_path(
+        rf"auto-select-language/api/course-language/{settings.COURSE_KEY_PATTERN}$",
+        CourseLanguageView.as_view(),
+        name="ol_course_language",
+    ),
+    # TODO: Remove the legacy endpoint in a  # noqa: FIX002, TD003, TD002
+    #  future release after updating all clients to use the new endpoint.
+    re_path(
+        rf"course-translations/api/course-language/{settings.COURSE_KEY_PATTERN}$",
+        CourseLanguageView.as_view(),
+        name="ol_course_language_legacy",
+    ),
+]

ol_openedx_auto_select_language-0.1.0/ol_openedx_auto_select_language/utils.py

@@ -0,0 +1,96 @@
+"""
+Utils for ol_openedx_auto_select_language.
+"""
+
+import re
+
+
+class LanguageCode:
+    """
+    Utility class for handling language code conversions between
+    Django/Open edX style and BCP47.
+    """
+
+    def __init__(self, lang_code):
+        self.lang_code = lang_code
+
+    def to_bcp47(self) -> str:
+        """
+        Convert Django / Open edX style language codes to BCP47.
+
+        Examples:
+            zh_HANS     -> zh-Hans
+            zh_HANT     -> zh-Hant
+            zh_HANS_CN  -> zh-Hans-CN
+            en_US       -> en-US
+            es_419      -> es-419
+            pt_br       -> pt-BR
+        """
+        if not self.lang_code:
+            return self.lang_code
+
+        parts = self.lang_code.replace("_", "-").split("-")
+        result = []
+        for idx, part in enumerate(parts):
+            if idx == 0:
+                # Language
+                result.append(part.lower())
+
+            elif re.fullmatch(r"[A-Za-z]{4}", part):
+                # Script (Hans, Hant, Latn, Cyrl, etc.)
+                result.append(part.title())
+
+            elif re.fullmatch(r"[A-Za-z]{2}", part):
+                # Region i.e US, PK, CN
+                result.append(part.upper())
+
+            elif re.fullmatch(r"\d{3}", part):
+                # Numeric region (419)
+                result.append(part)
+
+            else:
+                # Variants/extensions
+                result.append(part.lower())
+
+        return "-".join(result)
+
+    def to_django(self) -> str:
+        """
+        Convert BCP47 language tags to Django / Open edX style.
+
+        Examples:
+            zh-Hans     -> zh_HANS
+            zh-Hant     -> zh_HANT
+            zh-Hans-CN  -> zh_HANS_CN
+            en-US       -> en_US
+            es-419      -> es_419
+            pt-BR       -> pt_BR
+        """
+        if not self.lang_code:
+            return self.lang_code
+
+        parts = self.lang_code.replace("_", "-").split("-")
+        result = []
+
+        for idx, part in enumerate(parts):
+            if idx == 0:
+                # Language
+                result.append(part.lower())
+
+            elif re.fullmatch(r"[A-Za-z]{4}", part):
+                # Script
+                result.append(part.upper())
+
+            elif re.fullmatch(r"[A-Za-z]{2}", part):
+                # Region
+                result.append(part.upper())
+
+            elif re.fullmatch(r"\d{3}", part):
+                # Numeric region
+                result.append(part)
+
+            else:
+                # Variants/extensions
+                result.append(part.lower())
+
+        return "_".join(result)

ol_openedx_auto_select_language-0.1.0/ol_openedx_auto_select_language/views.py

@@ -0,0 +1,76 @@
+"""
+API Views for ol_openedx_auto_select_language App
+"""
+
+import logging
+
+from opaque_keys import InvalidKeyError
+from opaque_keys.edx.keys import CourseKey
+from openedx.core.djangoapps.content.course_overviews.models import CourseOverview
+from rest_framework import status
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from ol_openedx_auto_select_language.utils import LanguageCode
+
+log = logging.getLogger(__name__)
+
+
+class CourseLanguageView(APIView):
+    """
+    API View to retrieve the language of a specified course.
+
+    Sample Request:
+        GET /auto-select-language/api/course_language/{course_key}/
+
+    Sample Response:
+        200 OK
+        {
+            "language": "en"
+        }
+
+    Error Responses:
+        400 Bad Request
+        {
+            "error": "Invalid course_key."
+        }
+        404 Not Found
+        {
+            "error": "Course not found."
+        }
+        400 Bad Request
+        {
+            "error": "An unexpected error occurred."
+        }
+    """
+
+    permission_classes = [IsAuthenticated]
+
+    def get(self, request, course_key_string):  # noqa: ARG002
+        """
+        Retrieve the language of the specified course.
+        """
+        try:
+            course_key = CourseKey.from_string(course_key_string)
+            course = CourseOverview.get_from_id(course_key)
+        except InvalidKeyError:
+            log.info("Invalid course key %s", course_key_string)
+            return Response(
+                {"error": "Invalid course_key."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        except CourseOverview.DoesNotExist:
+            log.info("Course not found for key %s", course_key_string)
+            return Response(
+                {"error": "Course not found."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        except Exception:
+            log.exception("Unexpected error retrieving course %s", course_key_string)
+            return Response(
+                {"error": "An unexpected error occurred."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        language = LanguageCode(course.language).to_bcp47()
+        return Response({"language": language})

ol_openedx_auto_select_language-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "ol-openedx-auto-select-language"
+version = "0.1.0"
+description = "An Open edX plugin to auto-select the language based on course language settings."
+authors = [
+  {name = "MIT Office of Digital Learning"}
+]
+license = "BSD-3-Clause"
+readme = "README.rst"
+requires-python = ">=3.11"
+keywords = ["Python", "edx"]
+dependencies = [
+  "Django>=4.0",
+  "djangorestframework>=3.14.0",
+  "edx-opaque-keys",
+]
+
+[project.entry-points."cms.djangoapp"]
+ol_openedx_auto_select_language = "ol_openedx_auto_select_language.apps:OLOpenEdxAutoSelectLanguageConfig"
+
+[project.entry-points."lms.djangoapp"]
+ol_openedx_auto_select_language = "ol_openedx_auto_select_language.apps:OLOpenEdxAutoSelectLanguageConfig"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["ol_openedx_auto_select_language"]
+include = [
+  "ol_openedx_auto_select_language/**/*.py",
+]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "ol_openedx_auto_select_language/**/*",
+  "README.rst",
+  "pyproject.toml",
+]