ol-openedx-course-translations 0.3.0__py3-none-any.whl → 0.3.5__py3-none-any.whl

ol_openedx_course_translations/admin.py

@@ -0,0 +1,29 @@
+"""Django admin configuration for course translations plugin."""
+
+from django.contrib import admin
+
+from ol_openedx_course_translations.models import CourseTranslationLog
+
+
+@admin.register(CourseTranslationLog)
+class CourseTranslationLogAdmin(admin.ModelAdmin):
+    """Admin interface for CourseTranslationLog model."""
+
+    _common_fields = (
+        "source_course_language",
+        "target_course_language",
+        "srt_provider_name",
+        "srt_provider_model",
+        "content_provider_name",
+        "content_provider_model",
+    )
+
+    list_display = ("id", "source_course_id", *_common_fields, "created_at")
+    list_filter = _common_fields
+    readonly_fields = (
+        "source_course_id",
+        *_common_fields,
+        "created_at",
+        "command_stats",
+    )
+    search_fields = ("source_course_id",)

ol_openedx_course_translations/apps.py

@@ -13,6 +13,7 @@ class OLOpenedXCourseTranslationsConfig(AppConfig):
     """
 
     name = "ol_openedx_course_translations"
+    verbose_name = "OL Course Translations"
 
     plugin_app = {
         PluginURLs.CONFIG: {

ol_openedx_course_translations/filters.py

@@ -0,0 +1,39 @@
+"""
+Filters for Open edX course translations.
+"""
+
+from openedx_filters import PipelineStep
+from xmodule.modulestore.django import modulestore
+
+from ol_openedx_course_translations.utils.constants import ENGLISH_LANGUAGE_CODE
+
+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.
+        """
+        for child in dict(context)["block"].children:
+            if child.block_type == VIDEO_BLOCK_TYPE:
+                student_view_context["dest_lang"] = (
+                    ENGLISH_LANGUAGE_CODE  # default to English
+                )
+                video_block = modulestore().get_item(child)
+                transcripts_info = video_block.get_transcripts_info()
+                course_lang = getattr(
+                    context.get("course", None), "language", ENGLISH_LANGUAGE_CODE
+                )
+                if (
+                    transcripts_info
+                    and transcripts_info.get("transcripts", {})
+                    and course_lang in transcripts_info["transcripts"]
+                ):
+                    student_view_context["dest_lang"] = course_lang
+        return {"context": context, "student_view_context": student_view_context}

ol_openedx_course_translations/management/commands/translate_course.py

@@ -11,6 +11,7 @@ from celery import group
 from django.conf import settings
 from django.core.management.base import BaseCommand, CommandError
 
