ol-openedx-course-sync 0.4.0__py3-none-any.whl

ol_openedx_course_sync/__init__.py

@@ -0,0 +1,5 @@
+"""
+ol-openedx-course-sync plugin
+"""
+
+default_app_config = "ol_openedx_course_sync.apps.OLOpenEdxCourseSyncConfig"

ol_openedx_course_sync/admin.py

@@ -0,0 +1,91 @@
+"""
+Django admin for ol-openedx-course-sync plugin
+"""
+
+import logging
+
+from django import forms
+from django.contrib import admin
+from organizations.models import Organization
+
+from ol_openedx_course_sync.models import CourseSyncMapping, CourseSyncOrganization
+from ol_openedx_course_sync.tasks import async_course_sync
+
+log = logging.getLogger(__name__)
+
+
+class CourseSyncOrganizationForm(forms.ModelForm):
+    """
+    Form for CourseSyncOrganization model
+    """
+
+    class Meta:
+        model = CourseSyncOrganization
+        fields = "__all__"  # noqa: DJ007
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        org_choices = [
+            (org.name, org.name) for org in Organization.objects.filter(active=True)
+        ]
+        self.fields["organization"] = forms.ChoiceField(choices=org_choices)
+
+
+class CourseSyncOrganizationAdmin(admin.ModelAdmin):
+    """
+    Admin for CourseSyncOrganization model
+    """
+
+    form = CourseSyncOrganizationForm
+    list_display = ("organization", "is_active")
+
+    def has_delete_permission(self, request, obj=None):
+        """
+        Disable delete permission if CourseSyncMapping is not clean
+        """
+        if obj and not obj.can_be_deleted():
+            return False
+        return super().has_delete_permission(request, obj)
+
+
+class CourseSyncMappingAdmin(admin.ModelAdmin):
+    """
+    Admin for CourseSyncMapping model
+    """
+
+    list_display = ("source_course", "target_course", "is_active")
+    search_fields = ("source_course", "target_course")
+    list_filter = ("is_active",)
+    actions = ("sync_course_content",)
+
+    def get_readonly_fields(self, request, obj=None):  # noqa: ARG002
+        """
+        Make source_course readonly if object already exists.
+        """
+        if obj:
+            return (*self.readonly_fields, "source_course")
+        return self.readonly_fields
+
+    @admin.action(description="Sync Course Content")
+    def sync_course_content(self, request, queryset):
+        """
+        Sync course content for selected CourseSyncMapping(s)
+        """
+        for course_sync_mapping in queryset:
+            log.info(
+                "Initializing course content sync through admin actions from %s to %s",
+                course_sync_mapping.source_course,
+                course_sync_mapping.target_course,
+            )
+            async_course_sync.delay(
+                str(course_sync_mapping.source_course),
+                str(course_sync_mapping.target_course),
+            )
+            self.message_user(
+                request,
+                "Course sync started",
+            )
+
+
+admin.site.register(CourseSyncOrganization, CourseSyncOrganizationAdmin)
+admin.site.register(CourseSyncMapping, CourseSyncMappingAdmin)

ol_openedx_course_sync/apps.py

@@ -0,0 +1,30 @@
+"""
+App configuration for ol-openedx-course-sync plugin
+"""
+
+from django.apps import AppConfig
+from edx_django_utils.plugins import PluginSignals
+from openedx.core.djangoapps.plugins.constants import ProjectType
+
+
+class OLOpenEdxCourseSyncConfig(AppConfig):
+    """
+    App configuration for the ol-openedx-course-sync app.
+    """
+
+    name = "ol_openedx_course_sync"
+    verbose_name = "Open edX Course Sync"
+
+    plugin_app = {
+        PluginSignals.CONFIG: {
+            ProjectType.CMS: {
+                PluginSignals.RECEIVERS: [
+                    {
+                        PluginSignals.RECEIVER_FUNC_NAME: "listen_for_course_publish",
+                        PluginSignals.SIGNAL_PATH: "xmodule.modulestore.django.COURSE_PUBLISHED",  # noqa: E501
+                        PluginSignals.DISPATCH_UID: "ol_openedx_course_sync.signals.listen_for_course_publish",  # noqa: E501
+                    }
+                ],
+            },
+        },
+    }

ol_openedx_course_sync/constants.py

@@ -0,0 +1,6 @@
+"""
+Constants for ol-openedx-course-sync plugin
+"""
+
+COURSE_RERUN_STATE_SUCCEEDED = "succeeded"
+STATIC_TAB_TYPE = "static_tab"

