ol-openedx-course-translations 0.2.0__tar.gz

ol_openedx_course_translations-0.2.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_course_translations-0.2.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_course_translations-0.2.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: ol-openedx-course-translations
+Version: 0.2.0
+Summary: An Open edX plugin to translate courses
+Author: MIT Office of Digital Learning
+License-Expression: BSD-3-Clause
+License-File: LICENSE.txt
+Keywords: Python,edx
+Requires-Python: >=3.11
+Requires-Dist: deepl>=1.25.0
+Requires-Dist: django>=4.0
+Requires-Dist: djangorestframework>=3.14.0
+Description-Content-Type: text/x-rst
+
+OL Open edX Course Translations
+===============================
+
+An Open edX plugin to manage course translations.
+
+Purpose
+*******
+
+Translate course content into multiple languages to enhance accessibility for a global audience.
+
+Setup
+=====
+
+For detailed installation instructions, please refer to the `plugin installation guide <../../docs#installation-guide>`_.
+
+Installation required in:
+
+* Studio (CMS)
+* LMS (for auto language selection feature)
+
+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``. If you're using ``private.py``, add these values to ``lms/envs/private.py``. These should be added to the top level. **Ask a fellow developer for these values.**
+
+  .. code-block:: python
+
+       DEEPL_API_KEY: <YOUR_DEEPL_API_KEY_HERE>
+       ENABLE_AUTO_LANGUAGE_SELECTION: true  # Enable auto language selection based on course language
+
+- 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.
+
+Translating a Course
+====================
+1. Open the course in Studio.
+2. Go to Tools -> Export Course.
+3. Export the course as a .tar.gz file.
+4. Go to the CMS shell
+5. Run the management command to translate the course:
+
+   .. code-block:: bash
+
+        ./manage.py cms translate_course --source-language <SOURCE_LANGUAGE_CODE, defaults to `EN`> --translation-language <TRANSLATION_LANGUAGE_CODE i.e. AR> --course-dir <PATH_TO_EXPORTED_COURSE_TAR_GZ>
+
+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_course_translations-0.2.0/README.rst

@@ -0,0 +1,92 @@
+OL Open edX Course Translations
+===============================
+
+An Open edX plugin to manage course translations.
+
+Purpose
+*******
+
+Translate course content into multiple languages to enhance accessibility for a global audience.
+
+Setup
+=====
+
+For detailed installation instructions, please refer to the `plugin installation guide <../../docs#installation-guide>`_.
+
+Installation required in:
+
+* Studio (CMS)
+* LMS (for auto language selection feature)
+
+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``. If you're using ``private.py``, add these values to ``lms/envs/private.py``. These should be added to the top level. **Ask a fellow developer for these values.**
+
+  .. code-block:: python
+
+       DEEPL_API_KEY: <YOUR_DEEPL_API_KEY_HERE>
+       ENABLE_AUTO_LANGUAGE_SELECTION: true  # Enable auto language selection based on course language
+
+- 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.
+
+Translating a Course
+====================
+1. Open the course in Studio.
+2. Go to Tools -> Export Course.
+3. Export the course as a .tar.gz file.
+4. Go to the CMS shell
+5. Run the management command to translate the course:
+
+   .. code-block:: bash
+
+        ./manage.py cms translate_course --source-language <SOURCE_LANGUAGE_CODE, defaults to `EN`> --translation-language <TRANSLATION_LANGUAGE_CODE i.e. AR> --course-dir <PATH_TO_EXPORTED_COURSE_TAR_GZ>
+
+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_course_translations-0.2.0/ol_openedx_course_translations/__init__.py

@@ -0,0 +1,3 @@
+"""
+MIT's Open edX course translations plugin
+"""

ol_openedx_course_translations-0.2.0/ol_openedx_course_translations/apps.py

