QuizGenerator 0.8.1__py3-none-any.whl → 0.10.0__py3-none-any.whl

QuizGenerator/qrcode_generator.py

@@ -9,17 +9,21 @@ The QR codes include encrypted data that allows regenerating question answers
 without storing separate files, enabling efficient grading of randomized exams.
 """
 
+import base64
+import hashlib
 import json
-import tempfile
 import logging
 import os
-import base64
+import tempfile
+import zlib
+from datetime import datetime
 from io import BytesIO
 from pathlib import Path
 from typing import Optional, Dict, Any
 
 import segno
 from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 
 log = logging.getLogger(__name__)
 
@@ -38,6 +42,22 @@ class QuestionQRCode:
 
     # Error correction level: M = 15% recovery (balanced for compact encoded data)
     ERROR_CORRECTION = 'M'
+    _generated_key: Optional[bytes] = None
+    V2_PREFIX = "v2."
+
+    @classmethod
+    def _persist_generated_key(cls, key: bytes) -> None:
+        try:
+            os.makedirs("out/keys", exist_ok=True)
+            timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+            path = os.path.join("out", "keys", f"quiz_encryption_key-{timestamp}.log")
+            with open(path, "w", encoding="utf-8") as handle:
+                handle.write("QUIZ_ENCRYPTION_KEY=")
+                handle.write(key.decode("ascii"))
+                handle.write("\n")
+            log.warning(f"Wrote generated QUIZ_ENCRYPTION_KEY to {path}")
+        except Exception as exc:
+            log.warning(f"Failed to persist generated QUIZ_ENCRYPTION_KEY: {exc}")
 
     @classmethod
     def get_encryption_key(cls) -> bytes:
@@ -61,67 +81,95 @@ class QuestionQRCode:
                 "QUIZ_ENCRYPTION_KEY not set! Generating temporary key. "
                 "Set this environment variable for production use!"
             )
-            # Generate temporary key for development
-            return Fernet.generate_key()
+            if cls._generated_key is None:
+                cls._generated_key = Fernet.generate_key()
+                os.environ["QUIZ_ENCRYPTION_KEY"] = cls._generated_key.decode("ascii")
+                cls._persist_generated_key(cls._generated_key)
+            return cls._generated_key
 
         # Key should be stored as base64 string in env
         return key_str.encode()
 
     @classmethod
-    def encrypt_question_data(cls, question_type: str, seed: int, version: str,
+    def _derive_aead_key(cls, key: bytes) -> bytes:
+        return hashlib.sha256(key).digest()
+
+    @classmethod
+    def _encrypt_v2(cls, payload: Dict[str, Any], *, key: Optional[bytes] = None) -> str:
+        if key is None:
+            key = cls.get_encryption_key()
+        aead_key = cls._derive_aead_key(key)
+        aesgcm = AESGCM(aead_key)
+        nonce = os.urandom(12)
+        json_bytes = json.dumps(payload, separators=(',', ':'), ensure_ascii=False).encode("utf-8")
+        compressed = zlib.compress(json_bytes)
+        ciphertext = aesgcm.encrypt(nonce, compressed, None)
+        token = base64.urlsafe_b64encode(nonce + ciphertext).decode("ascii")
+        return f"{cls.V2_PREFIX}{token}"
+
+    @classmethod
+    def _decrypt_v2(cls, encrypted_data: str, *, key: Optional[bytes] = None) -> Dict[str, Any]:
+        if not encrypted_data.startswith(cls.V2_PREFIX):
+            raise ValueError("Not a v2 payload")
+        if key is None:
+            key = cls.get_encryption_key()
+        aead_key = cls._derive_aead_key(key)
+        token = encrypted_data[len(cls.V2_PREFIX):]
+        raw = base64.urlsafe_b64decode(token.encode("ascii"))
+        nonce, ciphertext = raw[:12], raw[12:]
+        aesgcm = AESGCM(aead_key)
+        compressed = aesgcm.decrypt(nonce, ciphertext, None)
+        json_bytes = zlib.decompress(compressed)
+        return json.loads(json_bytes.decode("utf-8"))
+
+    @classmethod
+    def encrypt_question_data(cls, question_type: str, seed: int, version: Optional[str] = None,
                               config: Optional[Dict[str, Any]] = None,
+                              context: Optional[Dict[str, Any]] = None,
+                              points_value: Optional[float] = None,
                               key: Optional[bytes] = None) -> str:
         """
