canvaslms 5.3__py3-none-any.whl → 5.4__py3-none-any.whl

canvaslms/cli/quizzes.nw

@@ -1,46 +1,148 @@
 \chapter{The \texttt{quizzes} command}
 \label{quizzes-command}
 \chapterprecis{%
-  This chapter was originally authored by GitHub Copilot and minimally reviewed 
+  This chapter was originally authored by GitHub Copilot and minimally reviewed
   and revised by Daniel Bosk.
   Then later expanded on by Dan-Claude and, finally,
   revised by Daniel Bosk.%
 }
 
-This chapter provides the subcommand [[quizzes]], which provides access to
-Canvas quiz and survey data.
+This chapter provides the subcommand [[quizzes]], which provides comprehensive
+access to Canvas quiz and survey functionality.  The command supports both
+Classic Quizzes (the original Canvas quiz system) and New Quizzes (Quizzes.Next).
 
-The [[quizzes]] command has two subcommands:
-\begin{itemize}
-\item [[list]] lists all quizzes (including Classic Quizzes, New Quizzes, and 
-surveys) in a course.
-\item [[analyse]] summarizes quiz or survey evaluation data.
-\end{itemize}
+The [[quizzes]] command has the following subcommands:
+\begin{description}
+\item[[[list]]] Lists all quizzes in a course (Classic, New Quizzes, and surveys)
+\item[[[view]]] Displays full quiz content including questions and answers
+\item[[[analyse]]] Summarizes quiz/survey evaluation data with statistics and AI
+\item[[[create]]] Creates a new quiz from JSON (settings and optionally questions)
+\item[[[edit]]] Modifies quiz settings and instructions
+\item[[[delete]]] Removes a quiz
+\item[[[export]]] Exports a complete quiz to JSON for backup or migration
+\item[[[items]]] Manages quiz questions (list, add, edit, delete, export)
+\item[[[banks]]] Manages quiz item banks
+\end{description}
 
-The [[analyse]] subcommand supports two modes of operation:
-\begin{enumerate}
-\item Fetch quiz/survey data directly from Canvas by specifying the quiz.
-  This works reliably for Classic Quizzes and New Quizzes (Quizzes.Next).
-  The implementation uses the documented New Quiz Reports API.
-\item Read and analyze a CSV file downloaded from Canvas.
-  This is the most reliable method for both Classic and New Quizzes.
-\end{enumerate}
 
-For analysis, the command provides:
-\begin{itemize}
-\item statistical summaries for quantitative (multiple choice, rating) data,
-\item Individual responses for qualitative (free text) data,
-\item AI-generated summaries of qualitative data using the [[llm]] package.
-  % XXX and quantitative?
-\end{itemize}
+\section{Creating and Managing Quizzes}
+
+The [[quizzes]] command provides a complete workflow for quiz backup, migration,
+and duplication between courses.
+
+\subsection{The export/create workflow}
+
+The recommended workflow for duplicating or migrating quizzes is:
+\begin{minted}{bash}
+# 1. Export an existing quiz (with -I for importable format)
+canvaslms quizzes export -c "Source Course" -a "Midterm Exam" -I > midterm.json
+
+# 2. Create the quiz in another course
+canvaslms quizzes create -c "Target Course" -f midterm.json
 
+# Optionally change the title
+canvaslms quizzes create -c "Target Course" -f midterm.json --title "New Title"
+\end{minted}
+
+This workflow exports both quiz settings (title, time limit, instructions, etc.)
+and all questions in a single JSON file.
+
+\subsection{Creating quizzes from scratch}
+
+To create a new quiz from scratch:
+\begin{minted}{bash}
+# See the full JSON format with examples
+canvaslms quizzes create --example > template.json
+
+# Edit the template and create the quiz
+canvaslms quizzes create -c "My Course" -f template.json
+\end{minted}
 
-\section{Usage Examples}
+The [[--example]] flag outputs complete examples for both New Quizzes and
+Classic Quizzes, including all supported settings and question types.
+
+\subsection{Advanced New Quiz settings}
+\label{sec:advanced-quiz-settings}
+
+New Quizzes support additional settings for controlling multiple attempts and
+result visibility.  These are specified in the [[quiz_settings]] object within
+[[settings]]:
+\begin{verbatim}
+{
+  "quiz_type": "new",
+  "settings": {
+    "title": "Practice Quiz",
+    "quiz_settings": {
+      "multiple_attempts": { ... },
+      "result_view_settings": { ... }
+    }
+  }
+}
+\end{verbatim}
+
+\paragraph{Multiple attempts with waiting periods.}
+To allow students multiple attempts with a cooling period between attempts:
+\begin{verbatim}
+"multiple_attempts": {
+  "multiple_attempts_enabled": true,
+  "attempt_limit": null,
+  "score_to_keep": "latest",
+  "cooling_period": true,
+  "cooling_period_seconds": 3600
+}
+\end{verbatim}
+Here, [[attempt_limit]] of [[null]] means unlimited attempts.  The
+[[score_to_keep]] can be [[highest]] (default) or [[latest]].  Setting
+[[cooling_period]] to [[true]] requires [[cooling_period_seconds]] to specify
+the wait time (3600 seconds = 1 hour).  Using [[latest]] with a cooling period
+lets students ``build on their last result''---they see which questions they
+got wrong and can retry without losing progress.
+
+\paragraph{Controlling what students see after submission.}
+To show students their score but hide the correct answers:
+\begin{verbatim}
+"result_view_settings": {
+  "display_items": true,
+  "display_item_response": true,
+  "display_item_correct_answer": false,
+  "display_item_feedback": false,
+  "display_points_awarded": true,
+  "display_points_possible": true
+}
+\end{verbatim}
+With these settings, students see their responses and points but cannot see
+which answers were correct.  This is useful for practice quizzes where you want
+students to keep trying without revealing the answers.
+
+You can also schedule when correct answers become visible using
+[[display_correct_answer_at]] and [[hide_correct_answer_at]] with ISO 8601
+timestamps.
+
+\subsection{Adding questions separately}
+
+You can also create an empty quiz and add questions separately:
+\begin{minted}{bash}
+# Create quiz with settings only
+canvaslms quizzes create -c "My Course" --title "New Quiz" --type new
+
+# Add questions from a JSON file
+canvaslms quizzes items add -c "My Course" -a "New Quiz" -f questions.json
+
+# See question format examples
+canvaslms quizzes items add --example
+\end{minted}
+
+
+\section{Analyzing Quiz Results}
+
+The [[quizzes analyse]] command provides statistical analysis and AI-generated
+summaries of quiz and survey responses.  It supports two modes: fetching data
+directly from Canvas or analyzing a downloaded CSV file.
 
 \subsection{Analyzing a CSV file}
 