ol_openedx_course_sync/migrations/0001_initial.py

@@ -0,0 +1,54 @@
+# Generated by Django 4.2.20 on 2025-05-23 09:28
+
+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="CourseSyncMapping",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "source_course",
+                    opaque_keys.edx.django.models.CourseKeyField(max_length=255),
+                ),
+                (
+                    "target_course",
+                    opaque_keys.edx.django.models.CourseKeyField(
+                        max_length=255, unique=True
+                    ),
+                ),
+                ("is_active", models.BooleanField(default=True)),
+            ],
+        ),
+        migrations.CreateModel(
+            name="CourseSyncOrganization",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("organization", models.CharField(max_length=255, unique=True)),
+                ("is_active", models.BooleanField(default=True)),
+            ],
+        ),
+    ]

ol_openedx_course_sync/models.py

@@ -0,0 +1,101 @@
+"""
+Models for ol-openedx-course-sync plugin
+"""
+
+from django.core.exceptions import ValidationError
+from django.db import models
+from opaque_keys.edx.django.models import (
+    CourseKeyField,
+)
+from openedx.core.djangoapps.content.course_overviews.models import CourseOverview
+
+
+class CourseSyncOrganization(models.Model):
+    """
+    Model for source course organizations
+
+    Any course that is part of this organization
+    will sync the content changes to the target/rerun courses.
+    """
+
+    organization = models.CharField(max_length=255, unique=True)
+    is_active = models.BooleanField(default=True)
+
+    class Meta:
+        app_label = "ol_openedx_course_sync"
+
+    def __str__(self):
+        return f"{self.organization} Course Sync Organization"
+
+    def delete(self, *args, **kwargs):
+        """
+        Override delete method to perform custom validations.
+        """
+        if not self.can_be_deleted():
+            raise ValidationError(  # noqa: TRY003
+                "Cannot delete organization with existing CourseSyncMapping objects."  # noqa: EM101
+            )
+        super().delete(*args, **kwargs)
+
+    def can_be_deleted(self):
+        """
+        Check if the organization can be deleted.
+        """
+        return not CourseSyncMapping.objects.filter(
+            models.Q(source_course__contains=self.organization)
+            | models.Q(target_course__contains=self.organization)
+        ).exists()
+
+
+class CourseSyncMapping(models.Model):
+    """
+    Model to keep track of source and target courses.
+    """
+
+    source_course = CourseKeyField(max_length=255)
+    target_course = CourseKeyField(max_length=255, unique=True)
+    is_active = models.BooleanField(default=True)
+
+    class Meta:
+        app_label = "ol_openedx_course_sync"
+
+    def __str__(self):
+        return f"{self.source_course} Course Sync Mapping"
+
+    def save(self, *args, **kwargs):
+        """
+        Override save method to perform custom validations.
+        """
+        self.full_clean()
+        super().save(*args, **kwargs)
+
+    def clean(self):
+        """
+        Override clean method to perform custom validations.
+        """
+        super().clean()
+
+        if not CourseOverview.objects.filter(id=self.source_course).exists():
+            raise ValidationError({"source_course": "Source course does not exist"})
+
+        if not CourseOverview.objects.filter(id=self.target_course).exists():
+            raise ValidationError({"target_course": "Target course does not exist"})
+
+        conflicting_target = CourseSyncMapping.objects.filter(
+            target_course=self.source_course
+        ).first()
+        if conflicting_target:
+            raise ValidationError(
+                {
+                    "source_course": f"This course is already used as target course of: "  # noqa: E501
+                    f"{conflicting_target.source_course}"
+                }
+            )
+
+        conflicting_source = CourseSyncMapping.objects.filter(
+            source_course=self.target_course
+        ).first()
+        if conflicting_source:
+            raise ValidationError(
+                {"target_course": "This course is already a source course"}
+            )

ol_openedx_course_sync/settings/common.py

@@ -0,0 +1,10 @@
+"""Common settings unique to the course sync plugin."""
+
+
+def plugin_settings(settings):
+    """Configure settings for the course sync plugin."""
+    # .. setting_name: OL_OPENEDX_COURSE_SYNC_SERVICE_WORKER_USERNAME
+    # .. setting_default: ""
+    # .. setting_description: The username of the service worker that
+    # will be used to sync courses.
+    settings.OL_OPENEDX_COURSE_SYNC_SERVICE_WORKER_USERNAME = ""

