ol-openedx-uai-content-customization 0.1.0__tar.gz

ol_openedx_uai_content_customization-0.1.0/.gitignore

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

ol_openedx_uai_content_customization-0.1.0/LICENSE.txt

@@ -0,0 +1,28 @@
+Copyright (C) 2026  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_uai_content_customization-0.1.0/PKG-INFO

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: ol-openedx-uai-content-customization
+Version: 0.1.0
+Summary: An Open edX plugin to generate industry/length-specific UAI custom courses from video CSV data.
+Author: MIT Office of Digital Learning
+License-Expression: BSD-3-Clause
+License-File: LICENSE.txt
+Requires-Python: >=3.11
+Requires-Dist: django>=4.0
+Requires-Dist: edx-django-utils>4.0.0
+Requires-Dist: edx-opaque-keys
+Description-Content-Type: text/x-rst
+
+OL Open edX UAI Content Customization
+======================================
+
+An Open edX CMS plugin that automates the generation of industry- and
+length-specific UAI course variants using direct Open edX modulestore APIs.
+
+Version Compatibility
+---------------------
+
+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
+
+Overview
+--------
+
+For each unique (course_key, industry, duration) row group in the CSV the
+command clones the source course into a new UAI-specific key, removes every
+existing section from the clone, and rebuilds the content from the CSV data.
+This produces multiple industry- and length-specific variants per source
+course while preserving all course settings (grading policy, certificates,
+pacing, advanced settings) from the original.
+
+Supported industry/length combinations:
+
++--------------+------+-------------+--------+
+| Industry     | Code | Length code | Length |
++==============+======+=============+========+
+| Healthcare   | HC   | S           | Short  |
++--------------+------+-------------+--------+
+| Healthcare   | HC   | F           | Full   |
++--------------+------+-------------+--------+
+| Finance      | F    | S           | Short  |
++--------------+------+-------------+--------+
+| Finance      | F    | F           | Full   |
++--------------+------+-------------+--------+
+| Energy       | E    | S           | Short  |
++--------------+------+-------------+--------+
+| Energy       | E    | F           | Full   |
++--------------+------+-------------+--------+
+| Original     | —    | S           | Short  |
++--------------+------+-------------+--------+
+| Original     | —    | F           | Full   |
++--------------+------+-------------+--------+
+
+Course Key Format
+~~~~~~~~~~~~~~~~~
+
+.. code-block:: text
+
+    course-v1:ORG+NUMBER.<DURATION>[.<INDUSTRY>]+RUN
+
+For the **Original** industry, no industry code is appended:
+
+.. code-block:: text
+
+    course-v1:UAI_SOURCE+UAI.3.S+1T2026   ← Original, Short
+    course-v1:UAI_SOURCE+UAI.3.F+1T2026   ← Original, Full
+    course-v1:UAI_SOURCE+UAI.3.S.HC+1T2026 ← Healthcare, Short
+
+Course Structure
+~~~~~~~~~~~~~~~~
+
+Each generated course has the following structure::
+
+    Course (<display name>)
+    └── Lectures  (section)
+        └── <Video Title>  (subsection)
+            └── <Video Title>  (unit)
+                └── <Video Title>  (video block with edX video ID)
+
+Usage
+-----
+
+Prerequisites
+~~~~~~~~~~~~~
+
+You will need two CSV files:
+
+1. **Processed videos CSV** — produced by the video customization
+   workflow. Required columns:
+
+   - ``course_key`` — the Open edX course key of the **source course to
+     clone** (e.g. ``course-v1:UAI_SOURCE+UAI.2+1T2026``).  This course
+     **must already exist** in the CMS modulestore before the command runs.
+     The command validates all source keys up-front and aborts with an error
+     if any are missing.
+   - ``industry`` — one of: ``Healthcare``, ``Finance``, ``Energy``,
+     ``Original industry``
+   - ``duration`` — ``short`` or ``long``
+   - ``video_file_name`` — file name matching the ``name`` column in the edX videos CSV
+   - ``video_title`` — display name for the subsection/unit/video
+   - ``module_name`` — used to build the course display name
+
+2. **Open edX videos CSV** — exported from Studio / OVS after uploading
+   the customized videos. Required columns:
+
+   - ``name`` — video file name (matches ``video_file_name`` above)
+   - ``video_id`` — the Open edX UUID for the video
+
+Running the Command
+~~~~~~~~~~~~~~~~~~~
+
+Run the management command from inside the CMS container (e.g. Tutor dev
+shell):
+
+.. code-block:: bash
+
+    python manage.py generate_uai_course_versions \
+        --processed-videos-csv /path/to/processed_videos.csv \
+        --edx-videos-csv /path/to/edx_videos.csv \
+        [--username studio_worker] \
+        [--dry-run]
+
+Options
+~~~~~~~
+
+``--processed-videos-csv``
+    Path to the processed video metadata CSV file. **Required.**
+
+``--edx-videos-csv``
+    Path to the Open edX videos CSV file. **Required.**
+
+``--username``
+    Username of the platform user under whose authority the courses are
+    created. Defaults to ``studio_worker``.
+
+``--dry-run``
+    Print what would be created without writing anything to the modulestore.
+    Use this to verify CSV mapping before committing.
+
+How It Works
+~~~~~~~~~~~~
+
+For each unique ``(course_key, industry, duration)`` group the command:
+
+1. **Validates** all source course keys against the live modulestore before
+   making any writes (fail-fast — aborts if any source is missing).
+2. **Clones** the source course into the new UAI-specific key, inheriting all
+   course settings.
+3. **Deletes** every existing section (chapter) from the clone.
+4. **Rebuilds** the content tree from the CSV rows::
+
+       Course  (cloned — settings inherited)
+       └── Lectures  (section)
+           └── <Video Title>  (subsection)
+               └── <Video Title>  (unit)
+                   └── <Video Title>  (video block)
+
+5. **Publishes** the course.
+
+.. note::
+
+   Course creation is **not atomic** (MongoDB is not covered by Django
+   transactions).  If a run fails partway through, already-created courses
+   remain; subsequent runs will skip them with a ``DuplicateCourseError``
+   warning.
+
+Development
+-----------
+
+.. code-block:: bash
+
+    # Install dependencies
+    uv sync --dev
+
+    # Run tests (requires Open edX environment — see AGENTS.md)
+    ./run_edx_integration_tests.sh --plugin ol_openedx_uai_content_customization --skip-build