-        Encode question regeneration data with optional simple obfuscation.
+        Encode question regeneration data for QR embedding.
 
         Args:
             question_type: Class name of the question (e.g., "VectorDotProduct")
             seed: Random seed used to generate this specific question
-            version: Question class version (e.g., "1.0")
+            version: Optional question version string
             config: Optional dictionary of configuration parameters
+            context: Optional dictionary of context extras
+            points_value: Optional points value (for redundancy)
             key: Encryption key (uses environment key if None)
 
         Returns:
-            str: Base64-encoded (optionally XOR-obfuscated) data
+            str: Base64-encoded encrypted payload with v2 prefix
 
         Example:
             >>> encrypted = QuestionQRCode.encrypt_question_data("VectorDot", 12345, "1.0")
             >>> print(encrypted)
             'VmVjdG9yRG90OjEyMzQ1OjEuMA=='
         """
-        # Create compact data string, including config if provided
+        payload: Dict[str, Any] = {
+            "t": question_type,
+            "s": seed,
+        }
+        if points_value is not None:
+            payload["p"] = points_value
         if config:
-            # Serialize config as JSON and append to data string
-            config_json = json.dumps(config, separators=(',', ':'))
-            data_str = f"{question_type}:{seed}:{version}:{config_json}"
-        else:
-            data_str = f"{question_type}:{seed}:{version}"
-        data_bytes = data_str.encode('utf-8')
-
-        # Simple XOR obfuscation if key is provided (optional, for basic protection)
-        if key is None:
-            key = cls.get_encryption_key()
-
-        if key:
-            # Use first 16 bytes of key for simple XOR obfuscation
-            key_bytes = key[:16] if isinstance(key, bytes) else key.encode()[:16]
-            # XOR each byte with repeating key pattern
-            obfuscated = bytes(b ^ key_bytes[i % len(key_bytes)] for i, b in enumerate(data_bytes))
-        else:
-            obfuscated = data_bytes
-
-        # Base64 encode for compact representation
-        encoded = base64.urlsafe_b64encode(obfuscated).decode('utf-8')
-
-        log.debug(f"Encoded question data: {question_type} seed={seed} version={version} ({len(encoded)} chars)")
-
+            payload["c"] = config
+        if context:
+            payload["x"] = context
+        if version:
+            payload["v"] = version
+
+        encoded = cls._encrypt_v2(payload, key=key)
+        log.debug(f"Encoded question data v2: {question_type} seed={seed} ({len(encoded)} chars)")
         return encoded
 
     @classmethod
     def decrypt_question_data(cls, encrypted_data: str,
                              key: Optional[bytes] = None) -> Dict[str, Any]:
         """
-        Decode question regeneration data from QR code.
+        Decode question regeneration data from QR code (v2 preferred, v1 fallback).
 
         Args:
             encrypted_data: Base64-encoded (optionally XOR-obfuscated) string from QR code
@@ -142,10 +190,24 @@ class QuestionQRCode:
             key = cls.get_encryption_key()
 
         try:
-            # Decode from base64
+            if encrypted_data.startswith(cls.V2_PREFIX):
+                payload = cls._decrypt_v2(encrypted_data, key=key)
+                result = {
+                    "question_type": payload.get("t"),
+                    "seed": int(payload.get("s")),
+                }
+                if "v" in payload:
+                    result["version"] = payload.get("v")
+                if "c" in payload:
+                    result["config"] = payload.get("c")
+                if "x" in payload:
+                    result["context"] = payload.get("x")
+                if "p" in payload:
+                    result["points"] = payload.get("p")
+                return result
+
+            # V1 fallback (XOR obfuscation)
             obfuscated = base64.urlsafe_b64decode(encrypted_data.encode())
-
-            # Reverse XOR obfuscation if key is provided
             if key:
                 key_bytes = key[:16] if isinstance(key, bytes) else key.encode()[:16]
                 data_bytes = bytes(b ^ key_bytes[i % len(key_bytes)] for i, b in enumerate(obfuscated))
@@ -153,29 +215,26 @@ class QuestionQRCode:
                 data_bytes = obfuscated
 
             data_str = data_bytes.decode('utf-8')