@@ -0,0 +1,33 @@
+"""
+ol_openedx_course_translations 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 OLOpenedXCourseTranslationsConfig(AppConfig):
+    """
+    Configuration for the ol_openedx_course_translations Django application.
+    """
+
+    name = "ol_openedx_course_translations"
+
+    plugin_app = {
+        PluginURLs.CONFIG: {
+            ProjectType.LMS: {
+                PluginURLs.NAMESPACE: "",
+                PluginURLs.REGEX: "^course-translations/",
+                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_course_translations-0.2.0/ol_openedx_course_translations/management/commands/translate_course.py

@@ -0,0 +1,687 @@
+"""
+Management command to translate course content to a specified language.
+"""
+
+import json
+import logging
+import re
+import shutil
+import tarfile
+from pathlib import Path
+from typing import Any
+from xml.etree.ElementTree import Element
+
+import deepl
+from defusedxml import ElementTree
+from django.conf import settings
+from django.core.management.base import BaseCommand, CommandError
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    """Translate given course content to the specified language."""
+
+    help = "Translate course content to the specified language."
+
+    def add_arguments(self, parser) -> None:
+        """Entry point for subclassed commands to add custom arguments."""
+        parser.add_argument(
+            "--source-language",
+            dest="source_language",
+            default="EN",
+            help=(
+                "Specify the source language of the course content "
+                "in ISO format, e.g. `EN` for English."
+            ),
+        )
+        parser.add_argument(
+            "--translation-language",
+            dest="translation_language",
+            required=True,
+            help=(
+                "Specify the language code in ISO format "
+                "to translate the course content into. e.g `AR` for Arabic"
+            ),
+        )
+        parser.add_argument(
+            "--course-dir",
+            dest="course_directory",
+            required=True,
+            help="Specify the course directory (tar archive).",
+        )
+
+    def handle(self, **options) -> None:
+        """Handle the translate_course command."""
+        try:
+            self._validate_inputs(options)
+
+            course_dir = Path(options["course_directory"])
+            source_language = options["source_language"]
+            translation_language = options["translation_language"]
+
+            # Extract course archive
+            extracted_dir = self._extract_course_archive(course_dir)
+
+            # Create translated copy
+            translated_dir = self._create_translated_copy(
+                extracted_dir, translation_language
+            )
+
+            # Delete extracted directory after copying
+            if extracted_dir.exists():
+                shutil.rmtree(extracted_dir)
+
+            # Translate content
+            billed_chars = self._translate_course_content(
+                translated_dir, source_language, translation_language
+            )
+
+            # Create final archive
+            archive_path = self._create_translated_archive(
+                translated_dir, translation_language, course_dir.stem
+            )
+
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"Translation completed. Archive created: {archive_path}"
+                )
+            )
+            logger.info("Total billed characters: %s", billed_chars)
+
+        except Exception as e:
+            logger.exception("Translation failed")
+            error_msg = f"Translation failed: {e}"
+            raise CommandError(error_msg) from e
+
+    def get_supported_archive_extension(self, filename: str) -> str | None:
+        """
+        Return the supported archive extension if filename ends with one, else None.
+        """
+        for ext in settings.COURSE_TRANSLATIONS_SUPPORTED_ARCHIVE_EXTENSIONS:
+            if filename.endswith(ext):
+                return ext
+        return None
+
+    def _validate_inputs(self, options: dict[str, Any]) -> None:
+        """Validate command inputs."""
+        course_dir = Path(options["course_directory"])
+
+        if not course_dir.exists():
+            error_msg = f"Course directory not found: {course_dir}"
+            raise CommandError(error_msg)
+
+        if self.get_supported_archive_extension(course_dir.name) is None:
+            supported_exts = ", ".join(
+                settings.COURSE_TRANSLATIONS_SUPPORTED_ARCHIVE_EXTENSIONS
+            )
+            error_msg = f"Course directory must be a tar file: {supported_exts}"
+            raise CommandError(error_msg)
+
+        if not hasattr(settings, "DEEPL_API_KEY") or not settings.DEEPL_API_KEY:
+            error_msg = "DEEPL_API_KEY setting is required"
+            raise CommandError(error_msg)
+
+    def _extract_course_archive(self, course_dir: Path) -> Path:
+        """Extract course archive to working directory."""
+        # Use the parent directory of the source file as the base extraction directory
+        extract_base_dir = course_dir.parent
+
+        # Get base name without extension
+        ext = self.get_supported_archive_extension(course_dir.name)
+        tarball_base = course_dir.name[: -len(ext)] if ext else course_dir.name
+
+        extracted_dir = extract_base_dir / tarball_base
+
+        if not extracted_dir.exists():
+            try:
+                with tarfile.open(course_dir, "r:*") as tar:
+                    # Validate tar file before extraction
+                    self._validate_tar_file(tar)
+                    tar.extractall(path=extracted_dir, filter="data")
+            except (tarfile.TarError, OSError) as e:
+                error_msg = f"Failed to extract archive: {e}"
+                raise CommandError(error_msg) from e
+
+        logger.info("Extracted course to: %s", extracted_dir)
+        return extracted_dir
+
+    def _validate_tar_file(self, tar: tarfile.TarFile) -> None:
+        """Validate tar file contents for security."""
+        for member in tar.getmembers():
+            # Check for directory traversal attacks
+            if member.name.startswith("/") or ".." in member.name:
+                error_msg = f"Unsafe tar member: {member.name}"
+                raise CommandError(error_msg)
+            # Check for excessively large files
+            if (
+                member.size > 512 * 1024 * 1024
+            ):  # 0.5GB limit because courses on Production are big
+                error_msg = f"File too large: {member.name}"
+                raise CommandError(error_msg)
+
+    def _create_translated_copy(
+        self, source_dir: Path, translation_language: str
+    ) -> Path:
+        """Create a copy of the course for translation."""
+        base_name = source_dir.name
+        new_dir_name = f"{translation_language}_{base_name}"
+        new_dir_path = source_dir.parent / new_dir_name
+
+        if new_dir_path.exists():
+            error_msg = f"Translation directory already exists: {new_dir_path}"
+            raise CommandError(error_msg)
+
+        shutil.copytree(source_dir, new_dir_path)
+        logger.info("Created translation copy: %s", new_dir_path)
+        return new_dir_path
+
+    def _translate_course_content(
+        self, course_dir: Path, source_language: str, translation_language: str
+    ) -> int:
+        """Translate all course content and return total billed characters."""
+        total_billed_chars = 0
+
+        # Translate files in main directories
+        for search_dir in [course_dir, course_dir.parent]:
+            total_billed_chars += self._translate_files_in_directory(
+                search_dir, source_language, translation_language, recursive=False
+            )
+
+            # Translate files in target subdirectories
+            for dir_name in settings.COURSE_TRANSLATIONS_TARGET_DIRECTORIES:
+                target_dir = search_dir / dir_name
+                if target_dir.exists() and target_dir.is_dir():
+                    total_billed_chars += self._translate_files_in_directory(
+                        target_dir,
+                        source_language,
+                        translation_language,
+                        recursive=True,
+                    )
+
+        # Translate special JSON files
+        total_billed_chars += self._translate_grading_policy(
+            course_dir, source_language, translation_language
+        )
+        total_billed_chars += self._translate_policy_json(
+            course_dir, source_language, translation_language
+        )
+
+        return total_billed_chars
+
+    def _translate_files_in_directory(
+        self,
+        directory: Path,
+        source_language: str,
+        translation_language: str,
+        *,
+        recursive: bool = False,
+    ) -> int:
+        """Translate files in a directory."""
+        total_billed_chars = 0
+
+        if recursive:
+            file_paths: list[Path] = []
+            for ext in settings.COURSE_TRANSLATIONS_TRANSLATABLE_EXTENSIONS:
+                file_paths.extend(directory.rglob(f"*{ext}"))
+        else:
+            file_paths = [
+                f
+                for f in directory.iterdir()
+                if f.is_file()
+                and any(
+                    f.name.endswith(ext)
+                    for ext in settings.COURSE_TRANSLATIONS_TRANSLATABLE_EXTENSIONS
+                )
+            ]
+
+        for file_path in file_paths:
+            try:
+                total_billed_chars += self._translate_file(
+                    file_path, source_language, translation_language
+                )
+            except (OSError, UnicodeDecodeError) as e:
+                logger.warning("Failed to translate %s: %s", file_path, e)
+
+        return total_billed_chars
+
+    def _update_video_xml(self, xml_content: str, translation_language: str) -> str:  # noqa: C901
+        """Update video XML transcripts and transcript tags for the target language."""
+        try:
+            root = ElementTree.fromstring(xml_content)
+            lang_code = translation_language.lower()
+
+            # Update transcripts attribute in <video>
+            if root.tag == "video" and "transcripts" in root.attrib:
+                transcripts_json = root.attrib["transcripts"].replace("&quot;", '"')
+                transcripts_dict = json.loads(transcripts_json)
+                for k in list(transcripts_dict.keys()):
+                    value = transcripts_dict[k]
+                    new_key = lang_code
+                    new_value = re.sub(r"-[a-zA-Z]{2}\.srt$", f"-{new_key}.srt", value)
+                    transcripts_dict[new_key] = new_value
+                new_transcripts = json.dumps(transcripts_dict, ensure_ascii=False)
+                root.set("transcripts", new_transcripts)
+
+            # Add a new <transcript> tag inside <transcripts> for the
+            # target language, inheriting attributes
+            for video_asset in root.findall("video_asset"):
+                for transcripts in video_asset.findall("transcripts"):
+                    existing_transcript = transcripts.find("transcript")
+                    new_transcript = Element("transcript")
+                    if existing_transcript is not None:
+                        new_transcript.attrib = existing_transcript.attrib.copy()
+                    new_transcript.set("language_code", lang_code)
+                    # Avoid duplicates
+                    if not any(
+                        t.attrib == new_transcript.attrib
+                        for t in transcripts.findall("transcript")
+                    ):
+                        transcripts.append(new_transcript)
+
+            # Add a new <transcript> tag for the target language
+            for transcript in root.findall("transcript"):
+                src = transcript.get("src")
+                if src:
+                    new_src = re.sub(r"-[a-zA-Z]{2}\.srt$", f"-{lang_code}.srt", src)
+                    new_transcript = Element("transcript")
+                    new_transcript.set("language", lang_code)
+                    new_transcript.set("src", new_src)
+                    # Avoid duplicates
+                    if not any(
+                        t.get("language") == lang_code and t.get("src") == new_src
+                        for t in root.findall("transcript")
+                    ):
+                        root.append(new_transcript)
+
+            xml_content = ElementTree.tostring(root, encoding="unicode")
+        except Exception as e:  # noqa: BLE001
+            logger.warning("Failed to update transcripts in video XML: %s", e)
+
+        return xml_content
+
+    def _translate_file(
+        self, file_path: Path, source_language: str, translation_language: str
+    ) -> int:
+        """Translate a single file and return billed characters."""
+        # Handle SRT files with DeepL document translation
+        if file_path.suffix == ".srt":
+            try:
+                billed_chars = self.translate_srt_file(
+                    file_path, source_language, translation_language
+                )
+            except Exception as e:  # noqa: BLE001
+                logger.warning("Failed to translate SRT %s: %s", file_path, e)
+                return 0
+            else:
+                return billed_chars
+
+        try:
+            content = file_path.read_text(encoding="utf-8")
+            logger.debug("Translating: %s", file_path)
+
+            translated_content, billed_chars = self._translate_text(
+                content, source_language, translation_language, file_path.name
+            )
+
+            # Handle XML display_name translation
+            if file_path.suffix == ".xml":
+                translated_content = self._translate_display_name(
+                    translated_content, source_language, translation_language
+                )
+
+                # If parent directory is 'video', update transcripts attribute
+                if file_path.parent.name == "video":
+                    translated_content = self._update_video_xml(
+                        translated_content, translation_language
+                    )
+
+            file_path.write_text(translated_content, encoding="utf-8")
+        except (OSError, UnicodeDecodeError) as e:
+            logger.warning("Failed to translate %s: %s", file_path, e)
+            return 0
+        else:
+            return billed_chars
+
+    def _translate_grading_policy(
+        self, course_dir: Path, source_language: str, translation_language: str
+    ) -> int:
+        """Translate grading_policy.json files."""
+        total_billed_chars = 0
+        policies_dir = course_dir / "course" / "policies"
+
+        if not policies_dir.exists():
+            return 0
+
+        for child_dir in policies_dir.iterdir():
+            if not child_dir.is_dir():
+                continue
+
+            grading_policy_path = child_dir / "grading_policy.json"
+            if not grading_policy_path.exists():
+                continue
+
+            try:
+                grading_policy = json.loads(
+                    grading_policy_path.read_text(encoding="utf-8")
+                )
+                updated = False
+
+                for item in grading_policy.get("GRADER", []):
+                    if "short_label" in item:
+                        translated_label, billed_chars = self._translate_text(
+                            item["short_label"], source_language, translation_language
+                        )
+                        item["short_label"] = translated_label
+                        total_billed_chars += billed_chars
+                        updated = True
+
+                if updated:
+                    grading_policy_path.write_text(
+                        json.dumps(grading_policy, ensure_ascii=False, indent=4),
+                        encoding="utf-8",
+                    )
+            except (OSError, json.JSONDecodeError) as e:
+                logger.warning(
+                    "Failed to translate grading policy in %s: %s", child_dir, e
+                )
+
+        return total_billed_chars
+
+    def _translate_policy_json(
+        self, course_dir: Path, source_language: str, translation_language: str
+    ) -> int:
+        """Translate policy.json files."""
+        total_billed_chars = 0
+        policies_dir = course_dir / "course" / "policies"
+
+        if not policies_dir.exists():
+            return 0
+
+        for child_dir in policies_dir.iterdir():
+            if not child_dir.is_dir():
+                continue
+
+            policy_path = child_dir / "policy.json"
+            if not policy_path.exists():
+                continue
+
+            try:
+                policy_data = json.loads(policy_path.read_text(encoding="utf-8"))
+                updated = False
+
+                for course_obj in policy_data.values():
+                    if not isinstance(course_obj, dict):
+                        continue
+
+                    # Translate various fields
+                    billed_chars, field_updated = self._translate_policy_fields(
+                        course_obj, source_language, translation_language
+                    )
+                    total_billed_chars += billed_chars
+                    updated = updated or field_updated
+
+                if updated:
+                    policy_path.write_text(
+                        json.dumps(policy_data, ensure_ascii=False, indent=4),
+                        encoding="utf-8",
+                    )
+            except (OSError, json.JSONDecodeError) as e:
+                logger.warning("Failed to translate policy in %s: %s", child_dir, e)
+
+        return total_billed_chars
+
+    def _translate_policy_fields(
+        self,
+        course_obj: dict[str, Any],
+        source_language: str,
+        translation_language: str,
+    ) -> tuple[int, bool]:
+        """Translate specific fields in policy object."""
+        total_billed_chars = 0
+        updated = False
+
+        # Translate simple string fields
+        billed_chars, field_updated = self._translate_string_fields(
+            course_obj, source_language, translation_language
+        )
+        total_billed_chars += billed_chars
+        updated = updated or field_updated
+
+        # Translate discussion topics
+        billed_chars, field_updated = self._translate_discussion_topics(
+            course_obj, source_language, translation_language
+        )
+        total_billed_chars += billed_chars
+        updated = updated or field_updated
+
+        # Translate learning info and tabs
+        billed_chars, field_updated = self._translate_learning_info_and_tabs(
+            course_obj, source_language, translation_language
+        )
+        total_billed_chars += billed_chars
+        updated = updated or field_updated
+
+        # Translate XML attributes
+        billed_chars, field_updated = self._translate_xml_attributes(
+            course_obj, source_language, translation_language
+        )
+        total_billed_chars += billed_chars
+        updated = updated or field_updated
+
+        return total_billed_chars, updated
+
+    def _translate_string_fields(
+        self,
+        course_obj: dict[str, Any],
+        source_language: str,
+        translation_language: str,
+    ) -> tuple[int, bool]:
+        """Translate simple string fields."""
+        total_billed_chars = 0
+        updated = False
+
+        string_fields = ["advertised_start", "display_name", "display_organization"]
+        for field in string_fields:
+            if field in course_obj:
+                translated, billed_chars = self._translate_text(
+                    course_obj[field], source_language, translation_language
+                )
+                course_obj[field] = translated
+                total_billed_chars += billed_chars
+                updated = True
+
+        return total_billed_chars, updated
+
+    def _translate_discussion_topics(
+        self,
+        course_obj: dict[str, Any],
+        source_language: str,
+        translation_language: str,
+    ) -> tuple[int, bool]:
+        """Translate discussion topics."""
+        total_billed_chars = 0
+        updated = False
+
+        if "discussion_topics" in course_obj:
+            topics = course_obj["discussion_topics"]
+            if isinstance(topics, dict):
+                new_topics = {}
+                for topic_key, value in topics.items():
+                    translated_key, billed_chars = self._translate_text(
+                        topic_key, source_language, translation_language
+                    )
+                    new_topics[translated_key] = value
+                    total_billed_chars += billed_chars
+                course_obj["discussion_topics"] = new_topics
+                updated = True
+
+        return total_billed_chars, updated
+
+    def _translate_learning_info_and_tabs(
+        self,
+        course_obj: dict[str, Any],
+        source_language: str,
+        translation_language: str,
+    ) -> tuple[int, bool]:
+        """Translate learning info and tabs."""
+        total_billed_chars = 0
+        updated = False
+
+        # Learning info
+        if "learning_info" in course_obj and isinstance(
+            course_obj["learning_info"], list
+        ):
+            translated_info = []
+            for item in course_obj["learning_info"]:
+                translated, billed_chars = self._translate_text(
+                    item, source_language, translation_language
+                )
+                translated_info.append(translated)
+                total_billed_chars += billed_chars
+            course_obj["learning_info"] = translated_info
+            updated = True
+
+        # Tabs
+        if "tabs" in course_obj and isinstance(course_obj["tabs"], list):
+            for tab in course_obj["tabs"]:
+                if isinstance(tab, dict) and "name" in tab:
+                    translated, billed_chars = self._translate_text(
+                        tab["name"], source_language, translation_language
+                    )
+                    tab["name"] = translated
+                    total_billed_chars += billed_chars
+                    updated = True
+
+        return total_billed_chars, updated
+
+    def _translate_xml_attributes(
+        self,
+        course_obj: dict[str, Any],
+        source_language: str,
+        translation_language: str,
+    ) -> tuple[int, bool]:
+        """Translate XML attributes."""
+        total_billed_chars = 0
+        updated = False
+
+        if "xml_attributes" in course_obj and isinstance(
+            course_obj["xml_attributes"], dict
+        ):
+            xml_attrs = course_obj["xml_attributes"]
+            xml_fields = [
+                "diplay_name",
+                "info_sidebar_name",
+            ]  # Note: keeping typo as in original
+            for field in xml_fields:
+                if field in xml_attrs:
+                    translated, billed_chars = self._translate_text(
+                        xml_attrs[field], source_language, translation_language
+                    )
+                    xml_attrs[field] = translated
+                    total_billed_chars += billed_chars
+                    updated = True
+
+        return total_billed_chars, updated
+
+    def _create_translated_archive(
+        self, translated_dir: Path, translation_language: str, original_name: str
+    ) -> Path:
+        """Create tar.gz archive of translated course."""
+        # Remove all archive extensions from the original name
+        ext = self.get_supported_archive_extension(original_name)
+        clean_name = original_name[: -len(ext)] if ext else original_name
+
+        tar_gz_name = f"{translation_language}_{clean_name}.tar.gz"
+        tar_gz_path = translated_dir.parent / tar_gz_name
+
+        # Remove existing archive
+        if tar_gz_path.exists():
+            tar_gz_path.unlink()
+
+        # Create tar.gz archive containing only the 'course' directory
+        course_dir_path = translated_dir / "course"
+        with tarfile.open(tar_gz_path, "w:gz") as tar:
+            tar.add(course_dir_path, arcname="course")
+
+        # Delete extracted directory after copying
+        if translated_dir.exists():
+            shutil.rmtree(translated_dir)
+
+        logger.info("Created tar.gz archive: %s", tar_gz_path)
+        return tar_gz_path
+
+    def translate_srt_file(
+        self, input_file_path: Path, source_language: str, target_language: str
+    ) -> int:
+        """
+        Translate an SRT file using DeepL document translation.
+        Creates a new output file with the target language prefix, then renames
+        it to the original file. Returns the number of billed characters.
+        """
+        input_name = input_file_path.name
+        output_name = input_name
+        if "-" in input_name and input_name.endswith(".srt"):
+            parts = input_name.rsplit("-", 1)
+            output_name = f"{parts[0]}-{target_language.lower()}.srt"
+        output_file_path = input_file_path.parent / output_name
+
+        deepl_client = deepl.Translator(settings.DEEPL_API_KEY)
+        result = deepl_client.translate_document_from_filepath(
+            input_file_path,
+            output_file_path,
+            source_lang=source_language,
+            target_lang=target_language,
+        )
+        return result.billed_characters
+
+    def _translate_text(
+        self,
+        text: str,
+        source_language: str,
+        target_language: str,
+        filename: str | None = None,
+    ) -> tuple[str, int]:
+        """Translate text using DeepL API."""
+        if not text or not text.strip():
+            return text, 0
+
+        try:
+            deepl_client = deepl.Translator(settings.DEEPL_API_KEY)
+
+            tag_handling = None
+            if filename:
+                extension = Path(filename).suffix.lstrip(".")
+                if extension in ["html", "xml"]:
+                    tag_handling = extension
+
+            result = deepl_client.translate_text(
+                text,
+                source_lang=source_language,
+                target_lang=target_language,
+                tag_handling=tag_handling,
+            )
+
+            return result.text, result.billed_characters  # noqa: TRY300
+        except (deepl.exceptions.DeepLException, OSError) as e:
+            logger.warning("Translation failed for text: %s... Error: %s", text[:50], e)
+            return text, 0
+
+    def _translate_display_name(
+        self, xml_content: str, source_language: str, target_language: str
+    ) -> str:
+        """Extract and translate the display_name attribute of the root element."""
+        try:
+            root = ElementTree.fromstring(xml_content)
+            display_name = root.attrib.get("display_name")
+
+            if display_name:
+                translated_name, _ = self._translate_text(
+                    display_name, source_language, target_language
+                )
+                root.set("display_name", translated_name)
+                return ElementTree.tostring(root, encoding="unicode")
+        except ElementTree.ParseError as e:
+            logger.warning("Could not translate display_name: %s", e)
+
+        return xml_content

ol_openedx_course_translations-0.2.0/ol_openedx_course_translations/middleware.py

@@ -0,0 +1,143 @@
+"""
+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
+
+ENGLISH_LANGUAGE_CODE = "en"
+
+
+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.
+        """
+        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_course_translations-0.2.0/ol_openedx_course_translations/settings/cms.py

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

ol_openedx_course_translations-0.2.0/ol_openedx_course_translations/settings/common.py

@@ -0,0 +1,35 @@
+# 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.
+    """
+    settings.ENABLE_AUTO_LANGUAGE_SELECTION = False
+    settings.AUTO_LANGUAGE_SELECTION_EXEMPT_PATHS = ["admin", "sysadmin", "instructor"]
+    settings.DEEPL_API_KEY = ""
+    settings.COURSE_TRANSLATIONS_TARGET_DIRECTORIES = [
+        "about",
+        "course",
+        "chapter",
+        "html",
+        "info",
+        "problem",
+        "sequential",
+        "vertical",
+        "video",
+        "static",
+        "tabs",
+    ]
+    settings.COURSE_TRANSLATIONS_SUPPORTED_ARCHIVE_EXTENSIONS = [
+        ".tar.gz",
+        ".tgz",
+        ".tar",
+    ]
+    settings.COURSE_TRANSLATIONS_TRANSLATABLE_EXTENSIONS = [
+        ".html",
+        ".xml",
+        ".srt",
+    ]

