Publish mixed Perseus + native QTI nodes as one QTI package

Route a node holding both raw Perseus and native QTI questions to
QTIExerciseGenerator alone (one QTI package, no separate Perseus archive),
capturing the mixed fact as qti_embeds_perseus during generator selection.
Thread that flag into create_associated_file_objects to OR the exercise bit
into the QTI file's included_presets (qti | exercise), so the flag is grounded
in the same routing decision that embeds the Perseus custom interactions and
cannot diverge from the packaged contents. Tests cover the routing, the
included_presets bit, and the end-to-end mixed package contents.

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

Author: rtibblesbot

contentcuration/contentcuration/tests/test_exportchannel.py

@@ -377,6 +377,42 @@ def setUp(self):
             randomize=False,
         )
 
+        # A node mixing a native QTI item with a raw perseus_question item ->
+        # must route to a single QTI package (Perseus embedded as custom
+        # interactions), not a separate Perseus archive.
+        mixed_perseus_qti_exercise = create_node(
+            {
+                "kind_id": "exercise",
+                "title": "Perseus + Native QTI Mixed Exercise",
+                "extra_fields": qti_extra_fields,
+            }
+        )
+        mixed_perseus_qti_exercise.complete = True
+        mixed_perseus_qti_exercise.parent = current_exercise.parent
+        mixed_perseus_qti_exercise.save()
+        cc.AssessmentItem.objects.create(
+            contentnode=mixed_perseus_qti_exercise,
+            assessment_id=uuid.uuid4().hex,
+            type=exercises.QTI,
+            question="",
+            answers="[]",
+            hints="[]",
+            raw_data=VALID_CHOICE_ITEM,
+            order=1,
+            randomize=False,
+        )
+        cc.AssessmentItem.objects.create(
+            contentnode=mixed_perseus_qti_exercise,
+            assessment_id=uuid.uuid4().hex,
+            type=exercises.PERSEUS_QUESTION,
+            question="",
+            answers="[]",
+            hints="[]",
+            raw_data="{}",
+            order=2,
+            randomize=False,
+        )
+
         first_topic = self.content_channel.main_tree.get_descendants().first()
 
         # Add a publishable topic to ensure it does not inherit but that its children do
@@ -671,12 +707,19 @@ def test_localfile_large_file_size_bigint(self):
         self.assertIsNone(local_file.file_size)
 
     def test_file_included_presets_renderable(self):
-        # Every non-supplementary (renderable) exported file carries its own preset bit.
+        # Every non-supplementary (renderable) exported file carries its own
+        # preset bit. A mixed Perseus + native QTI package additionally sets the
+        # exercise bit (see test_mixed_qti_file_included_presets); no other file
+        # is augmented.
         files = kolibri_models.File.objects.filter(supplementary=False)
         assert files.count() > 0
+        exercise_bit = 2 ** RENDERABLE_PRESETS_ORDER.index(format_presets.EXERCISE)
         for file in files:
-            expected = 2 ** RENDERABLE_PRESETS_ORDER.index(file.preset)
-            self.assertEqual(file.included_presets, expected)
+            own_bit = 2 ** RENDERABLE_PRESETS_ORDER.index(file.preset)
+            if file.preset == format_presets.QTI_ZIP:
+                self.assertIn(file.included_presets, (own_bit, own_bit | exercise_bit))
+            else:
+                self.assertEqual(file.included_presets, own_bit)
 
     def test_file_included_presets_supplementary_null(self):
         # Supplementary files (e.g. thumbnails) leave included_presets NULL.
@@ -685,6 +728,31 @@ def test_file_included_presets_supplementary_null(self):
         for file in files:
             self.assertIsNone(file.included_presets)
 
+    def test_mixed_qti_file_included_presets(self):
+        # A mixed Perseus + native QTI package embeds raw Perseus questions as
+        # custom interactions, so its qti File must also flag the exercise
+        # (Perseus) renderer via included_presets = qti | exercise.
+        qti_bit = 2 ** RENDERABLE_PRESETS_ORDER.index(format_presets.QTI_ZIP)
+        exercise_bit = 2 ** RENDERABLE_PRESETS_ORDER.index(format_presets.EXERCISE)
+
+        mixed_node = kolibri_models.ContentNode.objects.get(
+            title="Perseus + Native QTI Mixed Exercise"
+        )
+        mixed_qti_file = kolibri_models.File.objects.get(
+            contentnode=mixed_node, preset=format_presets.QTI_ZIP
+        )
+        self.assertEqual(mixed_qti_file.included_presets, qti_bit | exercise_bit)
+
+        # A native-QTI-only node embeds no Perseus questions, so its qti File
+        # keeps only the qti bit (guards against over-tagging).
+        native_node = kolibri_models.ContentNode.objects.get(
+            title="Native QTI Exercise"
+        )
+        native_qti_file = kolibri_models.File.objects.get(
+            contentnode=native_node, preset=format_presets.QTI_ZIP
+        )
+        self.assertEqual(native_qti_file.included_presets, qti_bit)
+
     def test_channel_icon_encoding(self):
         self.assertIsNotNone(self.content_channel.icon_encoding)
 