-
-            # Parse data string - can be 3 or 4 parts (4th is optional config)
-            parts = data_str.split(':', 3)  # Split into max 4 parts
-            if len(parts) < 3:
-                raise ValueError(f"Invalid encoded data format: expected at least 3 parts, got {len(parts)}")
+            parts = data_str.split(':', 3)
+            if len(parts) < 2:
+                raise ValueError(f"Invalid encoded data format: expected at least 2 parts, got {len(parts)}")
 
             question_type = parts[0]
             seed_str = parts[1]
-            version = parts[2]
+            version = parts[2] if len(parts) >= 3 else None
 
             result = {
                 "question_type": question_type,
                 "seed": int(seed_str),
-                "version": version
             }
+            if version:
+                result["version"] = version
 
-            # Parse config JSON if present
             if len(parts) == 4:
                 try:
                     result["config"] = json.loads(parts[3])
                 except json.JSONDecodeError as e:
                     log.warning(f"Failed to parse config JSON: {e}")
-                    # Continue without config rather than failing
 
             return result
 
@@ -215,24 +274,27 @@ class QuestionQRCode:
         """
         data = {
             "q": question_number,
-            "pts": points_value
+            "p": points_value
         }
 
         # If question regeneration data provided, encrypt it
-        if all(k in extra_data for k in ['question_type', 'seed', 'version']):
-            # Include config in encrypted data if present
+        if all(k in extra_data for k in ['question_type', 'seed']):
             config = extra_data.get('config', {})
+            context = extra_data.get('context', {})
             encrypted = cls.encrypt_question_data(
                 extra_data['question_type'],
                 extra_data['seed'],
-                extra_data['version'],
-                config=config
+                extra_data.get('version'),
+                config=config,
+                context=context,
+                points_value=points_value
             )
             data['s'] = encrypted
 
-            # Remove the unencrypted data
-            extra_data = {k: v for k, v in extra_data.items()
-                         if k not in ['question_type', 'seed', 'version', 'config']}
+            extra_data = {
+                k: v for k, v in extra_data.items()
+                if k not in ['question_type', 'seed', 'version', 'config', 'context']
+            }
 
         # Add any remaining extra metadata
         data.update(extra_data)

QuizGenerator/question.py

@@ -15,10 +15,13 @@ import pprint
 import random
 import re
 import uuid
+import types
+import inspect
+from types import MappingProxyType
 
 import pypandoc
 import yaml
-from typing import List, Dict, Any, Tuple, Optional
+from typing import List, Dict, Any, Tuple, Optional, Mapping, MutableMapping
 import canvasapi.course, canvasapi.quiz
 
 import QuizGenerator.contentast as ca
@@ -42,6 +45,7 @@ class RegenerationFlags:
     generation_seed: Optional[int]
     question_version: str
     config_params: Dict[str, Any]
+    context_extras: Dict[str, Any] = dataclasses.field(default_factory=dict)
 
 
 @dataclasses.dataclass(frozen=True)
@@ -58,6 +62,83 @@ class QuestionInstance:
     flags: RegenerationFlags
 
 
+@dataclasses.dataclass
+class QuestionContext:
+  rng_seed: Optional[int]
+  rng: random.Random
+  data: MutableMapping[str, Any] | Mapping[str, Any] = dataclasses.field(default_factory=dict)
+  frozen: bool = False
+  question_cls: type | None = None
+
+  def __getitem__(self, key: str) -> Any:
+    if key == "rng_seed":
+      return self.rng_seed
+    if key == "rng":
+      return self.rng
+    return self.data[key]
+
+  def __setitem__(self, key: str, value: Any) -> None:
+    if self.frozen:
+      raise TypeError("QuestionContext is frozen.")
+    if key == "rng_seed":
+      self.rng_seed = value
+      return
+    if key == "rng":
+      self.rng = value
+      return
+    if isinstance(self.data, MappingProxyType):
+      raise TypeError("QuestionContext is frozen.")
+    self.data[key] = value
+
+  def get(self, key: str, default: Any = None) -> Any:
+    if key == "rng_seed":
+      return self.rng_seed
+    if key == "rng":
+      return self.rng
+    if hasattr(self.data, "get"):
+      return self.data.get(key, default)
+    return default
+
+  def __contains__(self, key: object) -> bool:
+    if key in ("rng_seed", "rng"):
+      return True
+    return key in self.data
+
+  def __getattr__(self, name: str) -> Any:
+    if name in self.data:
+      return self.data[name]
+    if self.question_cls is not None and hasattr(self.question_cls, name):
+      raw_attr = inspect.getattr_static(self.question_cls, name)
+      if isinstance(raw_attr, staticmethod):
+        return raw_attr.__func__
+      if isinstance(raw_attr, classmethod):
+        return raw_attr.__func__.__get__(self.question_cls, self.question_cls)
+      attr = getattr(self.question_cls, name)
+      if callable(attr):
+        return types.MethodType(attr, self)
+      return attr
+    raise AttributeError(f"{type(self).__name__} has no attribute {name!r}")
+
+  def keys(self):
+    return self.data.keys()
+
+  def items(self):
+    return self.data.items()
+
+  def values(self):
+    return self.data.values()
+
+  def freeze(self) -> "QuestionContext":
+    frozen_data = MappingProxyType(dict(self.data))
+    return QuestionContext(
+      rng_seed=self.rng_seed,
+      rng=self.rng,
+      data=frozen_data,
+      frozen=True,
+      question_cls=self.question_cls,
+    )
+
+
 # Spacing presets for questions
 SPACING_PRESETS = {
     "NONE": 0,
@@ -183,7 +264,12 @@ class QuestionRegistry:
       # Load modules from the current directory
       for _, module_name, _ in pkgutil.iter_modules([str(path)]):
         # Import the module
-        module = importlib.import_module(f"{package_prefix}.{module_name}")
+        try:
+          importlib.import_module(f"{package_prefix}.{module_name}")
+        except ImportError as e:
+          log.warning(
+            f"Skipping module '{package_prefix}.{module_name}' due to import error: {e}"
+          )
 
       # Recursively load modules from subdirectories
       for subdir in path.iterdir():
@@ -262,7 +348,7 @@ class RegenerableChoiceMixin:
           self.register_choice('scheduler_kind', self.Kind, scheduler_kind, kwargs)
           super().__init__(**kwargs)
 
-      def _build_context(self, rng_seed=None, **kwargs):
+      def _build_context(cls, rng_seed=None, **kwargs):
           self.rng.seed(rng_seed)
           # Get the choice (randomly selected or from config_params)
           self.scheduler_algorithm = self.get_choice('scheduler_kind', self.Kind)
@@ -439,6 +525,7 @@ class Question(abc.ABC):
 
   # Default version - subclasses should override this
   VERSION = "1.0"
+  FREEZE_CONTEXT = False
   
   class Topic(enum.Enum):
     # CST334 (Operating Systems) Topics
@@ -547,8 +634,10 @@ class Question(abc.ABC):
     """
     # Generate the question, retrying with incremented seeds until we get an interesting one
     base_seed = kwargs.get("rng_seed", None)