ol_openedx_course_sync/settings/production.py

@@ -0,0 +1,10 @@
+"""Production settings unique to the course sync plugin."""
+
+
+def plugin_settings(settings):
+    """Configure settings for the course sync plugin."""
+    # .. setting_name: OL_OPENEDX_COURSE_SYNC_SERVICE_WORKER_USERNAME
+    # .. setting_default: ""
+    # .. setting_description: The username of the service worker that
+    # will be used to sync courses.
+    settings.OL_OPENEDX_COURSE_SYNC_SERVICE_WORKER_USERNAME = ""

ol_openedx_course_sync/signals.py

@@ -0,0 +1,89 @@
+"""
+Signal handlers for ol-openedx-course-sync plugin
+"""
+
+import logging
+
+from common.djangoapps.course_action_state.models import CourseRerunState
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured, ValidationError
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+
+from ol_openedx_course_sync.constants import COURSE_RERUN_STATE_SUCCEEDED
+from ol_openedx_course_sync.models import CourseSyncMapping, CourseSyncOrganization
+from ol_openedx_course_sync.tasks import async_course_sync
+
+log = logging.getLogger(__name__)
+
+
+def listen_for_course_publish(
+    sender,  # noqa: ARG001
+    course_key,
+    **kwargs,  # noqa: ARG001
+):
+    """
+    Listen for course publish signal and trigger course sync task
+    """
+    if not CourseSyncOrganization.objects.filter(
+        organization=course_key.org, is_active=True
+    ).exists():
+        return
+
+    if not getattr(settings, "OL_OPENEDX_COURSE_SYNC_SERVICE_WORKER_USERNAME", None):
+        error_msg = (
+            "OL_OPENEDX_COURSE_SYNC_SERVICE_WORKER_USERNAME is not set. "
+            "Course sync will not be performed."
+        )
+        raise ImproperlyConfigured(error_msg)
+
+    course_sync_mappings = CourseSyncMapping.objects.filter(
+        source_course=course_key, is_active=True
+    )
+    if not course_sync_mappings:
+        log.info("No mapping found for course %s. Skipping sync.", str(course_key))
+        return
+
+    for course_sync_mapping in course_sync_mappings:
+        log.info(
+            "Initializing course content sync from %s to %s",
+            course_sync_mapping.source_course,
+            course_sync_mapping.target_course,
+        )
+        async_course_sync.delay(
+            str(course_sync_mapping.source_course),
+            str(course_sync_mapping.target_course),
+        )
+
+
+@receiver(post_save, sender=CourseRerunState)
+def listen_for_course_rerun_state_post_save(sender, instance, **kwargs):  # noqa: ARG001
+    """
+    Listen for `CourseRerunState` post_save and
+    create target courses in `CourseSyncMapping`
+    """
+    if instance.state != COURSE_RERUN_STATE_SUCCEEDED:
+        return
+
+    if not CourseSyncOrganization.objects.filter(
+        organization=instance.source_course_key.org, is_active=True
+    ).exists():
+        return
+
+    try:
+        course_sync_mapping = CourseSyncMapping.objects.create(
+            source_course=instance.source_course_key,
+            target_course=instance.course_key,
+        )
+    except ValidationError:
+        log.exception(
+            "Failed to create CourseSyncMapping for %s",
+            instance.source_course_key,
+        )
+    else:
+        # Trigger course sync to sync the published changes.
+        # When a course clone or rerun is created, published changes are not synced.
+        async_course_sync.delay(
+            str(course_sync_mapping.source_course),
+            str(course_sync_mapping.target_course),
+        )

ol_openedx_course_sync/tasks.py

