feat: publish Perseus alongside QTI for derivable nodes

recurse_nodes emits both the QTI package and a Perseus archive when a
node has native QTI items and every item is Perseus-expressible; QTI only
otherwise, so a node containing any non-expressible interaction never
ships a partial or invalid Perseus. The expressible-types gate is sourced
from PerseusExerciseGenerator.TEMPLATE_MAP so it can't drift from what the
generator can render, and the stale-preset cleanup is generalized to diff
against the full generator list rather than a single generator.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: rtibblesbot

contentcuration/contentcuration/tests/test_exportchannel.py

@@ -4,6 +4,7 @@
 import string
 import tempfile
 import uuid
+import zipfile
 from unittest import mock
 
 import pytest
@@ -35,6 +36,7 @@
 from .testdata import slideshow
 from .testdata import thumbnail_bytes
 from .testdata import tree
+from .utils.qti.test_validation import _item_xml
 from .utils.qti.test_validation import VALID_CHOICE_ITEM
 from .utils.restricted_filesystemstorage import RestrictedFileSystemStorage
 from contentcuration import models as cc
@@ -56,6 +58,24 @@
 
 pytestmark = pytest.mark.django_db
 
+# A schema-valid native QTI item whose single interaction (order) Perseus cannot
+# express, so a node containing it must publish QTI only.
+UNSUPPORTED_QTI_ITEM = _item_xml(
+    "item_unsupported",
+    "Unsupported Item",
+    '<qti-response-declaration identifier="RESPONSE" cardinality="ordered" base-type="identifier">'
+    "<qti-correct-response>"
+    "<qti-value>choice_0</qti-value>"
+    "<qti-value>choice_1</qti-value>"
+    "</qti-correct-response>"
+    "</qti-response-declaration>",
+    '<qti-order-interaction response-identifier="RESPONSE">'
+    "<qti-prompt>Put these in order.</qti-prompt>"
+    '<qti-simple-choice identifier="choice_0" fixed="false">First</qti-simple-choice>'
+    '<qti-simple-choice identifier="choice_1" fixed="false">Second</qti-simple-choice>'
+    "</qti-order-interaction>",
+)
+
 
 def description():
     return "".join(random.sample(string.printable, 20))
@@ -282,6 +302,29 @@ def setUp(self):
             randomize=False,
         )
 
+        # Native QTI item whose interaction Perseus cannot express -> QTI only
+        native_qti_unsupported_exercise = create_node(
+            {
+                "kind_id": "exercise",
+                "title": "Native QTI Unsupported Exercise",
+                "extra_fields": qti_extra_fields,
+            }
+        )
+        native_qti_unsupported_exercise.complete = True
+        native_qti_unsupported_exercise.parent = current_exercise.parent
+        native_qti_unsupported_exercise.save()
+        cc.AssessmentItem.objects.create(
+            contentnode=native_qti_unsupported_exercise,
+            assessment_id=uuid.uuid4().hex,
+            type=exercises.QTI,
+            question="",
+            answers="[]",
+            hints="[]",
+            raw_data=UNSUPPORTED_QTI_ITEM,
+            order=1,
+            randomize=False,
+        )
+
         # Only legacy structured-field items, no perseus_question -> must now route to QTI (was Perseus)
         legacy_no_perseus_exercise = create_node(
             {
@@ -779,8 +822,36 @@ def test_qti_exercise_generates_qti_archive(self):
             "QTI file should be a zip archive",
         )
 
-    def test_native_qti_item_routes_to_qti_packaging(self):
+    def test_native_qti_choice_item_publishes_both_archives(self):
+        node = cc.ContentNode.objects.get(title="Native QTI Exercise")
+        self.assertTrue(node.files.filter(preset_id=format_presets.QTI_ZIP).exists())
+        self.assertTrue(node.files.filter(preset_id=format_presets.EXERCISE).exists())
+
+    def test_native_qti_perseus_ids_match_assessment_metadata(self):
+        """The derived Perseus item JSON filenames must equal the ids recorded
+        in the published node's ``AssessmentMetaData.assessment_item_ids`` (the
+        QTI manifest ``K``-ids), so older Kolibri resolves the derived items."""
         node = cc.ContentNode.objects.get(title="Native QTI Exercise")
+        exercise_file = node.files.get(preset_id=format_presets.EXERCISE)
+        with exercise_file.file_on_disk.open("rb") as file_handle:
+            item_stems = {
+                name[: -len(".json")]
+                for name in zipfile.ZipFile(file_handle).namelist()
+                if name.endswith(".json") and name != "exercise.json"
+            }
+
+        published_node = kolibri_models.ContentNode.objects.get(
+            title="Native QTI Exercise"
+        )
+        assessment_item_ids = set(
+            published_node.assessmentmetadata.first().assessment_item_ids
+        )
+
+        self.assertTrue(item_stems)
+        self.assertEqual(item_stems, assessment_item_ids)
+
+    def test_native_qti_unsupported_interaction_publishes_qti_only(self):
+        node = cc.ContentNode.objects.get(title="Native QTI Unsupported Exercise")
         self.assertTrue(node.files.filter(preset_id=format_presets.QTI_ZIP).exists())
         self.assertFalse(node.files.filter(preset_id=format_presets.EXERCISE).exists())
 

contentcuration/contentcuration/utils/publish.py

@@ -50,6 +50,7 @@
 from contentcuration.utils.assessment.qti.imsmanifest import (
     get_assessment_ids_from_manifest,
 )
+from contentcuration.utils.assessment.qti.perseus_derive import is_perseus_derivable
 from contentcuration.utils.cache import delete_public_channel_cache_keys
 from contentcuration.utils.files import create_thumbnail_from_base64
 from contentcuration.utils.files import get_thumbnail_encoding
@@ -249,6 +250,27 @@ def assign_license_to_contentcuration_nodes(channel, license):
 ]
 
 