ol_openedx_uai_content_customization-0.1.0/README.rst

@@ -0,0 +1,176 @@
+OL Open edX UAI Content Customization
+======================================
+
+An Open edX CMS plugin that automates the generation of industry- and
+length-specific UAI course variants using direct Open edX modulestore APIs.
+
+Version Compatibility
+---------------------
+
+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
+
+Overview
+--------
+
+For each unique (course_key, industry, duration) row group in the CSV the
+command clones the source course into a new UAI-specific key, removes every
+existing section from the clone, and rebuilds the content from the CSV data.
+This produces multiple industry- and length-specific variants per source
+course while preserving all course settings (grading policy, certificates,
+pacing, advanced settings) from the original.
+
+Supported industry/length combinations:
+
++--------------+------+-------------+--------+
+| Industry     | Code | Length code | Length |
++==============+======+=============+========+
+| Healthcare   | HC   | S           | Short  |
++--------------+------+-------------+--------+
+| Healthcare   | HC   | F           | Full   |
++--------------+------+-------------+--------+
+| Finance      | F    | S           | Short  |
++--------------+------+-------------+--------+
+| Finance      | F    | F           | Full   |
++--------------+------+-------------+--------+
+| Energy       | E    | S           | Short  |
++--------------+------+-------------+--------+
+| Energy       | E    | F           | Full   |
++--------------+------+-------------+--------+
+| Original     | —    | S           | Short  |
++--------------+------+-------------+--------+
+| Original     | —    | F           | Full   |
++--------------+------+-------------+--------+
+
+Course Key Format
+~~~~~~~~~~~~~~~~~
+
+.. code-block:: text
+
+    course-v1:ORG+NUMBER.<DURATION>[.<INDUSTRY>]+RUN
+
+For the **Original** industry, no industry code is appended:
+
+.. code-block:: text
+
+    course-v1:UAI_SOURCE+UAI.3.S+1T2026   ← Original, Short
+    course-v1:UAI_SOURCE+UAI.3.F+1T2026   ← Original, Full
+    course-v1:UAI_SOURCE+UAI.3.S.HC+1T2026 ← Healthcare, Short
+
+Course Structure
+~~~~~~~~~~~~~~~~
+
+Each generated course has the following structure::
+
+    Course (<display name>)
+    └── Lectures  (section)
+        └── <Video Title>  (subsection)
+            └── <Video Title>  (unit)
+                └── <Video Title>  (video block with edX video ID)
+
+Usage
+-----
+
+Prerequisites
+~~~~~~~~~~~~~
+
+You will need two CSV files:
+
+1. **Processed videos CSV** — produced by the video customization
+   workflow. Required columns:
+
+   - ``course_key`` — the Open edX course key of the **source course to
+     clone** (e.g. ``course-v1:UAI_SOURCE+UAI.2+1T2026``).  This course
+     **must already exist** in the CMS modulestore before the command runs.
+     The command validates all source keys up-front and aborts with an error
+     if any are missing.
+   - ``industry`` — one of: ``Healthcare``, ``Finance``, ``Energy``,
+     ``Original industry``
+   - ``duration`` — ``short`` or ``long``
+   - ``video_file_name`` — file name matching the ``name`` column in the edX videos CSV
+   - ``video_title`` — display name for the subsection/unit/video
+   - ``module_name`` — used to build the course display name
+
+2. **Open edX videos CSV** — exported from Studio / OVS after uploading
+   the customized videos. Required columns:
+
+   - ``name`` — video file name (matches ``video_file_name`` above)
+   - ``video_id`` — the Open edX UUID for the video
+
+Running the Command
+~~~~~~~~~~~~~~~~~~~
+
+Run the management command from inside the CMS container (e.g. Tutor dev
+shell):
+
+.. code-block:: bash
+
+    python manage.py generate_uai_course_versions \
+        --processed-videos-csv /path/to/processed_videos.csv \
+        --edx-videos-csv /path/to/edx_videos.csv \
+        [--username studio_worker] \
+        [--dry-run]
+
+Options
+~~~~~~~
+
+``--processed-videos-csv``
+    Path to the processed video metadata CSV file. **Required.**
+
+``--edx-videos-csv``
+    Path to the Open edX videos CSV file. **Required.**
+
+``--username``
+    Username of the platform user under whose authority the courses are
+    created. Defaults to ``studio_worker``.
+
+``--dry-run``
+    Print what would be created without writing anything to the modulestore.
+    Use this to verify CSV mapping before committing.
+
+How It Works
+~~~~~~~~~~~~
+
+For each unique ``(course_key, industry, duration)`` group the command:
+
+1. **Validates** all source course keys against the live modulestore before
+   making any writes (fail-fast — aborts if any source is missing).
+2. **Clones** the source course into the new UAI-specific key, inheriting all
+   course settings.
+3. **Deletes** every existing section (chapter) from the clone.
+4. **Rebuilds** the content tree from the CSV rows::
+
+       Course  (cloned — settings inherited)
+       └── Lectures  (section)
+           └── <Video Title>  (subsection)
+               └── <Video Title>  (unit)
+                   └── <Video Title>  (video block)
+
+5. **Publishes** the course.
+
+.. note::
+
+   Course creation is **not atomic** (MongoDB is not covered by Django
+   transactions).  If a run fails partway through, already-created courses
+   remain; subsequent runs will skip them with a ``DuplicateCourseError``
+   warning.
+
+Development
+-----------
+
+.. code-block:: bash
+
+    # Install dependencies
+    uv sync --dev
+
+    # Run tests (requires Open edX environment — see AGENTS.md)
+    ./run_edx_integration_tests.sh --plugin ol_openedx_uai_content_customization --skip-build