ol_openedx_course_translations-0.2.0/ol_openedx_course_translations/settings/lms.py

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

ol_openedx_course_translations-0.2.0/ol_openedx_course_translations/urls.py

@@ -0,0 +1,16 @@
+"""
+URL configuration for ol_openedx_course_translations app.
+"""
+
+from django.conf import settings
+from django.urls import re_path
+
+from ol_openedx_course_translations.views import CourseLanguageView
+
+urlpatterns = [
+    re_path(
+        rf"api/course-language/{settings.COURSE_KEY_PATTERN}$",
+        CourseLanguageView.as_view(),
+        name="ol_openedx_course_language",
+    ),
+]

ol_openedx_course_translations-0.2.0/ol_openedx_course_translations/views.py

@@ -0,0 +1,73 @@
+"""
+API Views for ol_openedx_course_translations 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
+
+log = logging.getLogger(__name__)
+
+
+class CourseLanguageView(APIView):
+    """
+    API View to retrieve the language of a specified course.
+
+    Sample Request:
+        GET /course-translations/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,
+            )
+        return Response({"language": course.language})

ol_openedx_course_translations-0.2.0/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "ol-openedx-course-translations"
+version = "0.2.0"
+description = "An Open edX plugin to translate courses"
+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",
+  "deepl>=1.25.0",
+]
+
+[project.entry-points."cms.djangoapp"]
+ol_openedx_course_translations = "ol_openedx_course_translations.apps:OLOpenedXCourseTranslationsConfig"
+
+[project.entry-points."lms.djangoapp"]
+ol_openedx_course_translations = "ol_openedx_course_translations.apps:OLOpenedXCourseTranslationsConfig"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["ol_openedx_course_translations"]
+include = [
+  "ol_openedx_course_translations/**/*.py",
+]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "ol_openedx_course_translations/**/*",
+  "README.rst",
+  "pyproject.toml",
+]