-Download the Student Analysis Report CSV manually from Canvas and analyze it 
-using this command:
+The most reliable method is to download the Student Analysis Report CSV from
+Canvas and analyze it locally:
 \begin{minted}{bash}
 canvaslms quizzes analyse --csv survey_results.csv
 \end{minted}
@@ -216,6 +318,7 @@ subcommands:
 \item[ [[add_create_command()]] ] Registers the [[quizzes create]] subcommand
 \item[ [[add_edit_command()]] ] Registers the [[quizzes edit]] subcommand
 \item[ [[add_delete_command()]] ] Registers the [[quizzes delete]] subcommand
+\item[ [[add_export_command()]] ] Registers the [[quizzes export]] subcommand
 \item[ [[add_items_command()]] ] Registers the [[quizzes items]] subcommand group
 \item[ [[add_banks_command()]] ] Registers the [[quizzes banks]] subcommand group
 \end{description}
@@ -269,6 +372,10 @@ def add_delete_command(subp):
   """Adds the quizzes delete subcommand to argparse parser subp"""
   <<add quizzes delete command to subp>>
 
+def add_export_command(subp):
+  """Adds the quizzes export subcommand to argparse parser subp"""
+  <<add quizzes export command to subp>>
+
 def add_items_command(subp):
   """Adds the quizzes items subcommand group to argparse parser subp"""
   <<add quizzes items command to subp>>
@@ -288,7 +395,8 @@ The subcommands are organized by workflow:
   content including questions (Chapter~\ref{quiz-view}).
 \item[Analysis] [[analyse]] provides statistical summaries and AI-generated
   insights for quiz/survey responses.
-\item[Management] [[create]], [[edit]], and [[delete]] handle quiz lifecycle.
+\item[Management] [[create]], [[edit]], [[delete]], and [[export]] handle quiz
+  lifecycle, including backup and migration.
 \item[Items] [[items]] and [[banks]] manage individual questions and item banks.
 \end{description}
 
@@ -308,6 +416,7 @@ add_view_command(quizzes_subp)
 add_create_command(quizzes_subp)
 add_edit_command(quizzes_subp)
 add_delete_command(quizzes_subp)
+add_export_command(quizzes_subp)
 add_items_command(quizzes_subp)
 add_banks_command(quizzes_subp)
 @
@@ -2287,55 +2396,108 @@ new quizzes.
 \label{sec:quizzes-create}
 
 The [[quizzes create]] command creates a new quiz in a course.
-Users can specify quiz settings via a JSON file or interactively.
+Users can specify quiz settings and optionally questions via a JSON file.
+The JSON format supports the complete export/create workflow, allowing users
+to export a quiz with [[quizzes export]] and create a copy with this command.
 
 <<add quizzes create command to subp>>=
 create_parser = subp.add_parser("create",
     help="Create a new quiz",
-    description="""Create a new quiz in a course. Quiz settings can be
-provided via a JSON file or entered interactively.""")
+    description="""Create a new quiz in a course from a JSON file.
+
+Use --example to see the full JSON format with all supported attributes.
+The JSON can include both quiz settings and questions, enabling a complete
+export/create workflow:
+
+  canvaslms quizzes export -c "Source Course" -a "Quiz" -I > quiz.json
+  canvaslms quizzes create -c "Target Course" -f quiz.json
+
+JSON STRUCTURE:
+  {
+    "quiz_type": "new" or "classic",
+    "settings": { ... quiz settings ... },
+    "items": [ ... ] (New Quizzes) or "questions": [ ... ] (Classic)
+  }
+
+SETTINGS FOR NEW QUIZZES (time_limit in seconds):
+  title, instructions, time_limit, allowed_attempts, shuffle_questions,
+  shuffle_answers, points_possible, due_at, unlock_at, lock_at
+
+ADVANCED SETTINGS FOR NEW QUIZZES (in settings.quiz_settings):
+  multiple_attempts: attempt_limit, score_to_keep, cooling_period_seconds
+  result_view_settings: display_item_correct_answer, display_item_feedback, etc.
+
+SETTINGS FOR CLASSIC QUIZZES (time_limit in minutes):
+  title, description, quiz_type (assignment/practice_quiz/graded_survey/survey),
+  time_limit, allowed_attempts, shuffle_questions, shuffle_answers,
+  points_possible, published, due_at, unlock_at, lock_at,
+  show_correct_answers, one_question_at_a_time, cant_go_back, access_code
+
+For question format details, see: canvaslms quizzes items add --example""")
 
 create_parser.set_defaults(func=create_command)
 
 try:
-  courses.add_course_option(create_parser, required=True)
+  courses.add_course_option(create_parser, required=False)
 except argparse.ArgumentError:
   pass
 
 create_parser.add_argument("-f", "--file",
-    help="JSON file containing quiz settings",
+    help="JSON file containing quiz settings and optionally questions",
     type=str)
 
 create_parser.add_argument("--type",
     choices=["new", "classic"],
-    default="new",
+    default=None,
     help="Quiz type: 'new' (New Quizzes) or 'classic' (Classic Quizzes). "
-         "Default: new")
+         "Auto-detected from JSON if not specified. Default: new")
 
 create_parser.add_argument("--title", "-t",
-    help="Quiz title (can also be specified in JSON file)")
+    help="Quiz title (overrides title in JSON file)")
+
+create_parser.add_argument("--example", "-E",
+    action="store_true",
+    help="Print example JSON for creating quizzes and exit")
 @
 
 
 \subsection{JSON format for quiz creation}
 
-The JSON file format follows the Canvas API structure.
-Here is an example for New Quizzes:
+The JSON file format supports two structures: a simple settings-only format
+and a full format that includes questions.
+
+\paragraph{Simple settings format.}
+For creating a quiz without questions (add questions later with
+[[quizzes items add]]):
 \begin{verbatim}
 {
   "title": "Midterm Exam",
   "instructions": "<p>Answer all questions.</p>",
   "time_limit": 3600,
-  "allowed_attempts": 2,
-  "shuffle_questions": true,
-  "shuffle_answers": true,
-  "points_possible": 100,
-  "due_at": "2025-03-15T23:59:00Z"
+  "allowed_attempts": 2
 }
 \end{verbatim}
 