ol_openedx_uai_content_customization-0.1.0/ol_openedx_uai_content_customization/apps.py

@@ -0,0 +1,23 @@
+"""App configuration for ol-openedx-uai-content-customization plugin."""
+
+from django.apps import AppConfig
+from edx_django_utils.plugins import PluginSettings
+from openedx.core.djangoapps.plugins.constants import ProjectType, SettingsType
+
+
+class OLOpenEdxUaiContentCustomizationConfig(AppConfig):
+    """App configuration for the ol-openedx-uai-content-customization plugin."""
+
+    name = "ol_openedx_uai_content_customization"
+    verbose_name = "OL Open edX UAI Content Customization"
+
+    plugin_app = {
+        PluginSettings.CONFIG: {
+            ProjectType.CMS: {
+                SettingsType.PRODUCTION: {
+                    PluginSettings.RELATIVE_PATH: "settings.production"
+                },
+                SettingsType.COMMON: {PluginSettings.RELATIVE_PATH: "settings.common"},
+            },
+        },
+    }

ol_openedx_uai_content_customization-0.1.0/ol_openedx_uai_content_customization/constants.py

@@ -0,0 +1,47 @@
+"""Constants for ol-openedx-uai-content-customization plugin."""
+
+INDUSTRY_CODES = {
+    "Healthcare": "HC",
+    "Finance": "F",
+    "Energy": "E",
+    "Original industry": "",
+}
+
+DURATION_CODE_SHORT = "S"
+DURATION_CODE_FULL = "F"
+
+DURATION_CODES = {
+    "short": DURATION_CODE_SHORT,
+    "long": DURATION_CODE_FULL,
+}
+
+LECTURES_SECTION_DISPLAY_NAME = "Lectures"
+
+BLOCK_TYPE_CHAPTER = "chapter"
+BLOCK_TYPE_SEQUENTIAL = "sequential"
+BLOCK_TYPE_VERTICAL = "vertical"
+BLOCK_TYPE_VIDEO = "video"
+
+CSV_COL_COURSE_KEY = "course_key"
+CSV_COL_INDUSTRY = "industry"
+CSV_COL_DURATION = "duration"
+CSV_COL_VIDEO_FILE_NAME = "video_file_name"
+CSV_COL_VIDEO_TITLE = "video_title"
+CSV_COL_MODULE_NAME = "module_name"
+
+CSV_COL_ASSET_NAME = "name"
+CSV_COL_ASSET_VIDEO_ID = "video_id"
+
+REQUIRED_CUSTOMIZED_CSV_COLS = [
+    CSV_COL_COURSE_KEY,
+    CSV_COL_INDUSTRY,
+    CSV_COL_DURATION,
+    CSV_COL_VIDEO_FILE_NAME,
+    CSV_COL_VIDEO_TITLE,
+    CSV_COL_MODULE_NAME,
+]
+
+REQUIRED_ASSET_CSV_COLS = [
+    CSV_COL_ASSET_NAME,
+    CSV_COL_ASSET_VIDEO_ID,
+]