+# Legacy structured-field item types Perseus can render, sourced from the
+# generator's own template map so the two never drift. ``perseus_question`` is
+# excluded: it takes the dedicated Perseus branch, never the derivation gate.
+PERSEUS_EXPRESSIBLE_LEGACY_TYPES = frozenset(PerseusExerciseGenerator.TEMPLATE_MAP) - {
+    exercises.PERSEUS_QUESTION
+}
+
+
+def _node_is_perseus_derivable(node):
+    """True iff the node has >=1 native QTI item and every item is Perseus-expressible."""
+    has_native_qti = False
+    for item in node.assessment_items.all():
+        if item.type == exercises.QTI:
+            has_native_qti = True
+            if not is_perseus_derivable(item.raw_data):
+                return False
+        elif item.type not in PERSEUS_EXPRESSIBLE_LEGACY_TYPES:
+            return False
+    return has_native_qti
+
+
 def has_assessments(node):
     """Check if a node should have its assessment items published.
 
@@ -367,36 +389,40 @@ def recurse_nodes(self, node, inherited_fields):  # noqa C901
                     t == exercises.PERSEUS_QUESTION
                     for t in exercise_data["assessment_mapping"].values()
                 )
-                generator_class = (
-                    PerseusExerciseGenerator
-                    if any_perseus_question
-                    else QTIExerciseGenerator
-                )
-
-                # If this exercise previously had a file generated by a different
-                # generator, make sure we clean it up here.
+                if any_perseus_question:
+                    generator_classes = [PerseusExerciseGenerator]
+                else:
+                    generator_classes = [QTIExerciseGenerator]
+                    # Also emit a Perseus archive when every item is a native QTI
+                    # interaction Perseus can express, so older Kolibri renders it.
+                    if _node_is_perseus_derivable(node):
+                        generator_classes.append(PerseusExerciseGenerator)
+
+                # If this exercise previously had files generated by generators no
+                # longer in use, make sure we clean them up here.
+                target_presets = {g.preset for g in generator_classes}
                 stale_presets = {
                     PerseusExerciseGenerator.preset,
                     QTIExerciseGenerator.preset,
-                } - {generator_class.preset}
-
-                # Remove archives produced by the previously-used generator
+                } - target_presets
                 node.files.filter(preset_id__in=stale_presets).delete()
 
-                if (
-                    self.force_exercises
-                    or node.changed
-                    or not node.files.filter(preset_id=generator_class.preset).exists()
-                ):
-
-                    generator = generator_class(
-                        node,
-                        exercise_data,
-                        self.channel_id,
-                        self.default_language.lang_code,
-                        user_id=self.user_id,
-                    )
-                    generator.create_exercise_archive()
+                for generator_class in generator_classes:
+                    if (
+                        self.force_exercises
+                        or node.changed
+                        or not node.files.filter(
+                            preset_id=generator_class.preset
+                        ).exists()
+                    ):
+                        generator = generator_class(
+                            node,
+                            exercise_data,
+                            self.channel_id,
+                            self.default_language.lang_code,
+                            user_id=self.user_id,
+                        )
+                        generator.create_exercise_archive()
 
                 # Only create assessment metadata for exercises, not UNIT topics
                 # UNIT topics store their assessment config in options/completion_criteria