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

canvaslms/cli/quizzes.py

@@ -123,6 +123,74 @@ QUIZ_SCHEMA = {
         "description": "When to hide results: null, always, until_after_last_attempt",
     },
 }
+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)",
+    },
+}
+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)",
+    },
+}
 EXAMPLE_NEW_QUIZ_JSON = {
     "items": [
         {
@@ -537,6 +605,176 @@ EXAMPLE_CLASSIC_QUIZ_JSON = {
         },
     ]
 }
+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},
+            },
+        },
+    ],
+}
+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},
+            ],
+        },
+    ],
+}
 import logging
 from datetime import datetime, timedelta
 
@@ -1816,23 +2054,50 @@ def generate_latex_postamble():
 
 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
@@ -1841,18 +2106,36 @@ 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}")
+
 
 def create_new_quiz(course, requester, quiz_params):
     """Creates a New Quiz via the New Quizzes API
@@ -1860,17 +2143,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(
@@ -1882,6 +2163,50 @@ def create_new_quiz(course, requester, quiz_params):
         return None
 
 
+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
+
+
 def create_classic_quiz(course, quiz_params):
     """Creates a Classic Quiz using the canvasapi library
 
@@ -1967,7 +2292,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(
@@ -2005,14 +2330,16 @@ def edit_quiz_interactive(quiz, requester, html_mode=False):
     return "updated" if success else "error"
 
 
-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 = {}
 
@@ -2033,12 +2360,39 @@ 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
 
 
+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
+
+
 def apply_quiz_edit(quiz, attributes, body, requester, html_mode=False):
     """Apply edited attributes and body to a quiz
 
@@ -2082,7 +2436,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 = {}
 
@@ -2111,11 +2465,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)
@@ -2134,16 +2496,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(
@@ -2252,6 +2613,114 @@ def delete_classic_quiz(quiz):
         return False
 
 
+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))
+
+
+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}
+
+
+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}
+
+
 def add_view_command(subp):
     """Adds the view subcommand to the quizzes command group"""
     view_parser = subp.add_parser(
@@ -3093,6 +3562,94 @@ def print_example_json():
     print(json.dumps(EXAMPLE_CLASSIC_QUIZ_JSON, indent=2))
 
 
+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))
+
+
 def items_add_command(config, canvas, args):
     """Adds questions to a quiz from a JSON file"""
     # Handle --example flag first (doesn't require course/assignment/file)
@@ -3621,15 +4178,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
 
 
@@ -4047,6 +4625,7 @@ def add_command(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)
 
@@ -4163,31 +4742,70 @@ def add_create_command(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", type=str
+        "-f",
+        "--file",
+        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)"
+        "--title", "-t", 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",
     )
 
 
@@ -4260,6 +4878,68 @@ def add_delete_command(subp):
     )
 
 
+def add_export_command(subp):
+    """Adds the quizzes export subcommand to argparse parser 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"
+    )
+
+
 def add_items_command(subp):
     """Adds the quizzes items subcommand group to argparse parser subp"""
     items_parser = subp.add_parser(