QuizGenerator 0.4.3__py3-none-any.whl → 0.5.0__py3-none-any.whl

QuizGenerator/premade_questions/cst463/tensorflow-intro/tensorflow_questions.py

@@ -85,16 +85,18 @@ class ParameterCountingQuestion(Question):
     """Create answer fields."""
     self.answers = {}
 
-    self.answers["total_weights"] = Answer.integer("total_weights", self.total_weights)
+    self.answers["total_weights"] = Answer.integer("total_weights", self.total_weights, label="Total weights")
 
     if self.include_biases:
-      self.answers["total_biases"] = Answer.integer("total_biases", self.total_biases)
-      self.answers["total_params"] = Answer.integer("total_params", self.total_params)
+      self.answers["total_biases"] = Answer.integer("total_biases", self.total_biases, label="Total biases")
+      self.answers["total_params"] = Answer.integer("total_params", self.total_params, label="Total trainable parameters")
     else:
-      self.answers["total_params"] = Answer.integer("total_params", self.total_params)
+      self.answers["total_params"] = Answer.integer("total_params", self.total_params, label="Total trainable parameters")
 
-  def get_body(self, **kwargs) -> ContentAST.Section:
+  def _get_body(self, **kwargs) -> Tuple[ContentAST.Section, List[Answer]]:
+    """Build question body and collect answers."""
     body = ContentAST.Section()
+    answers = []
 
     # Question description
     body.add_element(ContentAST.Paragraph([
@@ -122,27 +124,36 @@ class ParameterCountingQuestion(Question):
     table_data = []
     table_data.append(["Parameter Type", "Count"])
 
+    answers.append(self.answers["total_weights"])
     table_data.append([
       "Total weights (connections between layers)",
-      ContentAST.Answer(self.answers["total_weights"])
+      self.answers["total_weights"]
     ])
 
     if self.include_biases:
+      answers.append(self.answers["total_biases"])
       table_data.append([
         "Total biases",
-        ContentAST.Answer(self.answers["total_biases"])
+        self.answers["total_biases"]
       ])
 
+    answers.append(self.answers["total_params"])
     table_data.append([
       "Total trainable parameters",
-      ContentAST.Answer(self.answers["total_params"])
+      self.answers["total_params"]
     ])
 
     body.add_element(ContentAST.Table(data=table_data))
 
+    return body, answers
+
+  def get_body(self, **kwargs) -> ContentAST.Section:
+    """Build question body (backward compatible interface)."""
+    body, _ = self._get_body(**kwargs)
     return body
 
-  def get_explanation(self, **kwargs) -> ContentAST.Section:
+  def _get_explanation(self, **kwargs) -> Tuple[ContentAST.Section, List[Answer]]:
+    """Build question explanation."""
     explanation = ContentAST.Section()
 
     explanation.add_element(ContentAST.Paragraph([
@@ -150,7 +161,7 @@ class ParameterCountingQuestion(Question):
     ]))
 
     explanation.add_element(ContentAST.Paragraph([
-      "**Weights calculation:**"
+      ContentAST.Text("Weights calculation:", emphasis=True)
     ]))
 
     for i in range(len(self.layer_sizes) - 1):
@@ -174,7 +185,7 @@ class ParameterCountingQuestion(Question):
 
     if self.include_biases:
       explanation.add_element(ContentAST.Paragraph([
-        "**Biases calculation:**"
+        ContentAST.Text("Biases calculation:", emphasis=True)
       ]))
 
       for i in range(len(self.layer_sizes) - 1):
@@ -194,7 +205,7 @@ class ParameterCountingQuestion(Question):
       ]))
 
     explanation.add_element(ContentAST.Paragraph([
-      "**Total trainable parameters:**"
+      ContentAST.Text("Total trainable parameters:", emphasis=True)
     ]))
 
     if self.include_biases:
@@ -208,6 +219,11 @@ class ParameterCountingQuestion(Question):
         inline=False
       ))
 