+    max_backoff_attempts = kwargs.get("max_backoff_attempts", None)
     build_kwargs = dict(kwargs)
     build_kwargs.pop("rng_seed", None)
+    build_kwargs.pop("max_backoff_attempts", None)
     # Include config params so build() implementations can access YAML-provided settings.
     build_kwargs = {**self.config_params, **build_kwargs}
 
@@ -562,6 +651,10 @@ class Question(abc.ABC):
       is_interesting = False
       ctx = None
       while not is_interesting:
+        if max_backoff_attempts is not None and backoff_counter >= max_backoff_attempts:
+          raise RuntimeError(
+            f"Exceeded max_backoff_attempts={max_backoff_attempts} for {self.__class__.__name__}"
+          )
         # Increment seed for each backoff attempt to maintain deterministic behavior
         current_seed = None if base_seed is None else base_seed + backoff_counter
         ctx = self._build_context(
@@ -574,7 +667,17 @@ class Question(abc.ABC):
       # Store the actual seed used and question metadata for QR code generation
       actual_seed = None if base_seed is None else base_seed + backoff_counter - 1
 
-      components = self.build(rng_seed=current_seed, context=ctx, **build_kwargs)
+      # Keep instance rng in sync for any legacy usage.
+      if isinstance(ctx, QuestionContext):
+        self.rng = ctx.rng
+      elif isinstance(ctx, dict) and "rng" in ctx:
+        self.rng = ctx["rng"]
+
+      components = self.__class__.build(
+        rng_seed=current_seed,
+        context=ctx,
+        **build_kwargs
+      )
 
       # Collect answers from explicit lists and inline AST
       inline_body_answers = self._collect_answers_from_ast(components.body)
@@ -593,6 +696,20 @@ class Question(abc.ABC):
       if isinstance(ctx, dict) and ctx.get("_config_params"):
         config_params.update(ctx.get("_config_params"))
 
+      context_extras: Dict[str, Any] = {}
+      if isinstance(ctx, QuestionContext):
+        include_list = ctx.get("qr_include_list", None)
+        if isinstance(include_list, (list, tuple)):
+          for key in include_list:
+            if key in ctx:
+              context_extras[key] = ctx[key]
+      elif isinstance(ctx, dict):
+        include_list = ctx.get("qr_include_list", None)
+        if isinstance(include_list, (list, tuple)):
+          for key in include_list:
+            if key in ctx:
+              context_extras[key] = ctx[key]
+
       instance = QuestionInstance(
         body=components.body,
         explanation=components.explanation,
@@ -606,7 +723,8 @@ class Question(abc.ABC):
           question_class_name=self._get_registered_name(),
           generation_seed=actual_seed,
           question_version=self.VERSION,
-          config_params=config_params
+          config_params=config_params,
+          context_extras=context_extras
         )
       )
       return instance