ol_openedx_uai_content_customization-0.1.0/ol_openedx_uai_content_customization/csv_utils.py

@@ -0,0 +1,154 @@
+"""CSV parsing and video-mapping utilities for ol-openedx-uai-content-customization."""
+
+import csv
+from collections import defaultdict
+from pathlib import Path
+
+from opaque_keys.edx.keys import CourseKey
+
+from ol_openedx_uai_content_customization.constants import (
+    CSV_COL_ASSET_NAME,
+    CSV_COL_ASSET_VIDEO_ID,
+    CSV_COL_COURSE_KEY,
+    CSV_COL_DURATION,
+    CSV_COL_INDUSTRY,
+    DURATION_CODES,
+    INDUSTRY_CODES,
+)
+
+
+def parse_csv(path):
+    """
+    Read a CSV file and return a ``(rows, fieldnames)`` tuple.
+
+    Returns:
+        tuple: A 2-tuple ``(rows, fieldnames)`` where *rows* is a list of
+        ``dict`` objects (one per data row) and *fieldnames* is the list of
+        column header strings as they appear in the file.  Both are empty
+        lists when the file contains no header row at all.
+    """
+    with Path(path).open(encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f)
+        fieldnames = list(reader.fieldnames or [])
+        rows = list(reader)
+    fieldnames = [col.lower() for col in fieldnames]
+    rows = [{col.lower(): value for col, value in row.items()} for row in rows]
+    return rows, fieldnames
+
+
+def validate_csv_columns(fieldnames, required_cols, csv_label):
+    """
+    Raise ValueError if any required column is absent from the CSV headers.
+
+    Args:
+        fieldnames: List of column header strings returned by parse_csv().
+        required_cols: Iterable of column names that must be present.
+        csv_label: Human-readable label used in the error message.
+
+    Raises:
+        ValueError: describing which columns are missing.
+    """
+    actual_cols = {col.lower() for col in fieldnames}
+    missing = [col for col in required_cols if col.lower() not in actual_cols]
+    if missing:
+        msg = f"{csv_label} is missing required columns: {', '.join(missing)}"
+        raise ValueError(msg)
+
+
+def build_video_id_map(video_asset_rows):
+    """
+    Build a mapping of video file name → Open edX video ID.
+
+    Args:
+        video_asset_rows: Rows from the Open edX video asset CSV.
+
+    Returns:
+        dict mapping file name (e.g. "v004_h264.mp4") to video UUID string.
+    """
+    return {
+        row[CSV_COL_ASSET_NAME]: row[CSV_COL_ASSET_VIDEO_ID] for row in video_asset_rows
+    }
+
+
+def resolve_duration_code(duration_value):
+    """
+    Convert a duration cell value into a Short/Full code.
+
+    The CSV must provide explicit values: "short" or "long"
+    (case-insensitive).
+
+    Args:
+        duration_value: Raw string from the Duration column.
+
+    Returns:
+        "S" or "F"
+
+    Raises:
+        ValueError: if the value is not one of "short" or "long".
+    """
+    value = str(duration_value).strip().lower()
+
+    if value in DURATION_CODES:
+        return DURATION_CODES[value]
+
+    msg = (
+        "Unrecognised duration value "
+        f"{duration_value!r}. Expected one of: {', '.join(DURATION_CODES)}"
+    )
+    raise ValueError(msg)
+
+
+def build_new_course_key(original_key, industry, duration_value):
+    """
+    Generate a new course key for the given industry and duration.
+
+    Format:  course-v1:ORG+NUMBER.<DURATION>[.<INDUSTRY>]+RUN
+
+    For "Original industry" no industry code is appended, so the format is:
+        course-v1:ORG+NUMBER.<DURATION>+RUN
+
+    Args:
+        original_key: e.g. "course-v1:UAI_SOURCE+UAI.2+1T2026"
+        industry: Industry name string as it appears in the CSV.
+        duration_value: Raw Duration column value.
+
+    Returns:
+        New course key string.
+    """
+    parsed = CourseKey.from_string(original_key)
+    org = parsed.org
+    number = parsed.course
+    run = parsed.run
+
+    dur_code = resolve_duration_code(duration_value)
+
+    if industry not in INDUSTRY_CODES:
+        known = ", ".join(INDUSTRY_CODES)
+        msg = f"Unrecognised industry {industry!r}. Must be one of: {known}"
+        raise ValueError(msg)
+    ind_code = INDUSTRY_CODES[industry]
+
+    if ind_code:
+        new_number = f"{number}.{dur_code}.{ind_code}"
+    else:
+        new_number = f"{number}.{dur_code}"
+
+    return f"course-v1:{org}+{new_number}+{run}"
+
+
+def group_videos_by_course(customized_rows):
+    """
+    Group video rows by (original_course_key, industry, duration).
+
+    Returns:
+        dict mapping (course_key, industry, duration) → list of row dicts.
+    """
+    groups = defaultdict(list)
+    for row in customized_rows:
+        key = (
+            row[CSV_COL_COURSE_KEY],
+            row[CSV_COL_INDUSTRY],
+            row[CSV_COL_DURATION],
+        )
+        groups[key].append(row)
+    return groups