@@ -0,0 +1,106 @@
+"""
+Tasks for the ol-openedx-course-sync plugin.
+"""
+
+from celery import shared_task  # pylint: disable=import-error
+from celery.utils.log import get_task_logger
+from celery_utils.persist_on_failure import LoggedPersistOnFailureTask
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from edx_django_utils.cache import TieredCache, get_cache_key
+from edxval.api import copy_course_videos
+from opaque_keys.edx.locator import CourseLocator
+from xmodule.modulestore import ModuleStoreEnum
+from xmodule.modulestore.django import SignalHandler, modulestore
+
+from ol_openedx_course_sync.apps import OLOpenEdxCourseSyncConfig
+from ol_openedx_course_sync.utils import (
+    copy_course_content,
+    copy_static_tabs,
+    update_default_tabs,
+)
+
+User = get_user_model()
+logger = get_task_logger(__name__)
+
+
+@shared_task(
+    base=LoggedPersistOnFailureTask,
+    autoretry_for=(Exception,),
+    max_retries=3,
+    default_retry_delay=30,
+)
+def async_course_sync(source_course_id, dest_course_id):
+    """
+    Sync course content from source course to destination course.
+    """
+    logger.info("Starting course sync from %s to %s", source_course_id, dest_course_id)
+    source_course_key = CourseLocator.from_string(source_course_id)
+    dest_course_key = CourseLocator.from_string(dest_course_id)
+
+    cache_key = get_cache_key(
+        course_sync_service_worker=settings.OL_OPENEDX_COURSE_SYNC_SERVICE_WORKER_USERNAME
+    )
+    cache_value = TieredCache.get_cached_response(cache_key)
+    if not cache_value.is_found:
+        user = User.objects.filter(
+            username=settings.OL_OPENEDX_COURSE_SYNC_SERVICE_WORKER_USERNAME
+        ).first()
+        TieredCache.set_all_tiers(cache_key, user)
+    else:
+        user = cache_value.value
+
+    if not user:
+        logger.error(
+            "Service worker user %s not found. Cannot perform course sync.",
+            settings.OL_OPENEDX_COURSE_SYNC_SERVICE_WORKER_USERNAME,
+        )
+        return
+
+    logger.info(
+        "Copying draft course content from %s to %s", source_course_key, dest_course_key
+    )
+    # Copy draft branch content
+    copy_course_content(
+        source_course_key, dest_course_key, ModuleStoreEnum.BranchName.draft, user.id
+    )
+
+    logger.info(
+        "Copying course assets from %s to %s",
+        source_course_key,
+        dest_course_key,
+    )
+    # Copy course assets and videos.
+    # These steps are taken from the course_rerun task in edx-platform.
+    module_store = modulestore()
+    if module_store.contentstore:
+        module_store.contentstore.delete_all_course_assets(dest_course_key)
+        module_store.contentstore.copy_all_course_assets(
+            source_course_key, dest_course_key
+        )
+    copy_course_videos(source_course_key, dest_course_key)
+
+    logger.info(
+        "Copying published course content from %s to %s",
+        source_course_key,
+        dest_course_key,
+    )
+    # copy published branch content
+    copy_course_content(
+        source_course_key,
+        dest_course_key,
+        ModuleStoreEnum.BranchName.published,
+        user.id,
+    )
+
+    logger.info("Syncing static tabs from %s to %s", source_course_key, dest_course_key)
+    copy_static_tabs(source_course_key, dest_course_key, user)
+    update_default_tabs(source_course_key, dest_course_key, user)
+
+    # trigger course publish signal to trigger outline and relevant updates
+    SignalHandler.course_published.send(
+        sender=OLOpenEdxCourseSyncConfig, course_key=dest_course_key
+    )
+    logger.debug(
+        "Finished course sync from %s to %s", source_course_key, dest_course_key
+    )

ol_openedx_course_sync/utils.py