@@ -619,19 +737,27 @@ class Question(abc.ABC):
   def post_instantiate(self, instance, **kwargs):
     pass
    
-  def build(self, *, rng_seed=None, context=None, **kwargs) -> QuestionComponents:
+  @classmethod
+  def build(cls, *, rng_seed=None, context=None, **kwargs) -> QuestionComponents:
     """
     Build question content (body, answers, explanation) for a given seed.
 
     This should only generate content; metadata like points/spacing belong in instantiate().
     """
-    cls = self.__class__
     if context is None:
-      context = self._build_context(rng_seed=rng_seed, **kwargs)
+      context = cls._coerce_context(
+        cls._build_context(rng_seed=rng_seed, **kwargs),
+        rng_seed=rng_seed
+      )
+    else:
+      context = cls._coerce_context(context, rng_seed=rng_seed)
+
+    if cls.FREEZE_CONTEXT:
+      context = context.freeze()
 
     # Build body + explanation. Each may return just an Element or (Element, answers).
-    body, body_answers = cls._normalize_build_output(self._build_body(context))
-    explanation, explanation_answers = cls._normalize_build_output(self._build_explanation(context))
+    body, body_answers = cls._normalize_build_output(cls._build_body(context))
+    explanation, explanation_answers = cls._normalize_build_output(cls._build_explanation(context))
 
     # Collect inline answers from both body and explanation.
     inline_body_answers = cls._collect_answers_from_ast(body)
@@ -650,30 +776,48 @@ class Question(abc.ABC):
       explanation=explanation
     )
 
-  def _build_context(self, *, rng_seed=None, **kwargs):
+  @classmethod
+  def _coerce_context(cls, context, *, rng_seed=None) -> QuestionContext:
+    if isinstance(context, QuestionContext):
+      return context
+    if isinstance(context, dict):
+      ctx_seed = context.get("rng_seed", rng_seed)
+      rng = context.get("rng") or random.Random(ctx_seed)
+      ctx = QuestionContext(rng_seed=ctx_seed, rng=rng)
+      for key, value in context.items():
+        if key in ("rng_seed", "rng"):
+          continue
+        ctx.data[key] = value
+      return ctx
+    raise TypeError(f"Unsupported context type: {type(context)}")
+
+
+  @classmethod
+  def _build_context(cls, *, rng_seed=None, **kwargs) -> QuestionContext:
     """
     Build the deterministic context for a question instance.
 
-    Override to return a context dict and avoid persistent self.* state.
+    Override to return a QuestionContext and avoid persistent self.* state.
     """
     rng = random.Random(rng_seed)
-    # Keep instance rng in sync for questions that still use self.rng.
-    self.rng = rng
-    return {
-      "rng_seed": rng_seed,
-      "rng": rng,
-    }
+    return QuestionContext(
+      rng_seed=rng_seed,
+      rng=rng,
+      question_cls=cls,
+    )
 
   @classmethod
   def is_interesting_ctx(cls, context) -> bool:
     """Context-aware hook; defaults to existing is_interesting()."""
     return True
 
-  def _build_body(self, context) -> ca.Element | Tuple[ca.Element, List[ca.Answer]]:
+  @classmethod
+  def _build_body(cls, context) -> ca.Element | Tuple[ca.Element, List[ca.Answer]]:
     """Context-aware body builder."""
     raise NotImplementedError("Questions must implement _build_body().")
 