ol_openedx_uai_content_customization-0.1.0/ol_openedx_uai_content_customization/management/commands/generate_uai_course_versions.py

@@ -0,0 +1,326 @@
+"""
+Management command: generate_uai_course_versions
+
+Reads two CSV files and uses Open edX modulestore APIs to build industry- and
+length-specific variants of UAI courses by cloning a base course:
+
+  - Processed videos CSV  (produced by the video-generation workflow)
+  - Open edX videos CSV (exported from Studio / OVS)
+
+For each unique (course_key, industry, duration) combination the command:
+    1. Clones the source course (identified by the ``course_key`` CSV column)
+     into a new UAI-specific course key, preserving all course settings.
+  2. Deletes every existing section from the clone.
+  3. Rebuilds the content tree from the CSV data:
+
+        Course  (cloned, settings inherited)
+        └── Lectures  (chapter)
+            └── <Video Title>  (sequential)
+                └── <Video Title>  (vertical)
+                    └── <Video Title>  (video block)
+
+Usage:
+    python manage.py generate_uai_course_versions \\
+        --processed-videos-csv /path/to/processed_videos.csv \\
+        --edx-videos-csv /path/to/edx_videos.csv \\
+        [--username studio_worker] \\
+        [--dry-run]
+
+Note: this command writes to the MongoDB-backed modulestore.  Django's
+transaction.atomic() does NOT cover MongoDB, so course creation is not
+atomic.  If a run fails partway through, already-created courses will remain
+and subsequent runs will raise DuplicateCourseError for them (skipped with a
+warning).
+"""
+
+import logging
+
+from django.contrib.auth import get_user_model
+from django.core.management.base import BaseCommand, CommandError
+from opaque_keys import InvalidKeyError
+from opaque_keys.edx.keys import CourseKey
+from xmodule.modulestore.django import modulestore
+from xmodule.modulestore.exceptions import DuplicateCourseError
+
+from ol_openedx_uai_content_customization.constants import (
+    BLOCK_TYPE_CHAPTER,
+    BLOCK_TYPE_SEQUENTIAL,
+    BLOCK_TYPE_VERTICAL,
+    BLOCK_TYPE_VIDEO,
+    CSV_COL_MODULE_NAME,
+    CSV_COL_VIDEO_FILE_NAME,
+    CSV_COL_VIDEO_TITLE,
+    LECTURES_SECTION_DISPLAY_NAME,
+    REQUIRED_ASSET_CSV_COLS,
+    REQUIRED_CUSTOMIZED_CSV_COLS,
+)
+from ol_openedx_uai_content_customization.csv_utils import (
+    build_new_course_key,
+    build_video_id_map,
+    group_videos_by_course,
+    parse_csv,
+    validate_csv_columns,
+)
+from ol_openedx_uai_content_customization.modulestore_utils import (
+    create_content_block,
+    delete_course_sections,
+    get_or_clone_course_in_modulestore,
+    save_video_block_with_edx_video_id,
+)
+
+log = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    """Generate industry/length-specific UAI courses using Open edX modulestore APIs."""
+
+    help = (
+        "Generate industry and length-specific UAI courses by reading two CSV files "
+        "and creating courses in the CMS modulestore."
+    )
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--processed-videos-csv",
+            required=True,
+            help="Path to the processed video metadata CSV file.",
+        )
+        parser.add_argument(
+            "--edx-videos-csv",
+            required=True,
+            help="Path to the Open edX videos CSV file (exported from Studio/OVS).",
+        )
+        parser.add_argument(
+            "--username",
+            default="studio_worker",
+            help="Username of the platform user under whose authority courses are"
+            " created (default: studio_worker).",
+        )
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Log what would be created without writing to the modulestore.",
+        )
+
+    def handle(self, *args, **options):  # noqa: ARG002, PLR0915
+        processed_videos_csv = options["processed_videos_csv"]
+        edx_videos_csv = options["edx_videos_csv"]
+        username = options["username"]
+        dry_run = options["dry_run"]
+
+        if dry_run:
+            self.stdout.write(
+                self.style.WARNING("DRY RUN — no changes will be written.")
+            )
+
+        User = get_user_model()
+        try:
+            user = User.objects.get(username=username)
+        except User.DoesNotExist:
+            msg = f"No user found with username {username!r}."
+            raise CommandError(msg)  # noqa: B904
+        processed_video_rows, processed_video_fieldnames = parse_csv(
+            processed_videos_csv
+        )
+        edx_video_rows, edx_video_fieldnames = parse_csv(edx_videos_csv)
+
+        try:
+            validate_csv_columns(
+                processed_video_fieldnames,
+                REQUIRED_CUSTOMIZED_CSV_COLS,
+                "processed videos CSV",
+            )
+            validate_csv_columns(
+                edx_video_fieldnames,
+                REQUIRED_ASSET_CSV_COLS,
+                "edX videos CSV",
+            )
+        except ValueError as exc:
+            raise CommandError(str(exc)) from exc
+
+        video_id_map = build_video_id_map(edx_video_rows)
+
+        self.stdout.write(
+            f"Loaded {len(processed_video_rows)} processed video rows "
+            f"and {len(edx_video_rows)} edX video rows."
+        )
+
+        course_groups = group_videos_by_course(processed_video_rows)
+        self.stdout.write(f"Found {len(course_groups)} course variant(s) to create.")
+
+        self._validate_source_course_keys(course_groups)
+
+        created, skipped = 0, 0
+
+        for (orig_key, industry, duration), videos in course_groups.items():
+            source_key = CourseKey.from_string(orig_key)  # safe — already validated
+            try:
+                new_course_key = build_new_course_key(orig_key, industry, duration)
+            except ValueError as exc:
+                self.stdout.write(
+                    self.style.WARNING(
+                        f"  Skipping [{industry}, {duration}] from {orig_key}: {exc}"
+                    )
+                )
+                skipped += 1
+                continue
+
+            display_name = self._build_display_name(videos)
+
+            self.stdout.write(
+                f"\n-> {orig_key} [{industry}, {duration}] -> {new_course_key}"
+            )
+            self.stdout.write(f"  Display name : {display_name}")
+            self.stdout.write(f"  Videos       : {len(videos)}")
+
+            if dry_run:
+                for video in videos:
+                    vid_file = video[CSV_COL_VIDEO_FILE_NAME]
+                    vid_title = video[CSV_COL_VIDEO_TITLE]
+                    mapped_id = video_id_map.get(vid_file, "<NOT FOUND>")
+                    self.stdout.write(f"    - {vid_title} ({vid_file} -> {mapped_id})")
+                skipped += 1
+                continue
+
+            try:
+                self._create_course(
+                    source_key,
+                    new_course_key,
+                    display_name,
+                    videos,
+                    video_id_map,
+                    user,
+                )
+                created += 1
+            except DuplicateCourseError:
+                self.stdout.write(
+                    self.style.WARNING(
+                        f"  Course {new_course_key} already exists — skipping."
+                    )
+                )
+                skipped += 1
+            except Exception as exc:
+                log.exception("Failed to create course %s", new_course_key)
+                msg = f"Failed to create course {new_course_key}: {exc}"
+                raise CommandError(msg) from exc
+
+        self.stdout.write(
+            self.style.SUCCESS(f"\nDone. Created: {created}  Skipped: {skipped}")
+        )
+
+    def _build_display_name(self, videos):
+        """
+        Return the module name from the first video row as the course display name.
+
+        Falls back to "UAI Course" when no module name is available.
+        """
+        return (
+            videos[0].get(CSV_COL_MODULE_NAME, "").strip()
+            if videos
+            else "UAI Short Course"
+        )
+
+    def _validate_source_course_keys(self, course_groups):
+        """
+        Raise CommandError if any source course key in the CSV is invalid or absent.
+
+        Collects all failures before raising so the operator sees every problem
+        in a single run rather than one at a time.
+
+        Args:
+            course_groups: dict keyed by (orig_key, industry, duration).
+        """
+        store = modulestore()
+        unique_keys = sorted({orig_key for orig_key, _, _ in course_groups})
+        missing = []
+        for key_str in unique_keys:
+            try:
+                parsed = CourseKey.from_string(key_str)
+            except InvalidKeyError:
+                missing.append(f"{key_str!r} (invalid course key format)")
+                continue
+            if not store.has_course(parsed):
+                missing.append(key_str)
+        if missing:
+            missing_list = "\n".join(f"  - {k}" for k in missing)
+            msg = f"Source course(s) not found in the modulestore:\n{missing_list}"
+            raise CommandError(msg)
+
+    def _create_course(  # noqa: PLR0913
+        self, source_key, course_key_str, display_name, videos, video_id_map, user
+    ):
+        """
+        Clone the source course, strip its sections, then populate with UAI content.
+
+        The clone inherits all course settings (grading, certificates, pacing,
+        advanced settings) from the source.  After cloning, every existing
+        section is removed and a fresh "Lectures" section is built from the CSV
+        data with one subsection → unit → video block per video row.
+
+        All modulestore writes are wrapped in bulk_operations for performance.
+        """
+        parsed_key = CourseKey.from_string(course_key_str)
+        user_id = user.id
+        store = modulestore()
+        with store.bulk_operations(parsed_key):
+            course = get_or_clone_course_in_modulestore(
+                source_key,
+                parsed_key.org,
+                parsed_key.course,
+                parsed_key.run,
+                display_name,
+                user_id,
+            )
+            delete_course_sections(course, user_id)
+            section = create_content_block(
+                course,
+                BLOCK_TYPE_CHAPTER,
+                LECTURES_SECTION_DISPLAY_NAME,
+                user_id,
+            )
+
+            unmapped = []
+
+            for video in videos:
+                title = video[CSV_COL_VIDEO_TITLE]
+                vid_file = video[CSV_COL_VIDEO_FILE_NAME]
+                edx_video_id = video_id_map.get(vid_file)
+
+                if not edx_video_id:
+                    log.warning(
+                        "No Open edX video ID found for file '%s'"
+                        " (title: '%s') - skipping.",
+                        vid_file,
+                        title,
+                    )
+                    unmapped.append(vid_file)
+                    continue
+
+                subsection = create_content_block(
+                    section,
+                    BLOCK_TYPE_SEQUENTIAL,
+                    title,
+                    user_id,
+                )
+                unit = create_content_block(
+                    subsection,
+                    BLOCK_TYPE_VERTICAL,
+                    title,
+                    user_id,
+                )
+                video_block = create_content_block(
+                    unit,
+                    BLOCK_TYPE_VIDEO,
+                    title,
+                    user_id,
+                )
+                save_video_block_with_edx_video_id(video_block, user, edx_video_id)
+
+        store.publish(course.location, user_id)
+        if unmapped:
+            self.stdout.write(
+                self.style.WARNING(
+                    f"  Warning: {len(unmapped)} video file(s) had no"
+                    f" matching Open edX video ID: " + ", ".join(unmapped)
+                )
+            )

