canvaslms 5.3__py3-none-any.whl → 5.5__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
 
-\section{Usage Examples}
+# 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}
+
+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}
@@ -223,12 +326,14 @@ subcommands:
 <<[[quizzes.py]]>>=
 import argparse
 import csv
+import difflib
 import json
 import os
 import re
 import statistics
 import sys
 import time
+import yaml
 from collections import defaultdict, Counter
 from typing import Dict, List, Any
 
@@ -269,6 +374,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 +397,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 +418,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 +2398,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}
+
+\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}
 
-For Classic Quizzes, the format is similar but uses different field names
-(e.g., [[quiz_type]] instead of [[grading_type]]).
+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 +2508,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 +2577,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 +2614,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 +2628,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 +2651,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,23 +2882,300 @@ 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{File formats for quiz editing}
+\label{sec:quiz-file-formats}
+
+The [[quizzes edit]] command supports three file formats, auto-detected from
+the file extension and verified against the content:
+\begin{description}
+\item[JSON format] ([[.json]]) Full quiz structure with [[settings]] and
+  optional [[items]].  This is the same format used by [[quizzes export]] and
+  [[quizzes create]], enabling a round-trip workflow.
+\item[YAML format] ([[.yaml]], [[.yml]]) Same structure as JSON but in YAML
+  syntax.  More readable for hand-editing.
+\item[Front matter format] ([[.md]]) YAML front matter with Markdown body for
+  instructions.  This is the default interactive editing format, focused on
+  editing settings and instructions without touching questions.
+\end{description}
+
+The format is detected by file extension and verified by checking the first
+characters of the file:
+\begin{itemize}
+\item JSON files start with [[{]]
+\item YAML full format starts with [[quiz_type:]] or [[settings:]]
+\item Front matter format starts with [[---]]
+\end{itemize}
+
+<<functions>>=
+def detect_quiz_file_format(filepath):
+    """Detect quiz file format from extension and content
+
+    Args:
+        filepath: Path to the file
+
+    Returns:
+        'json', 'yaml', or 'frontmatter'
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        ValueError: If format cannot be determined or extension mismatches content
+    """
+    # Check extension
+    ext = os.path.splitext(filepath)[1].lower()
+
+    # Read file content
+    with open(filepath, 'r', encoding='utf-8') as f:
+        file_content = f.read()
+
+    content_stripped = file_content.lstrip()
+
+    # Determine expected format from extension
+    if ext == '.json':
+        expected = 'json'
+    elif ext in ('.yaml', '.yml'):
+        expected = 'yaml'
+    elif ext == '.md':
+        expected = 'frontmatter'
+    else:
+        expected = None  # Auto-detect
+
+    # Detect actual format from content
+    if content_stripped.startswith('{'):
+        actual = 'json'
+    elif content_stripped.startswith('---'):
+        actual = 'frontmatter'
+    elif (content_stripped.startswith('quiz_type:') or
+          content_stripped.startswith('settings:')):
+        actual = 'yaml'
+    else:
+        # For YAML, try parsing to see if it's valid
+        try:
+            data = yaml.safe_load(content_stripped)
+            if isinstance(data, dict) and ('settings' in data or 'title' in data):
+                actual = 'yaml'
+            else:
+                raise ValueError(f"Cannot determine format of {filepath}")
+        except yaml.YAMLError:
+            raise ValueError(f"Cannot determine format of {filepath}")
+
+    # Verify match if extension specified a format
+    if expected and expected != actual:
+        raise ValueError(
+            f"File extension suggests {expected} but content looks like {actual}"
+        )
+
+    return actual, file_content
+@
+
+The [[read_quiz_from_file]] function reads quiz data from any supported format
+and returns a unified structure that can be used for updating the quiz.
+
+<<functions>>=
+def read_quiz_from_file(filepath):
+    """Read quiz data from JSON, YAML, or front matter file
+
+    Args:
+        filepath: Path to the quiz file
+
+    Returns:
+        Dictionary with:
+            'format': 'json'|'yaml'|'frontmatter'
+            'settings': dict of quiz settings
+            'instructions': str or None (body for frontmatter format)
+            'items': list or None (questions, for json/yaml)
+            'quiz_type': 'new'|'classic' or None
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        ValueError: If file format is invalid
+    """
+    format_type, file_content = detect_quiz_file_format(filepath)
+
+    if format_type == 'json':
+        try:
+            data = json.loads(file_content)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON: {e}")
+        return _parse_quiz_full_format(data, 'json')
+
+    elif format_type == 'yaml':
+        try:
+            data = yaml.safe_load(file_content)
+        except yaml.YAMLError as e:
+            raise ValueError(f"Invalid YAML: {e}")
+        return _parse_quiz_full_format(data, 'yaml')
+
+    else:  # frontmatter
+        attributes, body = content.parse_yaml_front_matter(file_content)
+        return {
+            'format': 'frontmatter',
+            'settings': attributes,
+            'instructions': body.strip() if body else None,
+            'items': None,
+            'quiz_type': None
+        }
+
+
+def _parse_quiz_full_format(data, format_type):
+    """Parse full format (JSON or YAML) quiz data
+
+    Handles both the full format with 'settings' key and the simple format
+    where the entire dict is settings.
+    """
+    if not isinstance(data, dict):
+        raise ValueError(f"Expected a dictionary, got {type(data).__name__}")
+
+    if 'settings' in data:
+        settings = data['settings'].copy()
+    else:
+        # Simple format: entire dict is settings (excluding metadata keys)
+        settings = {k: v for k, v in data.items()
+                    if k not in ('quiz_type', 'items', 'questions')}
+
+    # Extract instructions from settings if present
+    instructions = settings.get('instructions')
+
+    return {
+        'format': format_type,
+        'settings': settings,
+        'instructions': instructions,
+        'items': data.get('items') or data.get('questions'),
+        'quiz_type': data.get('quiz_type')
+    }
+@
+
+
 \subsection{Command-line interface}
 
 The edit command takes course and quiz selection options. The [[-f]] option
-is now optional---without it, interactive mode is used. The [[--html]] option
-preserves raw HTML instead of converting to Markdown.
+supports multiple file formats (JSON, YAML, Markdown with front matter), which
+are auto-detected from the file extension.  The [[--full-json]] option enables
+interactive editing in full JSON format (same as [[quizzes export]]).
 
 <<add quizzes edit command to subp>>=
 edit_parser = subp.add_parser("edit",
     help="Edit quiz settings and instructions",
     description="""Edit an existing quiz's settings and instructions.
 
-Without -f: Opens your editor with YAML front matter (settings) and
-Markdown body (instructions). After editing, shows a preview and asks
-whether to accept, edit further, or discard the changes.
+INTERACTIVE MODE (default):
+  Opens your editor with YAML front matter (settings) and Markdown body
+  (instructions). After editing, shows a preview and asks whether to
+  accept, edit further, or discard the changes.
+
+  Use --full-json to edit as full JSON (same format as 'quizzes export -I').
+  This allows editing all quiz_settings including multiple_attempts and
+  result_view_settings.
+
+FILE MODE (-f):
+  Reads content from a file. Format is auto-detected from extension:
+    .json      - Full JSON format (settings + optional items)
+    .yaml/.yml - Full YAML format (same structure as JSON)
+    .md        - YAML front matter + Markdown body
 
-With -f: Reads content from a file for scripted workflows. The file
-should have YAML front matter followed by Markdown (or HTML with --html).
+  The JSON/YAML format is the same as 'quizzes export' output, enabling
+  a round-trip workflow: export, modify, edit.
+
+ITEM HANDLING:
+  By default, items/questions in the file are ignored to protect student
+  submissions. Use --replace-items to replace all questions (with confirmation
+  if submissions exist).
 
 The quiz type (New or Classic) is auto-detected.""")
 
@@ -2635,13 +3189,24 @@ except argparse.ArgumentError:
 add_quiz_option(edit_parser, required=True)
 
 edit_parser.add_argument("-f", "--file",
-    help="Read content from a Markdown/HTML file with YAML front matter",
+    help="Read content from file (format auto-detected: .json, .yaml, .yml, .md)",
     type=str,
     required=False)
 
 edit_parser.add_argument("--html",
     action="store_true",
     help="Edit raw HTML instead of converting to Markdown")
+
+edit_parser.add_argument("--full-json",
+    action="store_true",
+    help="Interactive mode: edit as full JSON instead of YAML+Markdown. "
+         "Allows editing all quiz_settings including multiple_attempts.")
+
+edit_parser.add_argument("--replace-items",
+    action="store_true",
+    help="Replace existing questions with items from file. "
+         "Default: ignore items to preserve student attempts. "
+         "Will prompt for confirmation if quiz has submissions.")
 @
 
 
@@ -2663,31 +3228,70 @@ def edit_command(config, canvas, args):
     <<edit quiz interactively>>
 @
 
-In file mode, we read the YAML front matter and body from the file, then
-apply the changes to the quiz. If the file contains an [[id]] field, we use
-it to identify the quiz directly; otherwise we use the filter match.
+In file mode, we use [[read_quiz_from_file]] to detect the format and parse
+the content appropriately.  The function returns a unified structure that
+works for all three formats (JSON, YAML, or Markdown with front matter).
+
+For JSON and YAML files, the structure may contain [[items]] (questions).
+By default we ignore items to protect student submissions---use
+[[--replace-items]] to replace them (after confirmation if submissions exist).
 
 <<edit quiz from file>>=
 try:
-  attributes, body = content.read_content_from_file(args.file)
+  quiz_data = read_quiz_from_file(args.file)
 except FileNotFoundError:
   canvaslms.cli.err(1, f"File not found: {args.file}")
 except ValueError as e:
   canvaslms.cli.err(1, f"Invalid file format: {e}")
 
-# If id is specified, find that specific quiz
-if attributes.get('id'):
+<<identify target quiz from file data>>
+<<handle item replacement if requested>>
+<<apply settings from file>>
+@
+
+We extract [[id]] from either the top level or the settings:
+
+<<identify target quiz from file data>>=
+settings = quiz_data['settings']
+quiz_id = settings.get('id')
+
+if quiz_id:
   target_quiz = None
   for quiz in quiz_list:
-    if str(quiz.id) == str(attributes['id']):
+    if str(quiz.id) == str(quiz_id):
       target_quiz = quiz
       break
   if not target_quiz:
-    canvaslms.cli.err(1, f"Quiz with ID {attributes['id']} not found")
+    canvaslms.cli.err(1, f"Quiz with ID {quiz_id} not found")
   quiz_list = [target_quiz]
+@
+
+If [[--replace-items]] is specified and the file contains items, we replace
+the quiz questions.  But first we check for student submissions and ask for
+confirmation if any exist.
+
+<<handle item replacement if requested>>=
+items = quiz_data.get('items')
+if args.replace_items and items:
+  for quiz in quiz_list:
+    <<check submissions and replace items>>
+elif items:
+  print(f"Note: Ignoring {len(items)} items in file (use --replace-items to update)",
+        file=sys.stderr)
+@
+
+The settings are applied using [[apply_quiz_edit]].  For frontmatter format,
+the body (instructions) is separate; for JSON/YAML it's in settings.
+
+<<apply settings from file>>=
+body = quiz_data.get('instructions') or ''
 
 for quiz in quiz_list:
-  success = apply_quiz_edit(quiz, attributes, body, requester, args.html)
+  # For JSON/YAML, instructions may be in settings; extract it for body
+  if quiz_data['format'] in ('json', 'yaml'):
+    body = settings.get('instructions', '') or ''
+
+  success = apply_quiz_edit(quiz, settings, body, requester, args.html)
   if success:
     print(f"Updated quiz: {quiz.title}")
   else:
@@ -2695,7 +3299,15 @@ for quiz in quiz_list:
 @
 
 In interactive mode, we process each quiz one at a time, opening the editor
-and showing a preview before applying changes.
+and showing a preview before applying changes.  The [[--full-json]] flag
+selects between two editing modes:
+\begin{description}
+\item[YAML+Markdown] (default) Simple front matter with Markdown body for
+  instructions.  Good for quick edits to title, due dates, and instructions.
+\item[Full JSON] (with [[--full-json]]) Complete JSON export format, including
+  [[quiz_settings]] with [[multiple_attempts]] and [[result_view_settings]].
+  Optionally includes items if [[--replace-items]] is also specified.
+\end{description}
 
 <<edit quiz interactively>>=
 # Confirm if multiple quizzes match
@@ -2713,7 +3325,13 @@ updated_count = 0
 skipped_count = 0
 
 for quiz in quiz_list:
-  result = edit_quiz_interactive(quiz, requester, args.html)
+  if args.full_json:
+    result = edit_quiz_interactive_json(
+      quiz, requester, args.html, args.replace_items
+    )
+  else:
+    result = edit_quiz_interactive(quiz, requester, args.html)
+
   if result == 'updated':
     updated_count += 1
   elif result == 'skipped':
@@ -2743,7 +3361,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(
@@ -2774,11 +3392,421 @@ def edit_quiz_interactive(quiz, requester, html_mode=False):
     print("Discarded changes.", file=sys.stderr)
     return 'skipped'
 
-  final_attrs, final_body = result
+  final_attrs, final_body = result
+
+  # Apply the changes
+  success = apply_quiz_edit(quiz, final_attrs, final_body, requester, html_mode)
+  return 'updated' if success else 'error'
+@
+
+
+\subsection{Interactive JSON editing workflow}
+
+The [[--full-json]] mode provides access to all quiz settings, including the
+nested [[quiz_settings]] structure that controls [[multiple_attempts]] and
+[[result_view_settings]].  This uses the same JSON format as [[quizzes export]],
+enabling a round-trip workflow.
+
+The workflow is:
+\begin{enumerate}
+\item Export the quiz to JSON (same format as [[quizzes export -I]])
+\item Open the JSON in the user's editor
+\item Show a diff of the changes and ask for confirmation
+\item Apply the changes (settings only, unless [[--replace-items]])
+\end{enumerate}
+
+<<functions>>=
+def edit_quiz_interactive_json(quiz, requester, html_mode=False,
+                               replace_items=False):
+  """Edit a quiz interactively using full JSON format
+
+  Args:
+    quiz: Quiz object to edit
+    requester: Canvas API requester
+    html_mode: If True, don't convert instructions (not used in JSON mode)
+    replace_items: If True, also update items from the JSON
+
+  Returns:
+    'updated', 'skipped', or 'error'
+  """
+  import tempfile
+
+  # Export current quiz state to JSON
+  if is_new_quiz(quiz):
+    original_data = export_full_new_quiz(quiz, requester, include_banks=True,
+                                         importable=not replace_items)
+  else:
+    original_data = export_full_classic_quiz(quiz, importable=not replace_items)
+
+  # If not replacing items, remove items from the export to simplify editing
+  if not replace_items:
+    original_data.pop('items', None)
+    original_data.pop('questions', None)
+  original_json = json.dumps(original_data, indent=2, ensure_ascii=False)
+
+  # Create temp file with .json extension for editor syntax highlighting
+  with tempfile.NamedTemporaryFile(
+    mode='w', suffix='.json', delete=False, encoding='utf-8'
+  ) as f:
+    f.write(original_json)
+    temp_path = f.name
+
+  try:
+    while True:
+      # Open editor
+      edited_json = open_in_editor(temp_path)
+      if edited_json is None:
+        print("Editor cancelled.", file=sys.stderr)
+        return 'skipped'
+
+      # Parse the edited JSON
+      try:
+        edited_data = json.loads(edited_json)
+      except json.JSONDecodeError as e:
+        print(f"Invalid JSON: {e}", file=sys.stderr)
+        response = input("Edit again? [Y/n] ").strip().lower()
+        if response == 'n':
+          return 'skipped'
+        continue
+
+      # Show diff and confirm
+      result = show_json_diff_and_confirm(
+        original_json, edited_json, quiz.title
+      )
+
+      if result == 'accept':
+        break
+      elif result == 'edit':
+        # Update temp file with edited content for next iteration
+        with open(temp_path, 'w', encoding='utf-8') as f:
+          f.write(edited_json)
+        continue
+      else:  # discard
+        print("Discarded changes.", file=sys.stderr)
+        return 'skipped'
+  finally:
+    # Clean up temp file
+    try:
+      os.unlink(temp_path)
+    except OSError:
+      pass
+
+  # Apply the changes
+  success = apply_quiz_from_dict(
+    quiz, edited_data, requester, replace_items=replace_items
+  )
+  return 'updated' if success else 'error'
+@
+
+\paragraph{Opening the editor.}
+We use the [[EDITOR]] environment variable, falling back to common editors.
+
+<<functions>>=
+def open_in_editor(filepath):
+  """Open a file in the user's preferred editor
+
+  Args:
+    filepath: Path to the file to edit
+
+  Returns:
+    The edited file content, or None if editor failed/was cancelled
+  """
+  import subprocess
+
+  editor = os.environ.get('EDITOR', os.environ.get('VISUAL', 'vi'))
+
+  try:
+    subprocess.run([editor, filepath], check=True)
+  except subprocess.CalledProcessError:
+    return None
+  except FileNotFoundError:
+    print(f"Editor '{editor}' not found. Set EDITOR environment variable.",
+          file=sys.stderr)
+    return None
+
+  try:
+    with open(filepath, 'r', encoding='utf-8') as f:
+      return f.read()
+  except IOError:
+    return None
+@
+
+\paragraph{Showing the diff and confirming.}
+We show a unified diff of the changes and ask the user to accept, edit again,
+or discard.
+
+<<functions>>=
+def show_json_diff_and_confirm(original, edited, title):
+  """Show a diff between original and edited JSON, ask for confirmation
+
+  Args:
+    original: Original JSON string
+    edited: Edited JSON string
+    title: Quiz title for display
+
+  Returns:
+    'accept', 'edit', or 'discard'
+  """
+  if original.strip() == edited.strip():
+    print("No changes detected.")
+    return 'discard'
+
+  # Generate unified diff
+  original_lines = original.splitlines(keepends=True)
+  edited_lines = edited.splitlines(keepends=True)
+
+  diff = list(difflib.unified_diff(
+    original_lines, edited_lines,
+    fromfile='original', tofile='edited',
+    lineterm=''
+  ))
+
+  if not diff:
+    print("No changes detected.")
+    return 'discard'
+
+  # Display diff with colors if terminal supports it
+  print(f"\n--- Changes to: {title} ---")
+  for line in diff:
+    line = line.rstrip('\n')
+    if line.startswith('+') and not line.startswith('+++'):
+      print(f"\033[32m{line}\033[0m")  # Green for additions
+    elif line.startswith('-') and not line.startswith('---'):
+      print(f"\033[31m{line}\033[0m")  # Red for deletions
+    elif line.startswith('@@'):
+      print(f"\033[36m{line}\033[0m")  # Cyan for line numbers
+    else:
+      print(line)
+  print()
+
+  # Prompt for action
+  while True:
+    response = input("[A]ccept, [E]dit, [D]iscard? ").strip().lower()
+    if response in ('a', 'accept'):
+      return 'accept'
+    elif response in ('e', 'edit'):
+      return 'edit'
+    elif response in ('d', 'discard'):
+      return 'discard'
+    print("Please enter A, E, or D.")
+@
+
+\paragraph{Applying changes from JSON.}
+We extract settings from the edited JSON and apply them.  If
+[[replace_items]] is True and items are present, we also update questions.
+
+<<functions>>=
+def apply_quiz_from_dict(quiz, data, requester, replace_items=False):
+  """Apply quiz changes from a dictionary (parsed JSON/YAML)
+
+  Args:
+    quiz: Quiz object to update
+    data: Dictionary with settings and optional items
+    requester: Canvas API requester
+    replace_items: If True, replace quiz items
+
+  Returns:
+    True on success, False on failure
+  """
+  # Extract settings - handle both 'settings' key and flat structure
+  if 'settings' in data:
+    settings = data['settings'].copy()
+  else:
+    # Flat structure: everything except 'items' and 'quiz_type' is settings
+    settings = {k: v for k, v in data.items()
+                if k not in ('items', 'questions', 'quiz_type')}
+
+  # Extract instructions/body
+  body = settings.get('instructions', '') or ''
+
+  # Apply settings
+  success = apply_quiz_edit(quiz, settings, body, requester, html_mode=True)
+
+  if not success:
+    return False
+
+  # Handle items if requested
+  items = data.get('items') or data.get('questions')
+  if replace_items and items:
+    item_success = replace_quiz_items(quiz, items, requester)
+    if not item_success:
+      canvaslms.cli.warn("Settings updated but failed to replace items")
+      return False
+
+  return True
+@
+
+
+\subsection{Submission checking and item replacement}
+
+Before replacing quiz items, we should check if students have already started
+the quiz.  Replacing items after students have submitted could invalidate their
+work, so we warn and ask for confirmation.
+
+<<functions>>=
+def get_quiz_submission_count(quiz, requester):
+  """Get the number of student submissions for a quiz
+
+  Args:
+    quiz: Quiz object
+    requester: Canvas API requester (unused for New Quizzes)
+
+  Returns:
+    Number of submissions, or -1 if unable to determine
+  """
+  try:
+    if is_new_quiz(quiz):
+      # New Quizzes are assignments - use standard Canvas API.
+      # The quiz.id is actually the assignment_id.
+      # Note: canvasapi returns NewQuiz.id as string (bug/inconsistency),
+      # but get_assignment() requires int.
+      assignment = quiz.course.get_assignment(int(quiz.id))
+      submissions = list(assignment.get_submissions())
+      # Count submissions that have been submitted (not just placeholder records)
+      return sum(1 for s in submissions if s.workflow_state == 'submitted' 
+                 or s.workflow_state == 'graded'
+                 or getattr(s, 'submitted_at', None) is not None)
+    else:
+      # Classic Quiz: use canvasapi
+      submissions = list(quiz.get_submissions())
+      # Count only actual submissions (not just generated records)
+      return sum(1 for s in submissions if s.workflow_state != 'settings_only')
+  except Exception as e:
+    canvaslms.cli.warn(f"Could not check submissions: {e}")
+    return -1
+@
+
+The [[replace_quiz_items]] function handles the complete process of replacing
+quiz items.  It first checks for submissions, then deletes existing items,
+and finally creates the new items.
+
+<<functions>>=
+def replace_quiz_items(quiz, items, requester):
+  """Replace all items in a quiz with new ones
+
+  Args:
+    quiz: Quiz object
+    items: List of item dictionaries (from export format)
+    requester: Canvas API requester
+
+  Returns:
+    True on success, False on failure
+  """
+  # Check for submissions first
+  submission_count = get_quiz_submission_count(quiz, requester)
+
+  if submission_count > 0:
+    print(f"\nWarning: This quiz has {submission_count} student submission(s).",
+          file=sys.stderr)
+    print("Replacing items will invalidate existing responses!", file=sys.stderr)
+    response = input("Continue anyway? [y/N] ").strip().lower()
+    if response != 'y':
+      print("Item replacement cancelled.")
+      return False
+  elif submission_count < 0:
+    print("\nWarning: Could not determine submission count.", file=sys.stderr)
+    response = input("Continue with item replacement? [y/N] ").strip().lower()
+    if response != 'y':
+      print("Item replacement cancelled.")
+      return False
+
+  # Delete existing items
+  if is_new_quiz(quiz):
+    delete_success = delete_all_new_quiz_items(quiz, requester)
+  else:
+    delete_success = delete_all_classic_quiz_questions(quiz)
+
+  if not delete_success:
+    canvaslms.cli.warn("Failed to delete existing items")
+    return False
+
+  # Create new items
+  if is_new_quiz(quiz):
+    create_success = add_new_quiz_items(quiz.course, quiz.id, requester, items)
+  else:
+    create_success = add_classic_questions(quiz, items)
+
+  return create_success
+@
+
+\paragraph{Deleting New Quiz items.}
+We first fetch all existing items, then delete each one.
+
+<<functions>>=
+def delete_all_new_quiz_items(quiz, requester):
+  """Delete all items from a New Quiz
+
+  Args:
+    quiz: Quiz object
+    requester: Canvas API requester
+
+  Returns:
+    True on success, False on failure
+  """
+  try:
+    # Fetch existing items
+    endpoint = f"courses/{quiz.course.id}/quizzes/{quiz.id}/items"
+    response = requester.request(
+      method='GET',
+      endpoint=endpoint,
+      _url="new_quizzes"
+    )
+    items = response.json()
+
+    if not items:
+      return True  # Nothing to delete
+
+    # Delete each item
+    for item in items:
+      item_id = item.get('id')
+      if item_id:
+        delete_endpoint = f"courses/{quiz.course.id}/quizzes/{quiz.id}/items/{item_id}"
+        requester.request(
+          method='DELETE',
+          endpoint=delete_endpoint,
+          _url="new_quizzes"
+        )
+
+    return True
+  except Exception as e:
+    canvaslms.cli.warn(f"Failed to delete New Quiz items: {e}")
+    return False
+@
+
+\paragraph{Deleting Classic Quiz questions.}
+For Classic Quizzes, we use the canvasapi library.
+
+<<functions>>=
+def delete_all_classic_quiz_questions(quiz):
+  """Delete all questions from a Classic Quiz
+
+  Args:
+    quiz: Classic Quiz object
+
+  Returns:
+    True on success, False on failure
+  """
+  try:
+    questions = list(quiz.get_questions())
+
+    for question in questions:
+      question.delete()
+
+    return True
+  except Exception as e:
+    canvaslms.cli.warn(f"Failed to delete Classic Quiz questions: {e}")
+    return False
+@
+
+The chunk [[<<check submissions and replace items>>]] combines submission
+checking with item replacement for the file-based workflow:
 
-  # Apply the changes
-  success = apply_quiz_edit(quiz, final_attrs, final_body, requester, html_mode)
-  return 'updated' if success else 'error'
+<<check submissions and replace items>>=
+item_success = replace_quiz_items(quiz, items, requester)
+if item_success:
+  print(f"Replaced items for quiz: {quiz.title}")
+else:
+  canvaslms.cli.warn(f"Failed to replace items for quiz: {quiz.title}")
 @
 
 
@@ -2789,15 +3817,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 +3851,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 +3948,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 +3977,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 +4004,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 +4015,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 +4182,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 +6174,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 +6425,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
@@ -5093,21 +6692,33 @@ def ensure_uuids_in_entry(entry):
     new_choices = []
 
     for i, choice in enumerate(interaction_data['choices']):
-      old_id = choice.get('id')
-      position = choice.get('position', i + 1)
-
-      # Generate new UUID if missing
-      if not old_id:
-        new_id = str(uuid.uuid4())
+      # Handle both dict choices (choice, multi-answer) and string choices (ordering)
+      if isinstance(choice, str):
+        # Ordering questions have choices as plain UUIDs/strings
+        # The string itself is the ID - keep it or generate new if invalid
+        if choice and len(choice) > 10:  # Looks like a UUID
+          new_id = choice
+        else:
+          new_id = str(uuid.uuid4())
+        position_to_uuid[i + 1] = new_id
+        new_choices.append(new_id)
       else:
-        new_id = old_id
+        # Regular choice dict
+        old_id = choice.get('id')
+        position = choice.get('position', i + 1)
+
+        # Generate new UUID if missing
+        if not old_id:
+          new_id = str(uuid.uuid4())
+        else:
+          new_id = old_id
 
-      position_to_uuid[position] = new_id
+        position_to_uuid[position] = new_id
 
-      new_choice = dict(choice)
-      new_choice['id'] = new_id
-      new_choice['position'] = position
-      new_choices.append(new_choice)
+        new_choice = dict(choice)
+        new_choice['id'] = new_id
+        new_choice['position'] = position
+        new_choices.append(new_choice)
 
     interaction_data['choices'] = new_choices
     entry['interaction_data'] = interaction_data
@@ -5648,6 +7259,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 +7279,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
 @