@@ -0,0 +1,138 @@
+"""
+Utilities for the ol-openedx-course-sync plugin
+"""
+
+from uuid import uuid4
+
+from cms.djangoapps.contentstore.utils import duplicate_block
+from xmodule.modulestore.django import modulestore
+from xmodule.modulestore.exceptions import ItemNotFoundError
+from xmodule.tabs import CourseTabList, StaticTab
+
+from ol_openedx_course_sync.constants import STATIC_TAB_TYPE
+
+
+def copy_course_content(source_course_key, target_course_key, branch, user_id=None):
+    """
+    Copy course content from source_course to target_course
+    on the specified branch.
+    """
+    module_store = modulestore()
+    subtree_list = [module_store.make_course_usage_key(source_course_key)]
+    source_course_key_for_branch = source_course_key.for_branch(branch)
+    target_course_key_for_branch = target_course_key.for_branch(branch)
+
+    source_modulestore = module_store._get_modulestore_for_courselike(source_course_key)  # noqa: SLF001
+    target_modulestore = module_store._get_modulestore_for_courselike(target_course_key)  # noqa: SLF001
+    if source_modulestore == target_modulestore:
+        source_modulestore.copy(
+            user_id,
+            source_course_key_for_branch,
+            target_course_key_for_branch,
+            subtree_list,
+        )
+
+
+def copy_static_tabs(source_course_key, target_course_key, user):
+    """
+    Copy static tabs from source to target course.
+
+    Args:
+        source_course_key (CourseLocator): The course key of the source course.
+        target_course_key (CourseLocator): The course key of the target course.
+        user (User): The user performing the update.
+    """
+    store = modulestore()
+    source_course = store.get_course(source_course_key)
+    target_course = store.get_course(target_course_key)
+
+    # If we need to update the static tabs, we will delete the
+    # old static tabs and create new ones to handle the tab ordering.
+    for tab in target_course.tabs:
+        if tab.type != STATIC_TAB_TYPE:
+            continue
+
+        tab_usage_key = target_course.id.make_usage_key(STATIC_TAB_TYPE, tab.url_slug)
+        existing_tabs = target_course.tabs or []
+
+        # Remove the tab from the target course tabs list
+        target_course.tabs = [
+            tab
+            for tab in existing_tabs
+            if tab.get("url_slug") != tab_usage_key.block_id
+        ]
+        store.update_item(target_course, user.id)
+        try:
+            store.get_item(tab_usage_key, user.id)
+        except ItemNotFoundError:
+            # If the tab does not exist, we can skip deletion
+            continue
+        store.delete_item(tab_usage_key, user.id)
+
+    # Now copy the static tabs from the source course to the target course
+    # Steps:
+    # 1. Iterate through the static tabs in the source course.
+    # 2. For each static tab, create a new usage key for the target course.
+    # 3. Duplicate the block from the source course to the target course.
+    # 4. Update the target course's tabs list with the new tab
+    target_course_usage_key = target_course.usage_key
+    for source_tab in source_course.tabs:
+        if source_tab.type != STATIC_TAB_TYPE:
+            continue
+
+        # Create a new usage key for the destination tab
+        target_tab_usage_key = target_course_usage_key.replace(
+            category=STATIC_TAB_TYPE, name=uuid4().hex
+        )
+        source_tab_usage_key = source_course.id.make_usage_key(
+            STATIC_TAB_TYPE, source_tab.url_slug
+        )
+
+        duplicate_block(
+            target_course_usage_key,
+            source_tab_usage_key,
+            user,
+            dest_usage_key=target_tab_usage_key,
+            display_name=source_tab.name,
+            shallow=True,
+        )
+
+        source_tab_dict = source_tab.to_json()
+        source_tab_dict["url_slug"] = target_tab_usage_key.block_id
+        target_course.tabs.append(
+            StaticTab(
+                tab_dict=source_tab_dict,
+                name=source_tab.name,
+                url_slug=target_tab_usage_key.block_id,
+            )
+        )
+
+    store.update_item(target_course, user.id)
+
+
+def update_default_tabs(source_course_key, target_course_key, user):
+    """
+    Update the `is_hidden` tab state for the default tabs like wiki, and progress tab.
+
+    Args:
+        source_course_key (CourseLocator): The course key of the source course.
+        target_course_key (CourseLocator): The course key of the target course.
+        user (User): The user performing the update.
+    """
+    store = modulestore()
+    source_course = store.get_course(source_course_key)
+    target_course = store.get_course(target_course_key)
+    is_updated = False
+
+    for tab in source_course.tabs:
+        if tab.type == STATIC_TAB_TYPE:
+            continue
+
+        target_course_tab = CourseTabList.get_tab_by_type(target_course.tabs, tab.type)
+        if tab.is_hidden == target_course_tab.is_hidden:
+            continue
+        target_course_tab.is_hidden = tab.is_hidden
+        is_updated = True
+
+    if is_updated:
+        store.update_item(target_course, user.id)