+    return explanation, []
+
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    """Build question explanation (backward compatible interface)."""
+    explanation, _ = self._get_explanation(**kwargs)
     return explanation
 
 
@@ -315,15 +331,17 @@ class ActivationFunctionComputationQuestion(Question):
 
     if self.activation == self.ACTIVATION_SOFTMAX:
       # Softmax: single vector answer
-      self.answers["output"] = Answer.vector_value("output", self.output_vector)
+      self.answers["output"] = Answer.vector_value("output", self.output_vector, label="Output vector")
     else:
       # Element-wise: individual answers
       for i, output in enumerate(self.output_vector):
         key = f"output_{i}"
-        self.answers[key] = Answer.float_value(key, float(output))
+        self.answers[key] = Answer.float_value(key, float(output), label=f"Output for input {self.input_vector[i]:.1f}")
 
-  def get_body(self, **kwargs) -> ContentAST.Section:
+  def _get_body(self, **kwargs) -> Tuple[ContentAST.Section, List[Answer]]:
+    """Build question body and collect answers."""
     body = ContentAST.Section()
+    answers = []
 
     # Question description
     body.add_element(ContentAST.Paragraph([
@@ -349,9 +367,10 @@ class ActivationFunctionComputationQuestion(Question):
         "Compute the output vector:"
       ]))
 
+      answers.append(self.answers["output"])
       table_data = []
       table_data.append(["Output Vector"])
-      table_data.append([ContentAST.Answer(self.answers["output"])])
+      table_data.append([self.answers["output"]])
 
       body.add_element(ContentAST.Table(data=table_data))
 
@@ -364,16 +383,24 @@ class ActivationFunctionComputationQuestion(Question):
       table_data.append(["Input", "Output"])
 
       for i, x in enumerate(self.input_vector):
+        answer = self.answers[f"output_{i}"]
+        answers.append(answer)
         table_data.append([
           ContentAST.Equation(f"{x:.1f}", inline=True),
-          ContentAST.Answer(self.answers[f"output_{i}"])
+          answer
         ])
 
       body.add_element(ContentAST.Table(data=table_data))
 
+    return body, answers
+
+  def get_body(self, **kwargs) -> ContentAST.Section:
+    """Build question body (backward compatible interface)."""
+    body, _ = self._get_body(**kwargs)
     return body
 