@@ -932,6 +1000,11 @@ def test_perseus_question_item_routes_to_perseus_packaging(self):
         self.assertTrue(node.files.filter(preset_id=format_presets.EXERCISE).exists())
         self.assertFalse(node.files.filter(preset_id=format_presets.QTI_ZIP).exists())
 
+    def test_mixed_perseus_and_native_qti_routes_to_qti(self):
+        node = cc.ContentNode.objects.get(title="Perseus + Native QTI Mixed Exercise")
+        self.assertTrue(node.files.filter(preset_id=format_presets.QTI_ZIP).exists())
+        self.assertFalse(node.files.filter(preset_id=format_presets.EXERCISE).exists())
+
     def test_qti_archive_contains_manifest_and_assessment_ids(self):
 
         published_qti_exercise = kolibri_models.ContentNode.objects.get(

contentcuration/contentcuration/utils/publish.py

@@ -386,13 +386,26 @@ def recurse_nodes(self, node, inherited_fields):  # noqa C901
                 metadata,
             )
 
+            # A mixed node's QTI package embeds its raw Perseus questions as
+            # custom interactions, so that file also needs the Perseus/exercise
+            # renderer. Discovered here alongside generator selection and carried
+            # to create_associated_file_objects, so the included_presets bit is
+            # grounded in the same decision that drives the embedding.
+            qti_embeds_perseus = False
+
             if has_assessments(node):
                 exercise_data = process_assessment_metadata(node)
+                mapping_values = exercise_data["assessment_mapping"].values()
                 any_perseus_question = any(
-                    t == exercises.PERSEUS_QUESTION
-                    for t in exercise_data["assessment_mapping"].values()
+                    t == exercises.PERSEUS_QUESTION for t in mapping_values
                 )
-                if any_perseus_question:
+                any_native_qti = any(t == exercises.QTI for t in mapping_values)
+                qti_embeds_perseus = any_perseus_question and any_native_qti
+                if qti_embeds_perseus:
+                    # Mixed node: one QTI package, raw Perseus embedded as
+                    # custom interactions.
+                    generator_classes = [QTIExerciseGenerator]
+                elif any_perseus_question:
                     generator_classes = [PerseusExerciseGenerator]
                 else:
                     generator_classes = [QTIExerciseGenerator]
@@ -439,7 +452,7 @@ def recurse_nodes(self, node, inherited_fields):  # noqa C901
             if node.kind_id == content_kinds.TOPIC:
                 for child in node.children.all():
                     self.recurse_nodes(child, metadata)
-            create_associated_file_objects(kolibrinode, node)
+            create_associated_file_objects(kolibrinode, node, qti_embeds_perseus)
             map_tags_to_node(kolibrinode, node)
 
         self._node_completed()
@@ -669,7 +682,7 @@ def create_associated_thumbnail(ccnode, ccfilemodel):
     )
 
 
-def create_associated_file_objects(kolibrinode, ccnode):
+def create_associated_file_objects(kolibrinode, ccnode, qti_embeds_perseus=False):
     logging.debug(
         "Creating LocalFile and File objects for Node {}".format(kolibrinode.id)
     )
@@ -722,6 +735,17 @@ def create_associated_file_objects(kolibrinode, ccnode):
                     ccfilemodel.pk,
                 )
 
+        # EXERCISE bit: a mixed QTI package embeds raw Perseus custom
+        # interactions, so it also needs the Perseus renderer (see recurse_nodes).
+        if (
+            included_presets is not None
+            and preset.pk == format_presets.QTI_ZIP
+            and qti_embeds_perseus
+        ):
+            included_presets |= 2 ** RENDERABLE_PRESETS_ORDER.index(
+                format_presets.EXERCISE
+            )
+
         kolibrimodels.File.objects.create(
             pk=ccfilemodel.pk,
             checksum=ccfilemodel.checksum,