-For Classic Quizzes, the format is similar but uses different field names
-(e.g., [[quiz_type]] instead of [[grading_type]]).
+\paragraph{Full format with questions.}
+For creating a complete quiz including questions (the format produced by
+[[quizzes export]]):
+\begin{verbatim}
+{
+  "quiz_type": "new",
+  "settings": {
+    "title": "Midterm Exam",
+    "instructions": "<p>Answer all questions.</p>",
+    "time_limit": 3600
+  },
+  "items": [ ... question items ... ]
+}
+\end{verbatim}
+
+The command auto-detects the format: if [[settings]] key exists, it uses the
+full format; otherwise it treats the entire JSON as settings.
+
+For Classic Quizzes, the format uses [[description]] instead of [[instructions]],
+[[time_limit]] in minutes (not seconds), and [[questions]] instead of [[items]].
 
 
 \subsection{Processing the create command}
@@ -2344,26 +2506,67 @@ The [[create_command]] function processes the create request, reading settings
 from a JSON file if provided, then calling the appropriate API based on the
 selected quiz type.
 
+When [[--example]] is provided, we print example JSON for both quiz types and
+exit immediately without requiring course or file arguments:
+\begin{minted}{bash}
+canvaslms quizzes create --example > quiz.json
+# Edit quiz.json to customize
+canvaslms quizzes create -c "My Course" -f quiz.json
+\end{minted}
+
+The command supports two JSON formats:
+\begin{enumerate}
+\item \textbf{Full format} with [[settings]] key: used by [[quizzes export]]
+\item \textbf{Simple format} without [[settings]]: treats entire JSON as settings
+\end{enumerate}
+
+If the JSON contains [[items]] (New Quizzes) or [[questions]] (Classic Quizzes),
+those are added after the quiz is created.
+
 <<functions>>=
 def create_command(config, canvas, args):
   """Creates a new quiz in a course"""
+  # Handle --example flag first (doesn't require course/file)
+  if getattr(args, 'example', False):
+    print_full_quiz_example_json()
+    return
+
+  # Validate required arguments when not using --example
+  if not getattr(args, 'course', None):
+    canvaslms.cli.err(1, "Please specify -c/--course or use --example")
+  if not getattr(args, 'file', None) and not getattr(args, 'title', None):
+    canvaslms.cli.err(1, "Please specify -f/--file or --title or use --example")
+
   # Get the course
   course_list = courses.process_course_option(canvas, args)
   if len(course_list) != 1:
     canvaslms.cli.err(1, "Please specify exactly one course for quiz creation")
   course = course_list[0]
 
-  # Read quiz settings from file or use defaults
-  quiz_params = {}
+  # Read quiz data from file or use defaults
+  quiz_data = {}
   if args.file:
     try:
       with open(args.file, 'r', encoding='utf-8') as f:
-        quiz_params = json.load(f)
+        quiz_data = json.load(f)
     except FileNotFoundError:
       canvaslms.cli.err(1, f"File not found: {args.file}")
     except json.JSONDecodeError as e:
       canvaslms.cli.err(1, f"Invalid JSON in {args.file}: {e}")
 
+  # Determine quiz type from args or JSON
+  quiz_type = args.type
+  if quiz_type is None:
+    quiz_type = quiz_data.get('quiz_type', 'new')
+
+  # Extract settings: support both full format (with 'settings' key) and simple format
+  if 'settings' in quiz_data:
+    quiz_params = quiz_data['settings'].copy()
+  else:
+    # Simple format: entire JSON is settings (excluding items/questions)
+    quiz_params = {k: v for k, v in quiz_data.items()
+                   if k not in ('quiz_type', 'items', 'questions')}
+
   # Command-line title overrides file
   if args.title:
     quiz_params['title'] = args.title
@@ -2372,15 +2575,35 @@ def create_command(config, canvas, args):
     canvaslms.cli.err(1, "Quiz title is required (use --title or include in JSON)")
 
   # Create the quiz
-  if args.type == "new":
-    quiz = create_new_quiz(course, canvas._Canvas__requester, quiz_params)
+  requester = canvas._Canvas__requester
+  if quiz_type == "new":
+    quiz = create_new_quiz(course, requester, quiz_params)
   else:
     quiz = create_classic_quiz(course, quiz_params)
 
-  if quiz:
-    print(f"Created quiz: {quiz_params.get('title')} (ID: {quiz.get('id', 'unknown')})")
-  else:
+  if not quiz:
     canvaslms.cli.err(1, "Failed to create quiz")
+
+  quiz_id = quiz.get('id', 'unknown')
+  print(f"Created quiz: {quiz_params.get('title')} (ID: {quiz_id})")
+
+  # Add questions if present in JSON
+  items = quiz_data.get('items', [])
+  questions = quiz_data.get('questions', [])
+
+  if quiz_type == "new" and items:
+    print(f"Adding {len(items)} question(s)...")
+    success, failed = add_new_quiz_items(course, quiz_id, requester, items)
+    print(f"Added {success} question(s), {failed} failed")
+  elif quiz_type == "classic" and questions:
+    # For classic quizzes, we need to get the quiz object to add questions
+    try:
+      quiz_obj = course.get_quiz(quiz_id)
+      print(f"Adding {len(questions)} question(s)...")
+      success, failed = add_classic_questions(quiz_obj, questions)
+      print(f"Added {success} question(s), {failed} failed")
+    except Exception as e:
+      canvaslms.cli.warn(f"Failed to add questions: {e}")
 @
 
 
@@ -2389,6 +2612,13 @@ def create_command(config, canvas, args):
 The New Quizzes API uses a different endpoint than Classic Quizzes.
 We make a direct POST request to [[/api/quiz/v1/courses/:id/quizzes]].
 
+The API expects nested parameters for [[quiz_settings]], which contains
+[[multiple_attempts]] and [[result_view_settings]] sub-structures.  We need
+to flatten these into the format the API expects:
+\begin{verbatim}
+quiz[quiz_settings][multiple_attempts][cooling_period_seconds]=3600
+\end{verbatim}
+
 <<functions>>=
 def create_new_quiz(course, requester, quiz_params):
   """Creates a New Quiz via the New Quizzes API
@@ -2396,17 +2626,15 @@ def create_new_quiz(course, requester, quiz_params):
   Args:
     course: Course object
     requester: Canvas API requester for direct HTTP calls
-    quiz_params: Dictionary of quiz parameters
+    quiz_params: Dictionary of quiz parameters, may include nested quiz_settings
 
   Returns:
     Dictionary with created quiz data, or None on failure
   """
   endpoint = f"courses/{course.id}/quizzes"
 