-  def get_explanation(self, **kwargs) -> ContentAST.Section:
+  def _get_explanation(self, **kwargs) -> Tuple[ContentAST.Section, List[Answer]]:
+    """Build question explanation."""
     explanation = ContentAST.Section()
 
     explanation.add_element(ContentAST.Paragraph([
@@ -382,7 +409,7 @@ class ActivationFunctionComputationQuestion(Question):
 
     if self.activation == self.ACTIVATION_SOFTMAX:
       explanation.add_element(ContentAST.Paragraph([
-        "**Softmax computation:**"
+        ContentAST.Text("Softmax computation:", emphasis=True)
       ]))
 
       # Show exponentials
@@ -419,7 +446,7 @@ class ActivationFunctionComputationQuestion(Question):
 
     else:
       explanation.add_element(ContentAST.Paragraph([
-        "**Element-wise computation:**"
+        ContentAST.Text("Element-wise computation:", emphasis=True)
       ]))
 
       for i, (x, y) in enumerate(zip(self.input_vector, self.output_vector)):
@@ -441,6 +468,11 @@ class ActivationFunctionComputationQuestion(Question):
             inline=False
           ))
 
+    return explanation, []
+
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    """Build question explanation (backward compatible interface)."""
+    explanation, _ = self._get_explanation(**kwargs)
     return explanation
 
 
@@ -513,14 +545,16 @@ class RegularizationCalculationQuestion(Question):
     """Create answer fields."""
     self.answers = {}
 
-    self.answers["prediction"] = Answer.float_value("prediction", float(self.prediction))
-    self.answers["base_loss"] = Answer.float_value("base_loss", float(self.base_loss))
-    self.answers["l2_penalty"] = Answer.float_value("l2_penalty", float(self.l2_penalty))
-    self.answers["total_loss"] = Answer.float_value("total_loss", float(self.total_loss))
-    self.answers["grad_total_w0"] = Answer.auto_float("grad_total_w0", float(self.grad_total_w0))
+    self.answers["prediction"] = Answer.float_value("prediction", float(self.prediction), label="Prediction ŷ")
+    self.answers["base_loss"] = Answer.float_value("base_loss", float(self.base_loss), label="Base MSE loss")
+    self.answers["l2_penalty"] = Answer.float_value("l2_penalty", float(self.l2_penalty), label="L2 penalty")
+    self.answers["total_loss"] = Answer.float_value("total_loss", float(self.total_loss), label="Total loss")
+    self.answers["grad_total_w0"] = Answer.auto_float("grad_total_w0", float(self.grad_total_w0), label="Gradient ∂L/∂w₀")
 
-  def get_body(self, **kwargs) -> ContentAST.Section:
+  def _get_body(self, **kwargs) -> Tuple[ContentAST.Section, List[Answer]]:
+    """Build question body and collect answers."""
     body = ContentAST.Section()
+    answers = []
 
     # Question description
     body.add_element(ContentAST.Paragraph([
@@ -570,36 +604,47 @@ class RegularizationCalculationQuestion(Question):
     table_data = []
     table_data.append(["Calculation", "Value"])
 
+    answers.append(self.answers["prediction"])
     table_data.append([
       ContentAST.Paragraph(["Prediction ", ContentAST.Equation(r"\hat{y}", inline=True)]),
-      ContentAST.Answer(self.answers["prediction"])
+      self.answers["prediction"]
     ])
 
+    answers.append(self.answers["base_loss"])
     table_data.append([
       ContentAST.Paragraph(["Base MSE loss: ", ContentAST.Equation(r"L_{base} = (1/2)(y - \hat{y})^2", inline=True)]),
-      ContentAST.Answer(self.answers["base_loss"])
+      self.answers["base_loss"]
     ])
 
+    answers.append(self.answers["l2_penalty"])
     table_data.append([
       ContentAST.Paragraph(["L2 penalty: ", ContentAST.Equation(r"L_{reg} = (\lambda/2)\sum w_i^2", inline=True)]),
-      ContentAST.Answer(self.answers["l2_penalty"])
+      self.answers["l2_penalty"]
     ])
 
+    answers.append(self.answers["total_loss"])
     table_data.append([
       ContentAST.Paragraph(["Total loss: ", ContentAST.Equation(r"L_{total} = L_{base} + L_{reg}", inline=True)]),
-      ContentAST.Answer(self.answers["total_loss"])
+      self.answers["total_loss"]
     ])
 
+    answers.append(self.answers["grad_total_w0"])
     table_data.append([
       ContentAST.Paragraph(["Gradient: ", ContentAST.Equation(r"\frac{\partial L_{total}}{\partial w_0}", inline=True)]),
-      ContentAST.Answer(self.answers["grad_total_w0"])
+      self.answers["grad_total_w0"]
     ])
 
     body.add_element(ContentAST.Table(data=table_data))
 
+    return body, answers
+
+  def get_body(self, **kwargs) -> ContentAST.Section:
+    """Build question body (backward compatible interface)."""
+    body, _ = self._get_body(**kwargs)
     return body
 
-  def get_explanation(self, **kwargs) -> ContentAST.Section:
+  def _get_explanation(self, **kwargs) -> Tuple[ContentAST.Section, List[Answer]]:
+    """Build question explanation."""
     explanation = ContentAST.Section()
 
     explanation.add_element(ContentAST.Paragraph([
@@ -608,7 +653,7 @@ class RegularizationCalculationQuestion(Question):
 
     # Step 1: Forward pass
     explanation.add_element(ContentAST.Paragraph([
-      "**Step 1: Compute prediction**"
+      ContentAST.Text("Step 1: Compute prediction", emphasis=True)
     ]))
 
     terms = []
@@ -626,7 +671,7 @@ class RegularizationCalculationQuestion(Question):
 
     # Step 2: Base loss
     explanation.add_element(ContentAST.Paragraph([
-      "**Step 2: Compute base MSE loss**"
+      ContentAST.Text("Step 2: Compute base MSE loss", emphasis=True)
     ]))
 
     explanation.add_element(ContentAST.Equation(
@@ -636,7 +681,7 @@ class RegularizationCalculationQuestion(Question):
 
     # Step 3: L2 penalty
     explanation.add_element(ContentAST.Paragraph([
-      "**Step 3: Compute L2 penalty**"
+      ContentAST.Text("Step 3: Compute L2 penalty", emphasis=True)
     ]))
 
     weight_squares = [f"{w:.1f}^2" for w in self.weights]
@@ -649,7 +694,7 @@ class RegularizationCalculationQuestion(Question):
 
     # Step 4: Total loss
     explanation.add_element(ContentAST.Paragraph([
-      "**Step 4: Compute total loss**"
+      ContentAST.Text("Step 4: Compute total loss", emphasis=True)
     ]))
 
     explanation.add_element(ContentAST.Equation(
@@ -659,7 +704,7 @@ class RegularizationCalculationQuestion(Question):
 
     # Step 5: Gradient with regularization
     explanation.add_element(ContentAST.Paragraph([
-      "**Step 5: Compute gradient with regularization**"
+      ContentAST.Text("Step 5: Compute gradient with regularization", emphasis=True)
     ]))
 
     explanation.add_element(ContentAST.Paragraph([
@@ -688,6 +733,11 @@ class RegularizationCalculationQuestion(Question):
       " to the gradient, pushing the weight toward zero."
     ]))
 
+    return explanation, []
+
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    """Build question explanation (backward compatible interface)."""
+    explanation, _ = self._get_explanation(**kwargs)
     return explanation
 
 
@@ -767,17 +817,19 @@ class MomentumOptimizerQuestion(Question, TableQuestionMixin, BodyTemplatesMixin
     self.answers = {}
 
     # New velocity
-    self.answers["velocity"] = Answer.vector_value("velocity", self.new_velocity)
+    self.answers["velocity"] = Answer.vector_value("velocity", self.new_velocity, label="New velocity")
 
     # New weights with momentum
-    self.answers["weights_momentum"] = Answer.vector_value("weights_momentum", self.new_weights)
+    self.answers["weights_momentum"] = Answer.vector_value("weights_momentum", self.new_weights, label="Weights (momentum)")
 
     # Vanilla SGD weights for comparison
     if self.show_vanilla_sgd:
-      self.answers["weights_sgd"] = Answer.vector_value("weights_sgd", self.sgd_weights)
+      self.answers["weights_sgd"] = Answer.vector_value("weights_sgd", self.sgd_weights, label="Weights (vanilla SGD)")
 
-  def get_body(self, **kwargs) -> ContentAST.Section:
+  def _get_body(self, **kwargs) -> Tuple[ContentAST.Section, List[Answer]]:
+    """Build question body and collect answers."""
     body = ContentAST.Section()
+    answers = []
 
     # Question description
     body.add_element(ContentAST.Paragraph([
@@ -800,14 +852,14 @@ class MomentumOptimizerQuestion(Question, TableQuestionMixin, BodyTemplatesMixin
 
     # Current state
     body.add_element(ContentAST.Paragraph([
-      "**Current optimization state:**"
+      ContentAST.Text("Current optimization state:", emphasis=True)
     ]))
 
     body.add_element(ContentAST.Paragraph([
       "Current weights: ",
       ContentAST.Equation(f"{format_vector(self.current_weights)}", inline=True)
     ]))
-    
+
     body.add_element(ContentAST.Paragraph([
       "Previous velocity: ",
       ContentAST.Equation(f"{format_vector(self.prev_velocity)}", inline=True)
@@ -815,7 +867,7 @@ class MomentumOptimizerQuestion(Question, TableQuestionMixin, BodyTemplatesMixin
 
     # Hyperparameters
     body.add_element(ContentAST.Paragraph([
-      "**Hyperparameters:**"
+      ContentAST.Text("Hyperparameters:", emphasis=True)
     ]))
 
     body.add_element(ContentAST.Paragraph([
@@ -837,30 +889,39 @@ class MomentumOptimizerQuestion(Question, TableQuestionMixin, BodyTemplatesMixin
     table_data = []
     table_data.append(["Update Type", "Formula", "Result"])
 
+    answers.append(self.answers["velocity"])
     table_data.append([
       "New velocity",
       ContentAST.Equation(r"v' = \beta v + (1-\beta)\nabla f", inline=True),
-      ContentAST.Answer(self.answers["velocity"])
+      self.answers["velocity"]
     ])
 
+    answers.append(self.answers["weights_momentum"])
     table_data.append([
       "Weights (momentum)",
       ContentAST.Equation(r"w' = w - \alpha v'", inline=True),
-      ContentAST.Answer(self.answers["weights_momentum"])
+      self.answers["weights_momentum"]
     ])
 
     if self.show_vanilla_sgd:
+      answers.append(self.answers["weights_sgd"])
       table_data.append([
         "Weights (vanilla SGD)",
         ContentAST.Equation(r"w' = w - \alpha \nabla f", inline=True),
-        ContentAST.Answer(self.answers["weights_sgd"])
+        self.answers["weights_sgd"]
       ])
 
     body.add_element(ContentAST.Table(data=table_data))
 
+    return body, answers
+
+  def get_body(self, **kwargs) -> ContentAST.Section:
+    """Build question body (backward compatible interface)."""
+    body, _ = self._get_body(**kwargs)
     return body
 
-  def get_explanation(self, **kwargs) -> ContentAST.Section:
+  def _get_explanation(self, **kwargs) -> Tuple[ContentAST.Section, List[Answer]]:
+    """Build question explanation."""
     explanation = ContentAST.Section()
 
     explanation.add_element(ContentAST.Paragraph([
@@ -870,7 +931,7 @@ class MomentumOptimizerQuestion(Question, TableQuestionMixin, BodyTemplatesMixin
 
     # Step 1: Calculate new velocity
     explanation.add_element(ContentAST.Paragraph([
-      "**Step 1: Update velocity using momentum**"
+      ContentAST.Text("Step 1: Update velocity using momentum", emphasis=True)
     ]))
 
     explanation.add_element(ContentAST.Paragraph([
@@ -883,17 +944,24 @@ class MomentumOptimizerQuestion(Question, TableQuestionMixin, BodyTemplatesMixin
     ))
 
     # Show calculation for each component
+    digits = Answer.DEFAULT_ROUNDING_DIGITS
     for i in range(self.num_variables):
       var_name = f"x_{i}"
+      # Round all intermediate values to avoid floating point precision issues
+      beta_times_v = round(self.momentum_beta * self.prev_velocity[i], digits)
+      one_minus_beta = round(1 - self.momentum_beta, digits)
+      one_minus_beta_times_grad = round((1 - self.momentum_beta) * self.gradients[i], digits)
+
       explanation.add_element(ContentAST.Equation(
-        f"v'[{i}] = {self.momentum_beta} \\times {self.prev_velocity[i]:.2f} + "
-        f"{1 - self.momentum_beta} \\times {self.gradients[i]:.4f} = {self.new_velocity[i]:.4f}",
+        f"v'[{i}] = {self.momentum_beta} \\times {self.prev_velocity[i]:.{digits}f} + "
+        f"{one_minus_beta:.{digits}f} \\times {self.gradients[i]:.{digits}f} = "
+        f"{beta_times_v:.{digits}f} + {one_minus_beta_times_grad:.{digits}f} = {self.new_velocity[i]:.{digits}f}",
         inline=False
       ))
 
     # Step 2: Update weights with momentum
     explanation.add_element(ContentAST.Paragraph([
-      "**Step 2: Update weights using new velocity**"
+      ContentAST.Text("Step 2: Update weights using new velocity", emphasis=True)
     ]))
 
     explanation.add_element(ContentAST.Equation(
@@ -910,7 +978,7 @@ class MomentumOptimizerQuestion(Question, TableQuestionMixin, BodyTemplatesMixin
     # Comparison with vanilla SGD
     if self.show_vanilla_sgd:
       explanation.add_element(ContentAST.Paragraph([
-        "**Comparison with vanilla SGD:**"
+        ContentAST.Text("Comparison with vanilla SGD:", emphasis=True)
       ]))
 
       explanation.add_element(ContentAST.Paragraph([
@@ -933,4 +1001,9 @@ class MomentumOptimizerQuestion(Question, TableQuestionMixin, BodyTemplatesMixin
         "which can help accelerate learning and smooth out noisy gradients."
       ]))
 
+    return explanation, []
+
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    """Build question explanation (backward compatible interface)."""
+    explanation, _ = self._get_explanation(**kwargs)
     return explanation

QuizGenerator/question.py

@@ -29,6 +29,14 @@ import logging
 log = logging.getLogger(__name__)
 
 
+@dataclasses.dataclass
+class QuestionComponents:
+    """Bundle of question parts generated during construction."""
+    body: ContentAST.Element
+    answers: List[Answer]
+    explanation: ContentAST.Element
+
+
 # Spacing presets for questions
 SPACING_PRESETS = {
     "NONE": 0,
@@ -344,25 +352,31 @@ class Question(abc.ABC):
   ensures consistent rendering across PDF/LaTeX and Canvas/HTML formats.
 
   Required Methods:
-    - get_body(): Return ContentAST.Section with question content
-    - get_explanation(): Return ContentAST.Section with solution steps
+    - _get_body(): Return Tuple[ContentAST.Section, List[Answer]] with body and answers
+    - _get_explanation(): Return Tuple[ContentAST.Section, List[Answer]] with explanation
+
+  Note: get_body() and get_explanation() are provided for backward compatibility
+  and call the _get_* methods, returning just the first element of the tuple.
 
   Required Class Attributes:
     - VERSION (str): Question version number (e.g., "1.0")
       Increment when RNG logic changes to ensure reproducibility
 
   ContentAST Usage Examples:
-    def get_body(self):
+    def _get_body(self):
         body = ContentAST.Section()
+        answers = []
         body.add_element(ContentAST.Paragraph(["Calculate the matrix:"]))
 
         # Use ContentAST.Matrix for math, NOT manual LaTeX
         matrix_data = [[1, 2], [3, 4]]
         body.add_element(ContentAST.Matrix(data=matrix_data, bracket_type="b"))
 
-        # Use ContentAST.Answer for input fields
-        body.add_element(ContentAST.Answer(answer=self.answers["result"]))
-        return body
+        # Answer extends ContentAST.Leaf - add directly to body
+        ans = Answer.integer("result", 42, label="Result")
+        answers.append(ans)
+        body.add_element(ans)
+        return body, answers
 
   Common ContentAST Elements:
     - ContentAST.Paragraph: Text blocks
@@ -472,6 +486,9 @@ class Question(abc.ABC):
 
     self.rng_seed_offset = kwargs.get("rng_seed_offset", 0)
 
+    # Component caching for unified Answer architecture
+    self._components: QuestionComponents = None
+
     # To be used throughout when generating random things
     self.rng = random.Random()
 
@@ -569,28 +586,105 @@ class Question(abc.ABC):
   
   def get_explanation(self, **kwargs) -> ContentAST.Section:
     """
-    Gets the body of the question during generation
+    Gets the body of the question during generation (backward compatible wrapper).
+    Calls _get_explanation() and returns just the explanation.
     :param kwargs:
     :return: (ContentAST.Section) Containing question explanation or None
     """
+    # Try new pattern first
+    if hasattr(self, '_get_explanation') and callable(getattr(self, '_get_explanation')):
+      explanation, _ = self._get_explanation()
+      return explanation
+    # Fallback: default explanation
     return ContentAST.Section(
       [ContentAST.Text("[Please reach out to your professor for clarification]")]
     )
-  
+
+  def _get_body(self) -> Tuple[ContentAST.Element, List[Answer]]:
+    """
+    Build question body and collect answers (new pattern).
+    Questions should override this to return (body, answers) tuple.
+
+    Returns:
+        Tuple of (body_ast, answers_list)
+    """
+    # Fallback: call old get_body() and return empty answers
+    body = self.get_body()
+    return body, []
+
+  def _get_explanation(self) -> Tuple[ContentAST.Element, List[Answer]]:
+    """
+    Build question explanation and collect answers (new pattern).
+    Questions can override this to include answers in explanations.
+
+    Returns:
+        Tuple of (explanation_ast, answers_list)
+    """
+    return ContentAST.Section(
+      [ContentAST.Text("[Please reach out to your professor for clarification]")]
+    ), []
+
+  def build_question_components(self, **kwargs) -> QuestionComponents:
+    """
+    Build question components (body, answers, explanation) in single pass.
+
+    Calls _get_body() and _get_explanation() which return tuples of
+    (content, answers).
+    """
+    # Build body with its answers
+    body, body_answers = self._get_body()
+
+    # Build explanation with its answers
+    explanation, explanation_answers = self._get_explanation()
+
+    # Combine all answers
+    all_answers = body_answers + explanation_answers
+
+    return QuestionComponents(
+      body=body,
+      answers=all_answers,
+      explanation=explanation
+    )
+
   def get_answers(self, *args, **kwargs) -> Tuple[Answer.AnswerKind, List[Dict[str,Any]]]:
-    if self.can_be_numerical():
+    """
+    Return answers from cached components (new pattern) or self.answers dict (old pattern).
+    """
+    # Try component-based approach first (new pattern)
+    if self._components is None:
+      try:
+        self._components = self.build_question_components()
+      except Exception as e:
+        # If component building fails, fall back to dict
+        log.debug(f"Failed to build question components: {e}, falling back to dict")
+        pass
+
+    # Use components if available and non-empty
+    if self._components is not None and len(self._components.answers) > 0:
+      answers = self._components.answers
+      if self.can_be_numerical():
+        return (
+          Answer.AnswerKind.NUMERICAL_QUESTION,
+          list(itertools.chain(*[a.get_for_canvas(single_answer=True) for a in answers]))
+        )
       return (
-        Answer.AnswerKind.NUMERICAL_QUESTION,
-        list(itertools.chain(*[a.get_for_canvas(single_answer=True) for a in self.answers.values()]))
+        self.answer_kind,
+        list(itertools.chain(*[a.get_for_canvas() for a in answers]))
       )
-    elif len(self.answers.values()) > 0:
+
+    # Fall back to dict pattern (old pattern)
+    if len(self.answers.values()) > 0:
+      if self.can_be_numerical():
+        return (
+          Answer.AnswerKind.NUMERICAL_QUESTION,
+          list(itertools.chain(*[a.get_for_canvas(single_answer=True) for a in self.answers.values()]))
+        )
       return (
         self.answer_kind,
         list(itertools.chain(*[a.get_for_canvas() for a in self.answers.values()]))
       )
-    return (
-      Answer.AnswerKind.ESSAY, []
-    )
+
+    return (Answer.AnswerKind.ESSAY, [])
     
   def refresh(self, rng_seed=None, *args, **kwargs):
     """If it is necessary to regenerate aspects between usages, this is the time to do it.
@@ -601,6 +695,7 @@ class Question(abc.ABC):
     :return: bool - True if the generated question is interesting, False otherwise
     """
     self.answers = {}
+    self._components = None  # Clear component cache
     # Seed the RNG directly with the provided seed (no offset)
     self.rng.seed(rng_seed)
     # Note: We don't call is_interesting() here because child classes need to