+from ol_openedx_course_translations.models import CourseTranslationLog
 from ol_openedx_course_translations.tasks import (
     translate_file_task,
     translate_grading_policy_task,
@@ -21,6 +22,7 @@ from ol_openedx_course_translations.utils.course_translations import (
     create_translated_archive,
     create_translated_copy,
     extract_course_archive,
+    generate_course_key_from_xml,
     get_translatable_file_paths,
     update_course_language_attribute,
     validate_course_inputs,
@@ -193,9 +195,10 @@ class Command(BaseCommand):
     def handle(self, **options) -> None:
         """Handle the translate_course command."""
         try:
+            start_time = time.perf_counter()
             course_archive_path = Path(options["course_archive_path"])
-            source_language = options["source_language"]
-            target_language = options["target_language"]
+            source_language = options["source_language"].upper()
+            target_language = options["target_language"].upper()
             content_provider_spec = options["content_translation_provider"]
             srt_provider_spec = options["srt_translation_provider"]
             glossary_directory = options.get("glossary_directory")
@@ -252,18 +255,28 @@ class Command(BaseCommand):
             )
 
             # Wait for all tasks and report status
-            self._wait_and_report_tasks()
-
+            command_stats = self._wait_and_report_tasks()
+            total_time_taken_msg = (
+                f"Command finished in: {time.perf_counter() - start_time:.2f} seconds."
+            )
+            self.stdout.write(self.style.SUCCESS(total_time_taken_msg))
+            command_stats.append(total_time_taken_msg)
+
+            # Add translation log entry
+            self._add_translation_log_entry(
+                source_language=source_language,
+                target_language=target_language,
+                command_stats=command_stats,
+            )
             # Create final archive
             translated_archive_path = create_translated_archive(
                 translated_course_dir, target_language, course_archive_path.stem
             )
-
-            self.stdout.write(
-                self.style.SUCCESS(
-                    f"Translation completed. Archive created: {translated_archive_path}"
-                )
+            success_msg = (
+                f"Translation completed successfully. Translated archive created: "
+                f"{translated_archive_path}"
             )
+            self.stdout.write(self.style.SUCCESS(success_msg))
 
         except Exception as e:
             logger.exception("Translation failed")
@@ -417,7 +430,7 @@ class Command(BaseCommand):
                 self.tasks.append(("policy", str(policy_file), task))
                 logger.info("Added policy.json task for: %s", policy_file)
 
-    def _wait_and_report_tasks(self) -> None:  # noqa: C901, PLR0915, PLR0912
+    def _wait_and_report_tasks(self) -> list[str]:  # noqa: C901, PLR0915, PLR0912
         """
         Execute all tasks as a Celery group and wait for completion.
 
@@ -427,9 +440,10 @@ class Command(BaseCommand):
         Raises:
             CommandError: If any tasks fail
         """
+        stats = []
         if not self.tasks:
             self.stdout.write("No tasks to execute.")
-            return
+            return []
 
         total_tasks = len(self.tasks)
         self.stdout.write(
@@ -449,7 +463,6 @@ class Command(BaseCommand):
 
         # Wait for all tasks to complete with progress reporting
         completed_count = 0
-        self.stdout.write(f"Progress: 0/{total_tasks} tasks completed")
         self.stdout.flush()
 
         try:
@@ -491,47 +504,82 @@ class Command(BaseCommand):
 
             if isinstance(task_result, dict):
                 status = task_result.get("status", "unknown")
-
                 if status == "success":
                     completed_tasks += 1
-                    self.stdout.write(self.style.SUCCESS(f"✓ {task_type}: {file_path}"))
+                    msg = f"✓ {task_type}: {file_path}"
+                    stats.append(msg)
+                    self.stdout.write(self.style.SUCCESS(msg))
                 elif status == "skipped":
                     skipped_tasks += 1
                     reason = task_result.get("reason", "Skipped")
-                    self.stdout.write(
-                        self.style.WARNING(f"⊘ {task_type}: {file_path} - {reason}")
-                    )
+                    msg = f"⊘ {task_type}: {file_path} - {reason}"
+                    stats.append(msg)
+                    self.stdout.write(self.style.WARNING(msg))
                 elif status == "error":
                     failed_tasks += 1
                     error = task_result.get("error", "Unknown error")
-                    self.stdout.write(
-                        self.style.ERROR(f"✗ {task_type}: {file_path} - {error}")
-                    )
+                    msg = f"✗ {task_type}: {file_path} - {error}"
+                    stats.append(msg)
+                    self.stdout.write(self.style.ERROR(msg))
                 else:
                     failed_tasks += 1
-                    self.stdout.write(
-                        self.style.ERROR(
-                            f"✗ {task_type}: {file_path} - Unknown status: {status}"
-                        )
-                    )
+                    msg = f"✗ {task_type}: {file_path} - Unknown status: {status}"
+                    stats.append(msg)
+                    self.stdout.write(self.style.ERROR(msg))
             else:
                 # Task raised an exception
                 failed_tasks += 1
                 error_msg = str(task_result) if task_result else "Task failed"
-                self.stdout.write(
-                    self.style.ERROR(f"✗ {task_type}: {file_path} - {error_msg}")
-                )
+                msg = f"✗ {task_type}: {file_path} - {error_msg}"
+                stats.append(msg)
+                self.stdout.write(self.style.ERROR(msg))
 
         # Print summary
         self.stdout.write("\n" + "=" * 60)
-        self.stdout.write(self.style.SUCCESS(f"Total tasks: {total_tasks}"))
-        self.stdout.write(self.style.SUCCESS(f"Completed: {completed_tasks}"))
+        successful_tasks_stats = (
+            f"Total tasks: {total_tasks}\nCompleted: {completed_tasks}"
+        )
+        stats.append(successful_tasks_stats)
+        self.stdout.write(self.style.SUCCESS(successful_tasks_stats))
         if skipped_tasks > 0:
-            self.stdout.write(self.style.WARNING(f"Skipped: {skipped_tasks}"))
+            skipped_tasks_stats = f"Skipped: {skipped_tasks}"
+            stats.append(skipped_tasks_stats)
+            self.stdout.write(self.style.WARNING(skipped_tasks_stats))
         if failed_tasks > 0:
-            self.stdout.write(self.style.ERROR(f"Failed: {failed_tasks}"))
+            failed_tasks_stats = f"Failed: {failed_tasks}"
+            stats.append(failed_tasks_stats)
+            self.stdout.write(self.style.ERROR(failed_tasks_stats))
         self.stdout.write("=" * 60 + "\n")
 
         if failed_tasks > 0:
             error_msg = f"{failed_tasks} translation tasks failed"
             raise CommandError(error_msg)
+
+        return stats
+
+    def _add_translation_log_entry(
+        self, source_language, target_language, command_stats=None
+    ) -> None:
+        """
+        Add a log entry for the course translation operation.
+
+        Args:
+            source_language: Source language code
+            target_language: Target language code
+            command_stats: List of command statistics/logs
+        """
+        source_course_id = generate_course_key_from_xml(
+            course_dir_path=self.translated_course_dir
+        )
+        command_stats_str = "\n".join(command_stats) if command_stats else ""
+
+        CourseTranslationLog.objects.create(
+            source_course_id=source_course_id,
+            source_course_language=source_language,
+            target_course_language=target_language,
+            srt_provider_name=self.srt_provider_name,
+            srt_provider_model=self.srt_model or "",
+            content_provider_name=self.content_provider_name,
+            content_provider_model=self.content_model or "",
+            command_stats=command_stats_str,
+        )

ol_openedx_course_translations/middleware.py

@@ -14,7 +14,7 @@ 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"
+from ol_openedx_course_translations.utils.constants import ENGLISH_LANGUAGE_CODE
 
 
 def should_process_request(request):

ol_openedx_course_translations/migrations/0001_add_translation_logs.py

@@ -0,0 +1,84 @@
+# Generated by Django 5.2.9 on 2026-01-15 11:04
+
+import opaque_keys.edx.django.models
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = []  # type: ignore[var-annotated]
+
+    operations = [
+        migrations.CreateModel(
+            name="CourseTranslationLog",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "source_course_id",
+                    opaque_keys.edx.django.models.CourseKeyField(
+                        db_index=True, max_length=255
+                    ),
+                ),
+                (
+                    "source_course_language",
+                    models.CharField(
+                        help_text="Source language code (e.g., 'EN')", max_length=10
+                    ),
+                ),
+                (
+                    "target_course_language",
+                    models.CharField(
+                        help_text="Target language code for translation (e.g., 'FR')",
+                        max_length=10,
+                    ),
+                ),
+                (
+                    "srt_provider_name",
+                    models.CharField(
+                        help_text="LLM Provider used for SRT translation",
+                        max_length=100,
+                    ),
+                ),
+                (
+                    "srt_provider_model",
+                    models.CharField(
+                        blank=True,
+                        help_text="LLM provider model used for SRT translation",
+                        max_length=100,
+                    ),
+                ),
+                (
+                    "content_provider_name",
+                    models.CharField(
+                        help_text="LLM Provider used for content translation",
+                        max_length=100,
+                    ),
+                ),
+                (
+                    "content_provider_model",
+                    models.CharField(
+                        blank=True,
+                        help_text="LLM provider model used for content translation",
+                        max_length=100,
+                    ),
+                ),
+                (
+                    "command_stats",
+                    models.TextField(
+                        blank=True, help_text="Logs from the translation command"
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+            ],
+        ),
+    ]

ol_openedx_course_translations/models.py

@@ -0,0 +1,57 @@
+"""Models for course translations plugin"""
+
+from django.db import models
+from opaque_keys.edx.django.models import CourseKeyField
+
+
+class CourseTranslationLog(models.Model):
+    """Log entry for course translation operations."""
+
+    source_course_id = CourseKeyField(max_length=255, db_index=True)
+    source_course_language = models.CharField(
+        max_length=10,
+        help_text="Source language code (e.g., 'EN')",
+    )
+    target_course_language = models.CharField(
+        max_length=10,
+        help_text="Target language code for translation (e.g., 'FR')",
+    )
+    srt_provider_name = models.CharField(
+        max_length=100,
+        help_text="LLM Provider used for SRT translation",
+    )
+    srt_provider_model = models.CharField(
+        max_length=100,
+        blank=True,
+        help_text="LLM provider model used for SRT translation",
+    )
+    content_provider_name = models.CharField(
+        max_length=100,
+        help_text="LLM Provider used for content translation",
+    )
+    content_provider_model = models.CharField(
+        max_length=100,
+        blank=True,
+        help_text="LLM provider model used for content translation",
+    )
+    command_stats = models.TextField(
+        blank=True, help_text="Logs from the translation command"
+    )
+    created_at = models.DateTimeField(
+        auto_now_add=True,
+    )
+    updated_at = models.DateTimeField(
+        auto_now=True,
+    )
+
+    class Meta:
+        """Meta options for CourseTranslationLog."""
+
+        app_label = "ol_openedx_course_translations"
+
+    def __str__(self):
+        """Return a string representation of the translation log."""
+        return (
+            f"{self.source_course_id} "
+            f"({self.source_course_language} → {self.target_course_language})"
+        )

ol_openedx_course_translations/providers/llm_providers.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from typing import Any
 
 import srt
+from django.conf import settings
 from litellm import completion
 
 from .base import TranslationProvider, load_glossary
@@ -68,6 +69,7 @@ class LLMProvider(TranslationProvider):
         primary_api_key: str,
         repair_api_key: str | None = None,
         model_name: str | None = None,
+        timeout: int = settings.LITE_LLM_REQUEST_TIMEOUT,
     ):
         """
         Initialize LLM provider with API keys and model name.
@@ -79,6 +81,7 @@ class LLMProvider(TranslationProvider):
         """
         super().__init__(primary_api_key, repair_api_key)
         self.model_name = model_name
+        self.timeout = timeout
 
     def _get_subtitle_system_prompt(
         self,
@@ -317,6 +320,7 @@ class LLMProvider(TranslationProvider):
             model=self.model_name,
             messages=llm_messages,
             api_key=self.primary_api_key,
+            timeout=self.timeout,
             **additional_kwargs,
         )
         return llm_response.choices[0].message.content.strip()
@@ -348,6 +352,9 @@ class LLMProvider(TranslationProvider):
         current_batch_size = len(subtitle_list)
 
         current_index = 0
+        retry_count = 0
+        max_retries = 3
+
         while current_index < len(subtitle_list):
             subtitle_batch = subtitle_list[
                 current_index : current_index + current_batch_size
@@ -373,18 +380,27 @@ class LLMProvider(TranslationProvider):
                 )
                 translated_subtitle_list.extend(translated_batch)
                 current_index += current_batch_size
+                retry_count = 0  # Reset retry count on success
 
             except Exception as llm_error:
                 error_message = str(llm_error).lower()
                 if any(
                     error_term in error_message for error_term in LLM_ERROR_KEYWORDS
                 ):
-                    if current_batch_size <= 1:
-                        logger.exception("Failed even with batch size 1")
+                    if current_batch_size <= 1 or retry_count >= max_retries:
+                        logger.exception(
+                            "Failed after %s batch size reduction attempts", retry_count
+                        )
                         raise
 
-                    logger.warning("Error: %s. Reducing batch size...", llm_error)
+                    logger.warning(
+                        "Error: %s. Reducing batch size (attempt %s/%s)...",
+                        llm_error,
+                        retry_count + 1,
+                        max_retries,
+                    )
                     current_batch_size = max(1, current_batch_size // 2)
+                    retry_count += 1
                     continue
                 else:
                     raise

ol_openedx_course_translations/settings/common.py

@@ -62,3 +62,4 @@ def apply_common_settings(settings):
     settings.TRANSLATIONS_REPO_URL = (
         "https://github.com/mitodl/mitxonline-translations.git"
     )
+    settings.LITE_LLM_REQUEST_TIMEOUT = 120  # seconds

ol_openedx_course_translations/settings/lms.py

@@ -13,3 +13,26 @@ def plugin_settings(settings):
     settings.MIDDLEWARE.extend(
         ["ol_openedx_course_translations.middleware.CourseLanguageCookieMiddleware"]
     )
+    VIDEO_TRANSCRIPT_LANGUAGE_FILTERS = {
+        "org.openedx.learning.xblock.render.started.v1": {
+            "pipeline": [
+                "ol_openedx_course_translations.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_course_translations/utils/constants.py

@@ -214,3 +214,5 @@ HTTP_UNPROCESSABLE_ENTITY = 422
 
 # Error message length limit
 MAX_ERROR_MESSAGE_LENGTH = 200
+
+ENGLISH_LANGUAGE_CODE = "en"

ol_openedx_course_translations/utils/course_translations.py

@@ -11,6 +11,7 @@ from xml.etree.ElementTree import Element
 from defusedxml import ElementTree
 from django.conf import settings
 from django.core.management.base import CommandError
+from opaque_keys.edx.locator import CourseLocator
 
 from ol_openedx_course_translations.providers.deepl_provider import DeepLProvider
 from ol_openedx_course_translations.providers.llm_providers import (
@@ -126,7 +127,7 @@ def translate_xml_display_name(
         if display_name:
             translated_name = provider.translate_text(
                 display_name,
-                target_language.lower(),
+                target_language,
                 glossary_directory=glossary_directory,
             )
             xml_root.set("display_name", translated_name)
@@ -150,7 +151,7 @@ def update_video_xml_transcripts(xml_content: str, target_language: str) -> str:
     """
     try:
         xml_root = ElementTree.fromstring(xml_content)
-        target_lang_code = target_language.lower()
+        target_lang_code = target_language
 
         # Update transcripts attribute in <video> tag
         if xml_root.tag == "video" and "transcripts" in xml_root.attrib:
@@ -579,3 +580,29 @@ def get_translatable_file_paths(
         ]
 
     return translatable_file_paths
+
+
+def generate_course_key_from_xml(course_dir_path: Path) -> str:
+    """
+    Generate the course id of the source course
+    """
+    try:
+        about_file_path = course_dir_path / "course" / "course.xml"
+        xml_content = about_file_path.read_text(encoding="utf-8")
+        xml_root = ElementTree.fromstring(xml_content)
+
+        org = xml_root.get("org", "")
+        course = xml_root.get("course", "")
+        url_name = xml_root.get("url_name", "")
+
+        if not all([org, course, url_name]):
+            error_msg = (
+                "Missing required attributes in course.xml: org, course, url_name"
+            )
+            raise CommandError(error_msg)
+    except (OSError, ElementTree.ParseError) as e:
+        error_msg = f"Failed to read course id from about.xml: {e}"
+        raise CommandError(error_msg) from e
+    else:
+        # URL name is the run ID of the course
+        return CourseLocator(org=org, course=course, run=url_name)

{ol_openedx_course_translations-0.3.0.dist-info → ol_openedx_course_translations-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ol-openedx-course-translations
-Version: 0.3.0
+Version: 0.3.5
 Summary: An Open edX plugin to translate courses
 Author: MIT Office of Digital Learning
 License-Expression: BSD-3-Clause
@@ -10,8 +10,9 @@ Requires-Python: >=3.11
 Requires-Dist: deepl>=1.25.0
 Requires-Dist: django>=4.0
 Requires-Dist: djangorestframework>=3.14.0
+Requires-Dist: edx-opaque-keys
 Requires-Dist: gitpython>=3.1.40
-Requires-Dist: litellm>=1.0.0
+Requires-Dist: litellm>=1.80.0
 Requires-Dist: polib>=1.2.0
 Requires-Dist: requests>=2.31.0
 Requires-Dist: srt>=3.5.3
@@ -69,6 +70,7 @@ Configuration
        TRANSLATIONS_GITHUB_TOKEN: <YOUR_GITHUB_TOKEN>
        TRANSLATIONS_REPO_PATH: ""
        TRANSLATIONS_REPO_URL: "https://github.com/mitodl/mitxonline-translations.git"
+       LITE_LLM_REQUEST_TIMEOUT: 120  # Timeout for LLM API requests in seconds
 
 - 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>`_.
 

{ol_openedx_course_translations-0.3.0.dist-info → ol_openedx_course_translations-0.3.5.dist-info}/RECORD

@@ -1,6 +1,9 @@
 ol_openedx_course_translations/__init__.py,sha256=qddojx2E0sw3CdZ_iyjwt3iTN_oTPCo1iPtRMSEgyHA,50
-ol_openedx_course_translations/apps.py,sha256=F99ZzLzMIZB85uNEy2tIlvMM1JTf16XnTcpJY6FguIs,1013
-ol_openedx_course_translations/middleware.py,sha256=pdcygHc-UdKOoaWDvZJIDWCr9o1jNHqzefCQZl2aJmw,4556
+ol_openedx_course_translations/admin.py,sha256=MXtJCUydPjG6xoAc8oebtkQrmRZH-9IV8y6luzvrIlg,827
+ol_openedx_course_translations/apps.py,sha256=__HhrdS6Tb4A0cVF9kZlJSs1JKhMeLNVnWXPx91k2oo,1057
+ol_openedx_course_translations/filters.py,sha256=m7Gth09EWZelR_5pZGavmxczQ63fsFbCDbogl1-5lMY,1505
+ol_openedx_course_translations/middleware.py,sha256=f5D6ZHlFhsdiOHForrPwHc--ZJWMygVhjXpFpwUJxMs,4608
+ol_openedx_course_translations/models.py,sha256=muqwNYBtbON3Ru6Uq9krorYF1JmbIGOiBzWC-X7CBoU,1787
 ol_openedx_course_translations/tasks.py,sha256=fxxd4mMV8HxtOY-y6kvM-oNjoif4iJE-V2aVyFua0OE,8071
 ol_openedx_course_translations/urls.py,sha256=wDlOrRTtV_YRXAA1lpIhjEEf_fNkyfZUtmVPMD1PEi8,385
 ol_openedx_course_translations/views.py,sha256=ESDmgSFAvyHKQE9s2hthyNgRZmMuLNWvfrGkR4isoec,2173
@@ -15,21 +18,23 @@ ol_openedx_course_translations/glossaries/machine_learning/ru.txt,sha256=d-p1Ucx
 ol_openedx_course_translations/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ol_openedx_course_translations/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ol_openedx_course_translations/management/commands/sync_and_translate_language.py,sha256=E2sLaXYBTI1qCYcocV022Q-06y9iIA1YTMN5rHsb078,70176
-ol_openedx_course_translations/management/commands/translate_course.py,sha256=L7wWlfiRq4swVaySV6kcCs0rRT0RIxkl_Qw4A628m_M,20486
+ol_openedx_course_translations/management/commands/translate_course.py,sha256=QFSR63sO07urXU9BWYj0iv4Xy1Xd94RkV5nvUjpJdeI,22633
+ol_openedx_course_translations/migrations/0001_add_translation_logs.py,sha256=nitP-DJjDIeK9F3IcA1HvE5jpFaGCaoDP00XQxrjcSc,2876
+ol_openedx_course_translations/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ol_openedx_course_translations/providers/__init__.py,sha256=ZTWIG9KsYXYElfr-QwMsId7l6Sh6MypDKCWTivk3PME,48
 ol_openedx_course_translations/providers/base.py,sha256=-1QV7w-6Wpwz4EMzCiOOuWOG2kDw4b2gZ1KSK6GFVLM,9264
 ol_openedx_course_translations/providers/deepl_provider.py,sha256=hPuLVEZLU3Dm6a9H-8ztpcX53K9gUA8e57jUzn_HsKU,10076
-ol_openedx_course_translations/providers/llm_providers.py,sha256=L3MwmQI2appwn8FTKzZhRfq_FNauP1ei0kenY-yBcgc,19369
+ol_openedx_course_translations/providers/llm_providers.py,sha256=BIijQgVudTytxtrCvB-NTN9FvA8YPMFiB-77pAHjP-4,19953
 ol_openedx_course_translations/settings/cms.py,sha256=SzoTxVUlvlWvjQ58GCoVygHjoMNAH3InME7T9K6dTQ4,392
-ol_openedx_course_translations/settings/common.py,sha256=2UksaEnYLJFDdpzB7wTwgpoPkJ8X7z2wK9glHSCm88o,1733
-ol_openedx_course_translations/settings/lms.py,sha256=4u6BjqxWcWHpMgxlgF4lNs7H9pDgKTQrEtjdhOg7Qv0,365
+ol_openedx_course_translations/settings/common.py,sha256=NXrBo-GmL-nMZzQvDH-S7p8jy3SIR7spuOI8dZuexe0,1788
+ol_openedx_course_translations/settings/lms.py,sha256=381QL_84D-GxD97rZcsUsdjoYRUqcxWbbrzndkliRRY,1320
 ol_openedx_course_translations/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ol_openedx_course_translations/utils/command_utils.py,sha256=GRSGIBKm6ZnRCnv5oVRzxhS6UFwvjmNeJkvCEpLCks0,6482
-ol_openedx_course_translations/utils/constants.py,sha256=D3ICk0OmMHFdERShJ9eq5MaTaXHLVaUcVO3ZIg_3umQ,8141
-ol_openedx_course_translations/utils/course_translations.py,sha256=jlGYsIj7PBJRrPVDZt3Q4-QbwJKhHswaZPZPeicFAjE,20647
+ol_openedx_course_translations/utils/constants.py,sha256=geIe61KP4N1piXw-kr8QuACkw79pd8T1xeROq17LHyA,8171
+ol_openedx_course_translations/utils/course_translations.py,sha256=ZGh6YKNFR0MlNeYC1oCABCe0cbAWxLslpXj6jvO7WSs,21639
 ol_openedx_course_translations/utils/translation_sync.py,sha256=IQL-auVk5GwSfUfyeGICUDhd1KPxZs_bthAzRYm9LSs,26739
-ol_openedx_course_translations-0.3.0.dist-info/METADATA,sha256=YVqZ0XOrw8_5P1eUB4S4U92MF7ilsy7SDX1xHWz0n5Y,16716
-ol_openedx_course_translations-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-ol_openedx_course_translations-0.3.0.dist-info/entry_points.txt,sha256=FPeAXhaGYIZqafskkDD8xPiljXJ6djil27_kTuNP0BI,239
-ol_openedx_course_translations-0.3.0.dist-info/licenses/LICENSE.txt,sha256=iVk4rSDx0SwrA7AriwFblTY0vUxpuVib1oqJEEeejN0,1496
-ol_openedx_course_translations-0.3.0.dist-info/RECORD,,
+ol_openedx_course_translations-0.3.5.dist-info/METADATA,sha256=e08wH5Ldm9qovRG2QTCVGCrc-iG9qwr0Xc135sx0m4I,16828
+ol_openedx_course_translations-0.3.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ol_openedx_course_translations-0.3.5.dist-info/entry_points.txt,sha256=FPeAXhaGYIZqafskkDD8xPiljXJ6djil27_kTuNP0BI,239
+ol_openedx_course_translations-0.3.5.dist-info/licenses/LICENSE.txt,sha256=iVk4rSDx0SwrA7AriwFblTY0vUxpuVib1oqJEEeejN0,1496
+ol_openedx_course_translations-0.3.5.dist-info/RECORD,,