ol_openedx_uai_content_customization-0.1.0/ol_openedx_uai_content_customization/modulestore_utils.py

@@ -0,0 +1,171 @@
+"""
+Modulestore wrappers for creating UAI course content.
+
+All functions that write to the modulestore live here so that the management
+command stays thin and these helpers can be mocked cleanly in tests.
+"""
+
+import logging
+
+from xmodule.modulestore import ModuleStoreEnum
+from xmodule.modulestore.django import modulestore
+from xmodule.modulestore.inheritance import own_metadata
+
+from ol_openedx_uai_content_customization.constants import (
+    BLOCK_TYPE_CHAPTER,
+    BLOCK_TYPE_VIDEO,
+)
+
+log = logging.getLogger(__name__)
+
+
+def get_or_clone_course_in_modulestore(  # noqa: PLR0913
+    source_course_key, dest_org, dest_number, dest_run, display_name, user_id
+):
+    """
+    Get or clone a course in the modulestore.
+
+    If the destination course already exists, it is returned as-is.
+    Otherwise, a new course is cloned from the source course key with
+    the given destination parameters.
+    """
+    store = modulestore()
+    with store.default_store(ModuleStoreEnum.Type.split):
+        dest_course_key = store.make_course_key(dest_org, dest_number, dest_run)
+
+        # if the course already exists, we assume it was cloned previously
+        # and return it rather than erroring out. This allows the cloning
+        # operation to be idempotent and the management command to be
+        # re-runnable without manual cleanup.
+        if store.has_course(dest_course_key):
+            return store.get_course(dest_course_key)
+
+        course = store.clone_course(
+            source_course_key,
+            dest_course_key,
+            user_id,
+            fields={"display_name": display_name},
+        )
+    log.info(
+        "Cloned course %s -> course-v1:%s+%s+%s (%s)",
+        source_course_key,
+        dest_org,
+        dest_number,
+        dest_run,
+        display_name,
+    )
+    return course
+
+
+def delete_course_sections(course, user_id):
+    """
+    Delete all top-level sections (chapters) from the course.
+
+    Called immediately after cloning the base course so the new course starts
+    empty before UAI-specific content is added.  In the Split modulestore the
+    course structure is versioned: old sections become part of the version
+    history and are not surfaced once the new sections are published.
+
+    Args:
+        course: Course XBlock descriptor.
+        user_id: ID of the user performing the operation.
+
+    Returns:
+        Number of sections deleted.
+    """
+    store = modulestore()
+    sections = store.get_items(
+        course.id,
+        qualifiers={"category": BLOCK_TYPE_CHAPTER},
+    )
+    for section in sections:
+        store.delete_item(section.location, user_id)
+        log.debug("Deleted cloned section %s", section.location)
+    count = len(sections)
+    log.info("Deleted %d cloned section(s) from course %s", count, course.id)
+    return count
+
+
+def create_content_block(parent, block_type, display_name, user_id, **extra_fields):
+    """
+    Add a content block under the given parent XBlock.
+
+    Args:
+        parent: Parent XBlock descriptor that will own the new child.
+        block_type: XBlock category to create (e.g. chapter, sequential,
+            vertical, video).
+        display_name: Display name for the created block.
+        user_id: ID of the user performing the operation.
+        **extra_fields: Optional additional fields for block creation.
+
+    Returns:
+        The newly-created child XBlock descriptor.
+    """
+    store = modulestore()
+    fields = {"display_name": display_name, **extra_fields}
+    block = store.create_child(
+        user_id,
+        parent.location,
+        block_type,
+        fields=fields,
+    )
+
+    if block_type == BLOCK_TYPE_VIDEO and "edx_video_id" in extra_fields:
+        log.debug(
+            "Created %s block '%s' (edx_video_id=%s) under %s",
+            block_type,
+            display_name,
+            extra_fields["edx_video_id"],
+            parent.location,
+        )
+    else:
+        log.debug(
+            "Created %s block '%s' under %s",
+            block_type,
+            display_name,
+            parent.location,
+        )
+
+    return block
+
+
+def save_video_block_with_edx_video_id(video_block, user, edx_video_id):
+    """
+    Save a newly-created video block using the CMS callback pipeline.
+
+    This mirrors Studio's save flow and normalizes legacy fallback fields so
+    an explicit ``edx_video_id`` is used as the canonical playback source.
+
+    Args:
+        video_block: Video XBlock descriptor created in modulestore.
+        user: Django user object performing the operation.
+        edx_video_id: VAL/Open edX video identifier to bind to the block.
+
+    Returns:
+        Updated video block descriptor returned by save callback utility.
+    """
+    from cms.djangoapps.contentstore.xblock_storage_handlers.view_handlers import (  # noqa: PLC0415
+        save_xblock_with_callback,
+    )
+
+    old_metadata = own_metadata(video_block)
+    video_block.edx_video_id = edx_video_id.strip()
+
+    # Keep legacy fallback metadata empty to avoid default placeholder IDs.
+    for field_name, value in (
+        ("youtube_id_0_75", ""),
+        ("youtube_id_1_0", ""),
+        ("youtube_id_1_25", ""),
+        ("youtube_id_1_5", ""),
+        ("sub", ""),
+        ("source", ""),
+        ("html5_sources", []),
+    ):
+        if hasattr(video_block, field_name):
+            setattr(video_block, field_name, value)
+
+    return save_xblock_with_callback(
+        video_block,
+        user,
+        old_metadata=old_metadata,
+    )