ol_openedx_course_sync-0.4.0.dist-info/METADATA

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: ol-openedx-course-sync
+Version: 0.4.0
+Summary: An Open edX plugin to sync course changes to its reruns.
+Author: MIT Office of Digital Learning
+License-Expression: BSD-3-Clause
+License-File: LICENCE
+Requires-Python: >=3.11
+Requires-Dist: django>2.0
+Requires-Dist: djangorestframework>=3.14.0
+Requires-Dist: edx-django-utils>4.0.0
+Requires-Dist: edx-opaque-keys
+Requires-Dist: openedx-events
+Description-Content-Type: text/x-rst
+
+OL Open edX Course Sync
+=======================
+
+An Open edX plugin to sync course changes to its reruns.
+
+Version Compatibility
+---------------------
+
+It supports Open edX releases from `Sumac` and onwards.
+
+Installing The Plugin
+---------------------
+
+For detailed installation instructions, please refer to the `plugin installation guide <../../docs#installation-guide>`_.
+
+Installation required in:
+
+* CMS
+
+Configuration
+=============
+
+* Add a setting ``OL_OPENEDX_COURSE_SYNC_SERVICE_WORKER_USERNAME`` for the service worker and all the sync operations will be done on behalf of this user.
+
+  * For Tutor, you can run:
+
+    .. code-block:: bash
+
+       tutor config save --set OL_OPENEDX_COURSE_SYNC_SERVICE_WORKER_USERNAME={USERNAME}
+
+  * If you have a ``private.py`` for the CMS settings, you can add it to ``cms/envs/private.py``.
+
+Usage
+-----
+
+* Install the plugin and run the migrations in the CMS.
+* Add the parent/source organization in the CMS admin model `CourseSyncOrganization`.
+    * Course sync will only work for this organization. It will treat all the courses under this organization as parent/source courses.
+* The plugin will automatically add course re-runs created from the CMS as the child courses.
+    * The organization can be different for the reruns.
+* Target/rerun courses can be managed in the CMS admin model `CourseSyncMapping`.
+* Now, any changes made in the source course will be synced to the target courses.

ol_openedx_course_sync-0.4.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+ol_openedx_course_sync/__init__.py,sha256=nETfBgWsxXNBycNTq2Uf0n0Jv3pI1B3zndwtfw0cjfI,116
+ol_openedx_course_sync/admin.py,sha256=0D7IP6OG9MX3rWSQhD5UK-D_fIVgNUBN1qHeQrPoRAE,2767
+ol_openedx_course_sync/apps.py,sha256=_hDAxj48F3nARJ4FmP5ONSloN6ox-c_dCSaca7CEanI,957
+ol_openedx_course_sync/constants.py,sha256=c_9EyNS27BU9wZi_dI3uTbVeObcl3McaYpbGnG2bTjE,127
+ol_openedx_course_sync/models.py,sha256=NCOuJVW5g6GxPP_oEdOAURP-NBGXtnTABiuNjbKo7-s,3193
+ol_openedx_course_sync/signals.py,sha256=Foq7C1NEOl7FP3GX9RcZtOcn05RW84hPEzHt9HTYL0I,2955
+ol_openedx_course_sync/tasks.py,sha256=LaVjyRv6iTI93p3983fTHp8BdS-hIyVq4vq_dB1dxEk,3621
+ol_openedx_course_sync/utils.py,sha256=ScOdJaqZ4oOMnP3QOEWXn_MRphMj88u3fvZ1rPlyn1o,5037
+ol_openedx_course_sync/migrations/0001_initial.py,sha256=O-j6B6SctPZ63nzuNX6WNf5fJ6jJFe_HZDoj9Lbt-gI,1677
+ol_openedx_course_sync/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ol_openedx_course_sync/settings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ol_openedx_course_sync/settings/common.py,sha256=U5A6fDciDihofo2fDLKul-i0xV6_wJXPlUOQ_iIbi8A,416
+ol_openedx_course_sync/settings/production.py,sha256=n5K9vicUD7rUQC-P21tppY4g3JTv3-T37-AWr-igSwo,420
+ol_openedx_course_sync-0.4.0.dist-info/METADATA,sha256=QBjZRnR8q6UNddT_ZneAxJsgylcZpmWaFG1NpQIvM9I,1902
+ol_openedx_course_sync-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ol_openedx_course_sync-0.4.0.dist-info/entry_points.txt,sha256=KIm6L9U3HifBgJidmyFU7Wyap0b0krOF9vxVDvnWulU,95
+ol_openedx_course_sync-0.4.0.dist-info/licenses/LICENCE,sha256=YfuyC7jc8ov7-UJZI-iUXi3g0HdeAaDG-IQ90-McB9M,1496
+ol_openedx_course_sync-0.4.0.dist-info/RECORD,,

ol_openedx_course_sync-0.4.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ol_openedx_course_sync-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[cms.djangoapp]
+ol_openedx_course_sync = ol_openedx_course_sync.apps:OLOpenEdxCourseSyncConfig

ol_openedx_course_sync-0.4.0.dist-info/licenses/LICENCE

@@ -0,0 +1,28 @@
+Copyright (C) 2025  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.