-  def _build_explanation(self, context) -> ca.Element | Tuple[ca.Element, List[ca.Answer]]:
+  @classmethod
+  def _build_explanation(cls, context) -> ca.Element | Tuple[ca.Element, List[ca.Answer]]:
     """Context-aware explanation builder."""
     raise NotImplementedError("Questions must implement _build_explanation().")
 
@@ -811,6 +955,7 @@ class Question(abc.ABC):
     question_ast.generation_seed = instance.flags.generation_seed
     question_ast.question_version = instance.flags.question_version
     question_ast.config_params = dict(instance.flags.config_params)
+    question_ast.qr_context_extras = dict(instance.flags.context_extras)
 
     return question_ast
 
@@ -893,11 +1038,11 @@ class QuestionGroup():
     
   def instantiate(self, *args, **kwargs):
     
-    # todo: Make work with rng_seed (or at least verify)
-    random.seed(kwargs.get("rng_seed", None))
+    # Use a local RNG to avoid global side effects.
+    rng = random.Random(kwargs.get("rng_seed", None))
     
     if not self.pick_once or self._current_question is None:
-      self._current_question = random.choice(self.questions)
+      self._current_question = rng.choice(self.questions)
     
   def __getattr__(self, name):
     if self._current_question is None or name == "generate":

QuizGenerator/regenerate.py

@@ -194,7 +194,9 @@ def regenerate_question_answer(
   }
   """
   question_num = qr_data.get('q')
-  points = qr_data.get('pts')
+  points = qr_data.get('p')
+  if points is None:
+    points = qr_data.get('pts')
   
   if question_num is None or points is None:
     log.error("QR code missing required fields 'q' or 'pts'")
@@ -219,8 +221,9 @@ def regenerate_question_answer(
     
     question_type = regen_data['question_type']
     seed = regen_data['seed']
-    version = regen_data['version']
+    version = regen_data.get('version')
     config = regen_data.get('config', {})
+    context_extras = regen_data.get('context', {})
     
     result['question_type'] = question_type
     result['seed'] = seed
@@ -228,7 +231,10 @@ def regenerate_question_answer(
     if config:
       result['config'] = config
     
-    log.info(f"Question {question_num}: {question_type} (seed={seed}, version={version})")
+    if version:
+      log.info(f"Question {question_num}: {question_type} (seed={seed}, version={version})")
+    else:
+      log.info(f"Question {question_num}: {question_type} (seed={seed})")
     if config:
       log.debug(f"  Config params: {config}")
     
@@ -241,7 +247,7 @@ def regenerate_question_answer(
     )
     
     # Generate question with the specific seed
-    instance = question.instantiate(rng_seed=seed)
+    instance = question.instantiate(rng_seed=seed, **context_extras)
     question_ast = question._build_question_ast(instance)
     
     # Extract answers
@@ -477,14 +483,22 @@ def display_answer_summary(question_data: Dict[str, Any]) -> None:
   if 'question_type' in question_data:
     print(f"Type: {question_data['question_type']}")
     print(f"Seed: {question_data['seed']}")
-    print(f"Version: {question_data['version']}")
+    if question_data.get('version') is not None:
+      print(f"Version: {question_data['version']}")
   
   if 'answer_objects' in question_data:
     print("\nANSWERS:")
-    for key, answer_obj in question_data['answer_objects'].items():
-      print(f"  {key}: {answer_obj.value}")
-      if hasattr(answer_obj, 'tolerance') and answer_obj.tolerance:
-        print(f"    (tolerance: ±{answer_obj.tolerance})")
+    answer_objects = question_data['answer_objects']
+    if isinstance(answer_objects, dict):
+      for key, answer_obj in answer_objects.items():
+        print(f"  {key}: {answer_obj.value}")
+        if hasattr(answer_obj, 'tolerance') and answer_obj.tolerance:
+          print(f"    (tolerance: ±{answer_obj.tolerance})")
+    else:
+      for i, answer_obj in enumerate(answer_objects, start=1):
+        print(f"  {i}: {answer_obj.value}")
+        if hasattr(answer_obj, 'tolerance') and answer_obj.tolerance:
+          print(f"    (tolerance: ±{answer_obj.tolerance})")
   elif 'answers' in question_data:
     print("\nANSWERS (raw Canvas format):")
     print(f"  Type: {question_data['answers']['kind']}")