ol_openedx_uai_content_customization-0.1.0/ol_openedx_uai_content_customization/settings/common.py

@@ -0,0 +1,5 @@
+"""Common settings for the ol-openedx-uai-content-customization plugin."""
+
+
+def plugin_settings(_settings):
+    """Configure common settings for the UAI content customization plugin."""

ol_openedx_uai_content_customization-0.1.0/ol_openedx_uai_content_customization/settings/production.py

@@ -0,0 +1,5 @@
+"""Production settings for the ol-openedx-uai-content-customization plugin."""
+
+
+def plugin_settings(_settings):
+    """Configure production settings for the UAI content customization plugin."""

ol_openedx_uai_content_customization-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "ol-openedx-uai-content-customization"
+version = "0.1.0"
+description = "An Open edX plugin to generate industry/length-specific UAI custom courses from video CSV data."
+authors = [
+  {name = "MIT Office of Digital Learning"}
+]
+license = "BSD-3-Clause"
+readme = "README.rst"
+requires-python = ">=3.11"
+dependencies = [
+  "Django>=4.0",
+  "edx-django-utils>4.0.0",
+  "edx-opaque-keys",
+]
+
+[project.entry-points."cms.djangoapp"]
+ol_openedx_uai_content_customization = "ol_openedx_uai_content_customization.apps:OLOpenEdxUaiContentCustomizationConfig"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["ol_openedx_uai_content_customization"]
+include = [
+  "ol_openedx_uai_content_customization/**/*.py",
+]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "ol_openedx_uai_content_customization/**/*",
+  "README.rst",
+  "pyproject.toml",
+]