-  # Build the request parameters
-  params = {}
-  for key, value in quiz_params.items():
-    params[f'quiz[{key}]'] = value
+  # Build the request parameters, handling nested quiz_settings
+  params = build_new_quiz_api_params(quiz_params)
 
   try:
     response = requester.request(
@@ -2421,6 +2649,53 @@ def create_new_quiz(course, requester, quiz_params):
     return None
 @
 
+The [[build_new_quiz_api_params]] function handles the conversion of our
+nested dictionary structure into the flat parameter format required by the
+Canvas API.  It recursively processes [[quiz_settings]] and its sub-structures.
+
+<<functions>>=
+def build_new_quiz_api_params(quiz_params):
+  """Converts quiz parameters to Canvas API format
+
+  Handles nested structures like quiz_settings.multiple_attempts by
+  flattening them into the format:
+    quiz[quiz_settings][multiple_attempts][key]=value
+
+  Args:
+    quiz_params: Dictionary with quiz parameters, may include nested dicts
+
+  Returns:
+    Dictionary suitable for passing to requester.request()
+  """
+  params = {}
+
+  for key, value in quiz_params.items():
+    if value is None:
+      continue
+
+    if key == 'quiz_settings' and isinstance(value, dict):
+      # Handle nested quiz_settings structure
+      for settings_key, settings_value in value.items():
+        if settings_value is None:
+          continue
+
+        if isinstance(settings_value, dict):
+          # Handle doubly-nested structures like multiple_attempts, result_view_settings
+          for nested_key, nested_value in settings_value.items():
+            if nested_value is not None:
+              param_key = f'quiz[quiz_settings][{settings_key}][{nested_key}]'
+              params[param_key] = nested_value
+        else:
+          # Direct quiz_settings value (e.g., shuffle_answers)
+          param_key = f'quiz[quiz_settings][{settings_key}]'
+          params[param_key] = settings_value
+    else:
+      # Top-level quiz parameter
+      params[f'quiz[{key}]'] = value
+
+  return params
+@
+
 
 \subsection{Creating a Classic Quiz}
 
@@ -2605,6 +2880,103 @@ QUIZ_SCHEMA = {
 @
 
 
+\subsection{New Quiz settings schema}
+\label{sec:new-quiz-settings-schema}
+
+New Quizzes use a more sophisticated settings structure than Classic Quizzes.
+The [[quiz_settings]] object contains nested structures for multiple attempts
+and result visibility.  These settings are particularly important for formative
+assessments where students should be able to:
+\begin{itemize}
+\item Retry the quiz multiple times (with optional waiting periods)
+\item See their score but not the correct answers
+\item Build on their previous attempt rather than starting fresh
+\end{itemize}
+
+\paragraph{Multiple attempts settings.}
+The [[multiple_attempts]] structure controls how many times students can take
+the quiz and what happens between attempts:
+
+<<constants>>=
+NEW_QUIZ_MULTIPLE_ATTEMPTS_SCHEMA = {
+    'multiple_attempts_enabled': {
+        'default': False,
+        'description': 'Whether multiple attempts are allowed'
+    },
+    'attempt_limit': {
+        'default': True,
+        'description': 'Whether there is a maximum number of attempts (False = unlimited)'
+    },
+    'max_attempts': {
+        'default': 1,
+        'description': 'Maximum number of attempts (only used if attempt_limit is True)'
+    },
+    'score_to_keep': {
+        'default': 'highest',
+        'description': 'Which score to keep: average, first, highest, or latest'
+    },
+    'cooling_period': {
+        'default': False,
+        'description': 'Whether to require a waiting period between attempts'
+    },
+    'cooling_period_seconds': {
+        'default': None,
+        'description': 'Required waiting time between attempts in seconds (e.g., 3600 = 1 hour)'
+    },
+}
+@
+
+\paragraph{Result view settings.}
+The [[result_view_settings]] structure controls what students see after
+submitting the quiz.  This is crucial for formative assessments where you want
+students to know their score but not memorize correct answers:
+
+<<constants>>=
+NEW_QUIZ_RESULT_VIEW_SCHEMA = {
+    'result_view_restricted': {
+        'default': False,
+        'description': 'Whether to restrict what students see in results'
+    },
+    'display_points_awarded': {
+        'default': True,
+        'description': 'Show points earned (requires result_view_restricted=True)'
+    },
+    'display_points_possible': {
+        'default': True,
+        'description': 'Show total points possible (requires result_view_restricted=True)'
+    },
+    'display_items': {
+        'default': True,
+        'description': 'Show questions in results (requires result_view_restricted=True)'
+    },
+    'display_item_response': {
+        'default': True,
+        'description': 'Show student responses (requires display_items=True)'
+    },
+    'display_item_response_qualifier': {
+        'default': 'always',
+        'description': 'When to show responses: always, once_per_attempt, after_last_attempt, once_after_last_attempt'
+    },
+    'display_item_response_correctness': {
+        'default': True,
+        'description': 'Show whether answers are correct/incorrect (requires display_item_response=True)'
+    },
+    'display_item_response_correctness_qualifier': {
+        'default': 'always',
+        'description': 'When to show correctness: always, after_last_attempt'
+    },
+    'display_item_correct_answer': {
+        'default': True,
+        'description': 'Show the correct answer (requires display_item_response_correctness=True)'
+    },
+    'display_item_feedback': {
+        'default': True,
+        'description': 'Show item feedback (requires display_items=True)'
+    },
+}
+@
+
+
 \subsection{Command-line interface}
 
 The edit command takes course and quiz selection options. The [[-f]] option
@@ -2743,7 +3115,7 @@ def edit_quiz_interactive(quiz, requester, html_mode=False):
     'updated', 'skipped', or 'error'
   """
   # Extract current quiz attributes including instructions
-  current_attrs = extract_quiz_attributes(quiz)
+  current_attrs = extract_quiz_attributes(quiz, requester)
 
   # Get content from editor - instructions becomes the body
   result = content.get_content_from_editor(
@@ -2789,15 +3161,20 @@ the quiz object. We use [[QUIZ_SCHEMA]] to determine which attributes to
 extract, and also include [[instructions]] separately (since it becomes the
 body content, not a YAML attribute).
 
+For New Quizzes, we also extract [[quiz_settings]] which contains the
+important [[multiple_attempts]] and [[result_view_settings]] structures.
+
 <<functions>>=
-def extract_quiz_attributes(quiz):
+def extract_quiz_attributes(quiz, requester=None):
   """Extract editable attributes from a quiz object
 
   Args:
     quiz: Quiz object (New Quiz or Classic Quiz)
+    requester: Canvas API requester (needed for New Quiz settings)
 
   Returns:
     Dictionary of attributes matching QUIZ_SCHEMA, plus 'instructions'
+    and 'quiz_settings' (for New Quizzes)
   """
   attrs = {}
 
@@ -2818,12 +3195,47 @@ def extract_quiz_attributes(quiz):
   # Add instructions (not in schema, but needed for content_attr)
   if is_new_quiz(quiz):
     attrs['instructions'] = getattr(quiz, 'instructions', '') or ''
+    # Fetch quiz_settings for New Quizzes
+    if requester:
+      quiz_settings = fetch_new_quiz_settings(quiz, requester)
+      if quiz_settings:
+        attrs['quiz_settings'] = quiz_settings
   else:
     attrs['instructions'] = getattr(quiz, 'description', '') or ''
 
   return attrs
 @
 
+\paragraph{Fetching New Quiz settings.}
+The New Quizzes API returns [[quiz_settings]] as part of the quiz object,
+but the [[canvasapi]] library may not expose all fields.  We make a direct
+API call to get the complete settings.
+
+<<functions>>=
+def fetch_new_quiz_settings(quiz, requester):
+  """Fetch quiz_settings from the New Quizzes API
+
+  Args:
+    quiz: Quiz object (must have .id and .course attributes)
+    requester: Canvas API requester
+
+  Returns:
+    Dictionary with quiz_settings, or None if unavailable
+  """
+  try:
+    endpoint = f"courses/{quiz.course.id}/quizzes/{quiz.id}"
+    response = requester.request(
+      method='GET',
+      endpoint=endpoint,
+      _url="new_quizzes"
+    )
+    data = response.json()
+    return data.get('quiz_settings', None)
+  except Exception as e:
+    canvaslms.cli.warn(f"Failed to fetch New Quiz settings: {e}")
+    return None
+@
+
 
 \subsection{Applying quiz edits}
 
@@ -2880,7 +3292,7 @@ def quiz_attributes_to_api_params(attributes, is_new, html_body):
     html_body: HTML content for instructions/description
 
   Returns:
-    Dictionary suitable for Canvas API
+    Dictionary suitable for Canvas API (nested for New Quizzes)
   """
   params = {}
 
@@ -2909,11 +3321,19 @@ def quiz_attributes_to_api_params(attributes, is_new, html_body):
       continue
 
     # Skip hide_results for New Quizzes: result visibility is controlled
-    # differently in the New Quizzes interface (through the "Restrict student
-    # result view" setting), not via this API parameter.
+    # through quiz_settings.result_view_settings, not this parameter.
     if key == 'hide_results' and is_new:
       continue
 
+    # Pass through quiz_settings as-is for New Quizzes
+    if key == 'quiz_settings' and is_new:
+      params['quiz_settings'] = value
+      continue
+
+    # Skip instructions - handled separately as body
+    if key == 'instructions':
+      continue
+
     params[key] = value
 
   # Add body with appropriate field name (include even if empty to allow clearing)
@@ -2928,6 +3348,9 @@ def quiz_attributes_to_api_params(attributes, is_new, html_body):
 
 \subsection{Updating a New Quiz}
 
+Updating a New Quiz uses the same nested parameter structure as creation.
+We reuse the [[build_new_quiz_api_params]] function to handle the conversion.
+
 <<functions>>=
 def update_new_quiz(course, assignment_id, requester, quiz_params):
   """Updates a New Quiz via the New Quizzes API
@@ -2936,16 +3359,15 @@ def update_new_quiz(course, assignment_id, requester, quiz_params):
     course: Course object
     assignment_id: The quiz/assignment ID
     requester: Canvas API requester
-    quiz_params: Dictionary of parameters to update
+    quiz_params: Dictionary of parameters to update, may include nested quiz_settings
 
   Returns:
     True on success, False on failure
   """
   endpoint = f"courses/{course.id}/quizzes/{assignment_id}"
 
-  params = {}
-  for key, value in quiz_params.items():
-    params[f'quiz[{key}]'] = value
+  # Build the request parameters, handling nested quiz_settings
+  params = build_new_quiz_api_params(quiz_params)
 
   try:
     requester.request(
@@ -3104,6 +3526,213 @@ def delete_classic_quiz(quiz):
 @
 
 
+\section{The [[quizzes export]] subcommand}
+\label{sec:quizzes-export}
+
+The [[quizzes export]] command exports a complete quiz (settings and questions)
+to JSON format.  The output is designed to be directly usable with
+[[quizzes create]], enabling a complete backup and migration workflow:
+\begin{minted}{bash}
+# Export a quiz from one course
+canvaslms quizzes export -c "Source Course" -a "Midterm" -I > midterm.json
+
+# Create the same quiz in another course
+canvaslms quizzes create -c "Target Course" -f midterm.json
+\end{minted}
+
+The [[--importable]] flag produces clean JSON suitable for import, stripping
+Canvas-specific IDs and metadata that would conflict when creating a new quiz.
+
+<<add quizzes export command to subp>>=
+export_parser = subp.add_parser("export",
+    help="Export a complete quiz to JSON",
+    description="""Export a quiz (settings and questions) to JSON format.
+
+The output can be directly used with 'quizzes create' to duplicate a quiz
+in another course or create a backup.
+
+WORKFLOW EXAMPLE:
+  # Export quiz from source course
+  canvaslms quizzes export -c "Course A" -a "Quiz Name" -I > quiz.json
+
+  # Create identical quiz in target course
+  canvaslms quizzes create -c "Course B" -f quiz.json
+
+OUTPUT FORMAT:
+  {
+    "quiz_type": "new" or "classic",
+    "settings": { ... quiz settings ... },
+    "items": [ ... ] (New Quizzes) or "questions": [ ... ] (Classic)
+  }
+
+Use --importable/-I for clean JSON ready for 'quizzes create'.
+Without -I, the output includes Canvas IDs and metadata for reference.""")
+
+export_parser.set_defaults(func=export_command)
+
+try:
+  courses.add_course_option(export_parser, required=True)
+except argparse.ArgumentError:
+  pass
+
+export_parser.add_argument("-a", "--assignment",
+    required=True,
+    help="Regex matching quiz title or Canvas ID")
+
+export_parser.add_argument("--importable", "-I",
+    action="store_true",
+    help="Output clean JSON directly usable with 'quizzes create' command")
+
+export_parser.add_argument("--include-banks", "-B",
+    action="store_true",
+    default=True,
+    help="Include questions from referenced item banks (default: true)")
+
+export_parser.add_argument("--no-banks",
+    action="store_true",
+    help="Don't expand item bank references")
+@
+
+
+\subsection{Processing the export command}
+
+The export command finds the quiz, extracts its settings, and exports all
+questions.  We reuse the existing [[export_new_quiz_items]] and
+[[export_classic_questions]] functions for question export.
+
+<<functions>>=
+def export_command(config, canvas, args):
+  """Exports a complete quiz (settings + questions) to JSON"""
+  # Find the quiz
+  course_list = courses.process_course_option(canvas, args)
+  quiz_list = list(filter_quizzes(course_list, args.assignment))
+
+  if not quiz_list:
+    canvaslms.cli.err(1, f"No quiz found matching: {args.assignment}")
+
+  quiz = quiz_list[0]
+  requester = canvas._Canvas__requester
+  include_banks = args.include_banks and not args.no_banks
+  importable = getattr(args, 'importable', False)
+
+  # Build the export structure
+  if is_new_quiz(quiz):
+    export = export_full_new_quiz(quiz, requester, include_banks, importable)
+  else:
+    export = export_full_classic_quiz(quiz, importable)
+
+  # Output as JSON
+  print(json.dumps(export, indent=2, ensure_ascii=False))
+@
+
+
+\subsection{Exporting a complete New Quiz}
+
+For New Quizzes, we extract settings from the quiz object and combine them
+with the items export.  We also fetch and include [[quiz_settings]] which
+contains the important [[multiple_attempts]] and [[result_view_settings]]
+structures.  The [[--importable]] flag triggers cleaning of Canvas-specific
+metadata.
+
+<<functions>>=
+def export_full_new_quiz(quiz, requester, include_banks=True, importable=False):
+  """Exports a complete New Quiz with settings and items
+
+  Args:
+    quiz: Quiz object (must have .id and .course attributes)
+    requester: Canvas API requester
+    include_banks: If True, expand Bank/BankEntry items to include bank questions
+    importable: If True, clean output for direct import
+
+  Returns:
+    Dictionary with quiz_type, settings (including quiz_settings), and items
+  """
+  # Extract basic settings
+  settings = {
+    'title': getattr(quiz, 'title', ''),
+    'instructions': getattr(quiz, 'instructions', '') or '',
+    'time_limit': getattr(quiz, 'time_limit', None),
+    'points_possible': getattr(quiz, 'points_possible', None),
+    'due_at': getattr(quiz, 'due_at', None),
+    'unlock_at': getattr(quiz, 'unlock_at', None),
+    'lock_at': getattr(quiz, 'lock_at', None),
+  }
+
+  # Fetch quiz_settings from the API (contains multiple_attempts, result_view_settings, etc.)
+  quiz_settings = fetch_new_quiz_settings(quiz, requester)
+  if quiz_settings:
+    settings['quiz_settings'] = quiz_settings
+
+  # Get items
+  items_export = export_new_quiz_items(quiz, requester, include_banks=include_banks)
+  items = items_export.get('items', [])
+
+  # Clean for import if requested
+  if importable:
+    items_cleaned = clean_for_import({'items': items}, quiz_type='new_quiz')
+    items = items_cleaned.get('items', [])
+
+  return {
+    'quiz_type': 'new',
+    'settings': settings,
+    'items': items
+  }
+@
+
+
+\subsection{Exporting a complete Classic Quiz}
+
+For Classic Quizzes, we extract settings and questions using the canvasapi
+library's native methods.
+
+<<functions>>=
+def export_full_classic_quiz(quiz, importable=False):
+  """Exports a complete Classic Quiz with settings and questions
+
+  Args:
+    quiz: Quiz object
+    importable: If True, clean output for direct import
+
+  Returns:
+    Dictionary with quiz_type, settings, and questions
+  """
+  # Extract settings
+  settings = {
+    'title': getattr(quiz, 'title', ''),
+    'description': getattr(quiz, 'description', '') or '',
+    'quiz_type': getattr(quiz, 'quiz_type', 'assignment'),
+    'time_limit': getattr(quiz, 'time_limit', None),
+    'allowed_attempts': getattr(quiz, 'allowed_attempts', 1),
+    'shuffle_questions': getattr(quiz, 'shuffle_questions', False),
+    'shuffle_answers': getattr(quiz, 'shuffle_answers', False),
+    'points_possible': getattr(quiz, 'points_possible', None),
+    'published': getattr(quiz, 'published', False),
+    'due_at': getattr(quiz, 'due_at', None),
+    'unlock_at': getattr(quiz, 'unlock_at', None),
+    'lock_at': getattr(quiz, 'lock_at', None),
+    'show_correct_answers': getattr(quiz, 'show_correct_answers', True),
+    'one_question_at_a_time': getattr(quiz, 'one_question_at_a_time', False),
+    'cant_go_back': getattr(quiz, 'cant_go_back', False),
+    'access_code': getattr(quiz, 'access_code', None),
+  }
+
+  # Get questions
+  questions_export = export_classic_questions(quiz)
+  questions = questions_export.get('questions', [])
+
+  # Clean for import if requested
+  if importable:
+    questions_cleaned = clean_for_import({'questions': questions}, quiz_type='classic')
+    questions = questions_cleaned.get('questions', [])
+
+  return {
+    'quiz_type': 'classic',
+    'settings': settings,
+    'questions': questions
+  }
+@
+
+
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Viewing Quiz Content}
 \label{quiz-view}
@@ -4889,6 +5518,226 @@ EXAMPLE_CLASSIC_QUIZ_JSON = {
 }
 @
 
+
+\subsection{Full quiz JSON format for export/create workflow}
+
+While the examples above show the format for adding \emph{questions} to an
+existing quiz, users often need to export a complete quiz (settings and
+questions) and create a copy elsewhere.  The [[quizzes export]] and
+[[quizzes create]] commands use a unified format that combines quiz settings
+with questions.
+
+The format wraps settings in a [[settings]] object and includes a [[quiz_type]]
+field so [[quizzes create]] knows which API to use:
+\begin{description}
+\item[[[quiz_type]]] Either [[new]] (New Quizzes) or [[classic]] (Classic
+  Quizzes)
+\item[[[settings]]] Quiz settings like title, time limit, instructions
+\item[[[quiz_settings]]] For New Quizzes: nested object with [[multiple_attempts]]
+  and [[result_view_settings]] for controlling attempts and what students see
+\item[[[items]]] For New Quizzes: array of question items
+\item[[[questions]]] For Classic Quizzes: array of questions
+\end{description}
+
+\paragraph{New Quiz settings structure.}
+The [[quiz_settings]] object within [[settings]] controls advanced quiz behavior:
+\begin{description}
+\item[[[multiple_attempts]]] Controls multiple attempts, waiting periods between
+  attempts, and which score to keep (see [[NEW_QUIZ_MULTIPLE_ATTEMPTS_SCHEMA]])
+\item[[[result_view_settings]]] Controls what students see after submission,
+  including whether to show correct answers (see [[NEW_QUIZ_RESULT_VIEW_SCHEMA]])
+\item[[[shuffle_answers]]] Whether to randomize answer order
+\item[[[shuffle_questions]]] Whether to randomize question order
+\item[[[has_time_limit]]] Whether the quiz has a time limit
+\item[[[session_time_limit_in_seconds]]] Time limit in seconds
+\end{description}
+
+<<constants>>=
+EXAMPLE_FULL_NEW_QUIZ_JSON = {
+  "quiz_type": "new",
+  "settings": {
+    "title": "Example Practice Quiz",
+    "instructions": "<p>This is a practice quiz to test your knowledge. "
+                    "You can retry multiple times with a 1-hour waiting period "
+                    "between attempts. Your latest score will be kept.</p>"
+                    "<p>You will see your score but not the correct answers, "
+                    "so you can keep practicing until you get them all right!</p>",
+    "time_limit": 1800,
+    "points_possible": 20,
+    "due_at": None,
+    "unlock_at": None,
+    "lock_at": None,
+    "quiz_settings": {
+      # Randomization settings
+      "shuffle_answers": True,
+      "shuffle_questions": False,
+
+      # Time limit settings
+      "has_time_limit": True,
+      "session_time_limit_in_seconds": 1800,
+
+      # Question display settings
+      "one_at_a_time_type": "none",
+      "allow_backtracking": True,
+
+      # Calculator settings
+      "calculator_type": "none",
+
+      # Access restrictions
+      "filter_ip_address": False,
+      "filters": {},
+      "require_student_access_code": False,
+      "student_access_code": None,
+
+      # Multiple attempts settings
+      "multiple_attempts": {
+        "multiple_attempts_enabled": True,
+        "attempt_limit": False,
+        "max_attempts": None,
+        "score_to_keep": "latest",
+        "cooling_period": True,
+        "cooling_period_seconds": 3600
+      },
+
+      # Result view settings - what students see after submission
+      "result_view_settings": {
+        "result_view_restricted": True,
+        "display_points_awarded": True,
+        "display_points_possible": True,
+        "display_items": True,
+        "display_item_response": True,
+        "display_item_response_qualifier": "always",
+        "display_item_response_correctness": True,
+        "display_item_correct_answer": False,
+        "display_item_feedback": False,
+        "display_correct_answer_at": None,
+        "hide_correct_answer_at": None
+      }
+    }
+  },
+  "items": [
+    {
+      "position": 1,
+      "points_possible": 5,
+      "entry": {
+        "title": "Geography: Capital Cities",
+        "item_body": "<p>What is the capital of Sweden?</p>",
+        "interaction_type_slug": "choice",
+        "scoring_algorithm": "Equivalence",
+        "interaction_data": {
+          "choices": [
+            {"position": 1, "item_body": "<p>Stockholm</p>"},
+            {"position": 2, "item_body": "<p>Gothenburg</p>"},
+            {"position": 3, "item_body": "<p>Malmö</p>"},
+            {"position": 4, "item_body": "<p>Uppsala</p>"}
+          ]
+        },
+        "scoring_data": {"value": 1}
+      }
+    },
+    {
+      "position": 2,
+      "points_possible": 5,
+      "entry": {
+        "title": "Programming: Language Type",
+        "item_body": "<p>Python is an interpreted programming language.</p>",
+        "interaction_type_slug": "true-false",
+        "scoring_algorithm": "Equivalence",
+        "interaction_data": {
+          "true_choice": "True",
+          "false_choice": "False"
+        },
+        "scoring_data": {"value": True}
+      }
+    },
+    {
+      "position": 3,
+      "points_possible": 5,
+      "entry": {
+        "title": "Math: Select All Correct",
+        "item_body": "<p>Which of the following are prime numbers?</p>",
+        "interaction_type_slug": "multi-answer",
+        "scoring_algorithm": "AllOrNothing",
+        "interaction_data": {
+          "choices": [
+            {"position": 1, "item_body": "<p>2</p>"},
+            {"position": 2, "item_body": "<p>4</p>"},
+            {"position": 3, "item_body": "<p>7</p>"},
+            {"position": 4, "item_body": "<p>9</p>"},
+            {"position": 5, "item_body": "<p>11</p>"}
+          ]
+        },
+        "scoring_data": {"value": [1, 3, 5]}
+      }
+    },
+    {
+      "position": 4,
+      "points_possible": 5,
+      "entry": {
+        "title": "Programming: Output Question",
+        "item_body": "<p>What does the following Python code print?</p>"
+                     "<pre>x = 5\nif x > 3:\n    print('big')\nelse:\n    print('small')</pre>",
+        "interaction_type_slug": "choice",
+        "scoring_algorithm": "Equivalence",
+        "interaction_data": {
+          "choices": [
+            {"position": 1, "item_body": "<p>big</p>"},
+            {"position": 2, "item_body": "<p>small</p>"},
+            {"position": 3, "item_body": "<p>5</p>"},
+            {"position": 4, "item_body": "<p>Nothing is printed</p>"}
+          ]
+        },
+        "scoring_data": {"value": 1}
+      }
+    }
+  ]
+}
+@
+
+<<constants>>=
+EXAMPLE_FULL_CLASSIC_QUIZ_JSON = {
+  "quiz_type": "classic",
+  "settings": {
+    "title": "Example Classic Quiz",
+    "description": "<p>Answer all questions carefully. Time limit: 60 minutes.</p>",
+    "quiz_type": "assignment",
+    "time_limit": 60,
+    "allowed_attempts": 2,
+    "shuffle_questions": True,
+    "shuffle_answers": True,
+    "points_possible": 100,
+    "published": False,
+    "due_at": None,
+    "unlock_at": None,
+    "lock_at": None
+  },
+  "questions": [
+    {
+      "question_name": "Capital Question",
+      "question_text": "<p>What is the capital of Sweden?</p>",
+      "question_type": "multiple_choice_question",
+      "points_possible": 5,
+      "answers": [
+        {"answer_text": "Stockholm", "answer_weight": 100},
+        {"answer_text": "Gothenburg", "answer_weight": 0},
+        {"answer_text": "Malmö", "answer_weight": 0}
+      ]
+    },
+    {
+      "question_name": "True/False Question",
+      "question_text": "<p>Python is an interpreted language.</p>",
+      "question_type": "true_false_question",
+      "points_possible": 5,
+      "answers": [
+        {"answer_text": "True", "answer_weight": 100},
+        {"answer_text": "False", "answer_weight": 0}
+      ]
+    }
+  ]
+}
+@
+
+
 The [[print_example_json]] function outputs both formats with explanatory
 headers, making it easy for users to copy the appropriate format for their quiz
 type.
@@ -4920,6 +5769,100 @@ def print_example_json():
 @
 
 
+Similarly, the [[print_full_quiz_example_json]] function outputs the full quiz
+format (settings plus questions) for use with [[quizzes create]] and
+[[quizzes export]].
+
+<<functions>>=
+def print_full_quiz_example_json():
+  """Prints example JSON for full quiz creation (settings + questions)"""
+  print("=" * 70)
+  print("EXAMPLE JSON FOR CREATING NEW QUIZZES (Quizzes.Next)")
+  print("=" * 70)
+  print()
+  print("This format includes both quiz settings and questions.")
+  print("Save to a file and use with:")
+  print("  canvaslms quizzes create -c COURSE -f quiz.json")
+  print()
+  print("This is the same format produced by 'quizzes export -I'.")
+  print()
+  print("BASIC SETTINGS:")
+  print("  title              - Quiz title")
+  print("  instructions       - HTML instructions shown to students")
+  print("  time_limit         - Time limit in SECONDS (or null)")
+  print("  points_possible    - Total points")
+  print("  due_at/unlock_at/lock_at - ISO 8601 dates (or null)")
+  print()
+  print("QUIZ SETTINGS (in 'settings.quiz_settings'):")
+  print()
+  print("  Randomization:")
+  print("    shuffle_answers: true/false - Randomize answer order")
+  print("    shuffle_questions: true/false - Randomize question order")
+  print()
+  print("  Time limit:")
+  print("    has_time_limit: true/false")
+  print("    session_time_limit_in_seconds: number")
+  print()
+  print("  Question display:")
+  print("    one_at_a_time_type: 'none' or 'question'")
+  print("    allow_backtracking: true/false - Can go back to previous questions")
+  print()
+  print("  Calculator:")
+  print("    calculator_type: 'none', 'basic', or 'scientific'")
+  print()
+  print("  Access restrictions:")
+  print("    require_student_access_code: true/false")
+  print("    student_access_code: 'password' or null")
+  print("    filter_ip_address: true/false")
+  print("    filters: {} or IP filter rules")
+  print()
+  print("  Multiple attempts:")
+  print("    multiple_attempts_enabled: true/false")
+  print("    attempt_limit: true/false (true = limited, false = unlimited)")
+  print("    max_attempts: number or null")
+  print("    score_to_keep: 'highest' or 'latest'")
+  print("    cooling_period: true/false (require wait between attempts)")
+  print("    cooling_period_seconds: seconds (e.g., 3600 = 1 hour)")
+  print()
+  print("  Result view (what students see after submission):")
+  print("    result_view_restricted: true/false")
+  print("    display_items: true/false - Show questions")
+  print("    display_item_response: true/false - Show student's answers")
+  print("    display_item_response_correctness: true/false - Show right/wrong")
+  print("    display_item_correct_answer: true/false - Show correct answers")
+  print("    display_item_feedback: true/false - Show per-question feedback")
+  print("    display_points_awarded: true/false - Show points earned")
+  print("    display_points_possible: true/false - Show max points")
+  print("    display_correct_answer_at: ISO date or null - When to reveal")
+  print("    hide_correct_answer_at: ISO date or null - When to hide")
+  print()
+  print("SCORING:")
+  print("  Use position numbers (1, 2, 3...) to reference correct answers.")
+  print("  UUIDs are generated automatically during import.")
+  print()
+  print(json.dumps(EXAMPLE_FULL_NEW_QUIZ_JSON, indent=2))
+  print()
+  print()
+  print("=" * 70)
+  print("EXAMPLE JSON FOR CREATING CLASSIC QUIZZES")
+  print("=" * 70)
+  print()
+  print("Classic Quizzes use different field names and units.")
+  print()
+  print("Settings (time_limit in MINUTES for Classic Quizzes):")
+  print("  title, description (not instructions), quiz_type,")
+  print("  time_limit, allowed_attempts, shuffle_questions,")
+  print("  shuffle_answers, points_possible, published,")
+  print("  due_at, unlock_at, lock_at, show_correct_answers,")
+  print("  one_question_at_a_time, cant_go_back, access_code")
+  print()
+  print("quiz_type values: assignment, practice_quiz, graded_survey, survey")
+  print("answer_weight: 100 = correct, 0 = incorrect")
+  print()
+  print(json.dumps(EXAMPLE_FULL_CLASSIC_QUIZ_JSON, indent=2))
+@
+
+
 \subsection{Processing the add command}
 
 When [[--example]] is provided, we print the example JSON and exit immediately
@@ -5648,6 +6591,17 @@ The [[clean_interaction_data]] function strips UUIDs from choices, keeping only
 the [[position]] and [[item_body]] fields.  This makes the JSON human-readable
 and avoids UUID conflicts when importing to a different quiz.
 
+Some question types use different structures:
+\begin{description}
+\item[choices] Multiple choice and multi-answer questions use a list of
+  dictionaries with [[id]], [[position]], and [[item_body]].
+\item[answers] Matching questions use [[answers]] (a list of strings for the
+  right column) and [[questions]] (a list of dicts for the left column).
+\end{description}
+
+We handle both cases, preserving string arrays as-is while cleaning dict-based
+choices.
+
 <<functions>>=
 def clean_interaction_data(interaction_data):
   """Removes UUIDs from interaction_data choices"""
@@ -5657,15 +6611,36 @@ def clean_interaction_data(interaction_data):
   clean = dict(interaction_data)
 
   # Handle choices array (multiple choice, multi-answer)
+  # Choices are dicts with id, position, item_body
   if 'choices' in clean:
     clean_choices = []
     for i, choice in enumerate(clean['choices']):
+      # Skip if choice is not a dict (shouldn't happen, but be safe)
+      if not isinstance(choice, dict):
+        clean_choices.append(choice)
+        continue
       clean_choice = {'position': choice.get('position', i + 1)}
       if 'item_body' in choice:
         clean_choice['item_body'] = choice['item_body']
       clean_choices.append(clean_choice)
     clean['choices'] = clean_choices
 
+  # Handle questions array (matching questions)
+  # Questions are dicts with id, item_body - we keep item_body, drop id
+  if 'questions' in clean:
+    clean_questions = []
+    for i, question in enumerate(clean['questions']):
+      if not isinstance(question, dict):
+        clean_questions.append(question)
+        continue
+      clean_q = {}
+      if 'item_body' in question:
+        clean_q['item_body'] = question['item_body']
+      clean_questions.append(clean_q)
+    clean['questions'] = clean_questions
+
+  # 'answers' is a list of strings (matching questions) - keep as-is
+
   return clean
 @