QuizGenerator 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

QuizGenerator/premade_questions/cst463/math_and_data/vector_questions.py

@@ -2,26 +2,28 @@
 import abc
 import logging
 import math
+import random
 from typing import List
 
 from QuizGenerator.question import Question, QuestionRegistry
 import QuizGenerator.contentast as ca
-from QuizGenerator.mixins import MathOperationQuestion
 
 log = logging.getLogger(__name__)
 
 
-class VectorMathQuestion(MathOperationQuestion, Question):
+class VectorMathQuestion(Question):
 
   def __init__(self, *args, **kwargs):
     kwargs["topic"] = kwargs.get("topic", Question.Topic.MATH)
     super().__init__(*args, **kwargs)
 
-  def _generate_vector(self, dimension, min_val=-10, max_val=10):
+  @staticmethod
+  def _generate_vector(rng, dimension, min_val=-10, max_val=10):
     """Generate a vector with random integer values."""
-    return [self.rng.randint(min_val, max_val) for _ in range(dimension)]
+    return [rng.randint(min_val, max_val) for _ in range(dimension)]
 
-  def _format_vector(self, vector):
+  @staticmethod
+  def _format_vector(vector):
     """Return a ca.Matrix element for the vector (format-independent).
 
     The Matrix element will render appropriately for each output format:
@@ -33,66 +35,42 @@ class VectorMathQuestion(MathOperationQuestion, Question):
     matrix_data = [[v] for v in vector]
     return ca.Matrix(data=matrix_data, bracket_type="b")
 
-  def _format_vector_inline(self, vector):
+  @staticmethod
+  def _format_vector_inline(vector):
     """Format vector for inline display."""
     elements = [str(v) for v in vector]
     return f"({', '.join(elements)})"
 
-  # Implement MathOperationQuestion abstract methods
-
-  def generate_operands(self):
-    """Generate two vectors for the operation."""
-    if not hasattr(self, 'dimension'):
-      self.dimension = self.rng.randint(self.MIN_DIMENSION, self.MAX_DIMENSION)
-    vector_a = self._generate_vector(self.dimension)
-    vector_b = self._generate_vector(self.dimension)
-    return vector_a, vector_b
-
-  def format_operand_latex(self, operand):
-    """Format a vector for LaTeX display."""
-    return self._format_vector(operand)
-
-  def format_single_equation(self, operand_a, operand_b):
-    """Format the equation for single questions."""
-    operand_a_latex = self.format_operand_latex(operand_a)
-    operand_b_latex = self.format_operand_latex(operand_b)
-    return f"{operand_a_latex} {self.get_operator()} {operand_b_latex}"
-
-  # Vector-specific overrides
-
-  def refresh(self, *args, **kwargs):
-    # Generate vector dimension first
-    self.dimension = self.rng.randint(self.MIN_DIMENSION, self.MAX_DIMENSION)
-
-    # Call parent refresh which will use our generate_operands method
-    super().refresh(*args, **kwargs)
-
-    self.vector_a = self.operand_a
-    self.vector_b = self.operand_b
-
-  def generate_subquestion_data(self):
-    """Generate LaTeX content for each subpart of the question.
-    Override to handle vector-specific keys in subquestion_data."""
-    subparts = []
-    for data in self.subquestion_data:
-      # Map generic operand names to vector names for compatibility
-      vector_a = data.get('vector_a', data['operand_a'])
-      vector_b = data.get('vector_b', data['operand_b'])
-
-      vector_a_latex = self._format_vector(vector_a)
-      vector_b_latex = self._format_vector(vector_b)
-      # Return as tuple of (matrix_a, operator, matrix_b)
-      subparts.append((vector_a_latex, self.get_operator(), vector_b_latex))
-    return subparts
+  @classmethod
+  def _build_context(cls, *, rng_seed=None, **kwargs):
+    rng = random.Random(rng_seed)
+    num_subquestions = kwargs.get("num_subquestions", 1)
+    if num_subquestions > 1:
+      raise NotImplementedError("Multipart not supported")
+
+    dimension = kwargs.get("dimension", rng.randint(cls.MIN_DIMENSION, cls.MAX_DIMENSION))
+    vector_a = cls._generate_vector(rng, dimension)
+    vector_b = cls._generate_vector(rng, dimension)
+    result = cls.calculate_single_result(vector_a, vector_b)
+
+    return {
+      "dimension": dimension,
+      "vector_a": vector_a,
+      "vector_b": vector_b,
+      "result": result,
+      "num_subquestions": num_subquestions,
+    }
 
   # Abstract methods that subclasses must still implement
+  @staticmethod
   @abc.abstractmethod
-  def get_operator(self):
+  def get_operator():
     """Return the LaTeX operator for this operation."""
     pass
 
+  @staticmethod
   @abc.abstractmethod
-  def calculate_single_result(self, vector_a, vector_b):
+  def calculate_single_result(vector_a, vector_b):
     """Calculate the result for a single question with two vectors."""
     pass
 
@@ -108,27 +86,32 @@ class VectorAddition(VectorMathQuestion):
   MIN_DIMENSION = 2
   MAX_DIMENSION = 4
 
-  def get_operator(self):
+  @staticmethod
+  def get_operator():
     return "+"
 
-  def calculate_single_result(self, vector_a, vector_b):
+  @staticmethod
+  def calculate_single_result(vector_a, vector_b):
     return [vector_a[i] + vector_b[i] for i in range(len(vector_a))]
 
   def create_subquestion_answers(self, subpart_index, result):
     raise NotImplementedError("Multipart not supported")
 
   def create_single_answers(self, result):
-    self.answers["result"] = ca.AnswerTypes.Vector(result)
+    answer = ca.AnswerTypes.Vector(result)
+    self._single_answer = answer
+    return [answer]
 
-  def _get_body(self):
+  @classmethod
+  def _build_body(cls, context):
     """Build question body and collect answers."""
     body = ca.Section()
 
-    body.add_element(ca.Paragraph([self.get_intro_text()]))
+    body.add_element(ca.Paragraph(["Calculate the following:"]))
 
     # Equation display using MathExpression for format-independent rendering
-    vector_a_elem = self._format_vector(self.vector_a)
-    vector_b_elem = self._format_vector(self.vector_b)
+    vector_a_elem = cls._format_vector(context["vector_a"])
+    vector_b_elem = cls._format_vector(context["vector_b"])
     body.add_element(ca.MathExpression([
         vector_a_elem,
         " + ",
@@ -136,24 +119,27 @@ class VectorAddition(VectorMathQuestion):
         " = "
     ]))
 
-    # Canvas-only answer field - use stored answer for consistent UUID
-    answer = self.answers["result"]
+    answer = ca.AnswerTypes.Vector(context["result"])
     body.add_element(ca.OnlyHtml([ca.Paragraph(["Enter your answer as a column vector:"])]))
     body.add_element(ca.OnlyHtml([answer]))
 
-    return body, list(self.answers.values())
+    return body, [answer]
 
-  def _get_explanation(self):
+  @classmethod
+  def _build_explanation(cls, context):
     """Build question explanation."""
     explanation = ca.Section()
 
     explanation.add_element(ca.Paragraph(["To add vectors, we add corresponding components:"]))
 
     # Use LaTeX syntax for make_block_equation__multiline_equals
-    vector_a_str = r" \\ ".join([str(v) for v in self.vector_a])
-    vector_b_str = r" \\ ".join([str(v) for v in self.vector_b])
-    result_str = r" \\ ".join([str(v) for v in self.result])
-    addition_str = r" \\ ".join([f"{self.vector_a[i]}+{self.vector_b[i]}" for i in range(self.dimension)])
+    vector_a_str = r" \\ ".join([str(v) for v in context["vector_a"]])
+    vector_b_str = r" \\ ".join([str(v) for v in context["vector_b"]])
+    result_str = r" \\ ".join([str(v) for v in context["result"]])
+    addition_str = r" \\ ".join([
+      f"{context['vector_a'][i]}+{context['vector_b'][i]}"
+      for i in range(context["dimension"])
+    ])
 
     explanation.add_element(
         ca.Equation.make_block_equation__multiline_equals(
@@ -175,66 +161,87 @@ class VectorScalarMultiplication(VectorMathQuestion):
   MIN_DIMENSION = 2
   MAX_DIMENSION = 4
 
-  def _generate_scalar(self):
+  @classmethod
+  def _build_context(cls, *, rng_seed=None, **kwargs):
+    rng = random.Random(rng_seed)
+    num_subquestions = kwargs.get("num_subquestions", 1)
+    if num_subquestions > 1:
+      raise NotImplementedError("Multipart not supported")
+
+    dimension = kwargs.get("dimension", rng.randint(cls.MIN_DIMENSION, cls.MAX_DIMENSION))
+    vector_a = cls._generate_vector(rng, dimension)
+    scalar = cls._generate_scalar(rng)
+    result = cls.calculate_single_result(vector_a, scalar)
+
+    return {
+      "dimension": dimension,
+      "vector_a": vector_a,
+      "scalar": scalar,
+      "result": result,
+      "num_subquestions": num_subquestions,
+    }
+
+  @staticmethod
+  def _generate_scalar(rng):
     """Generate a non-zero scalar for multiplication."""
-    scalar = self.rng.randint(-5, 5)
+    scalar = rng.randint(-5, 5)
     while scalar == 0:
-      scalar = self.rng.randint(-5, 5)
+      scalar = rng.randint(-5, 5)
     return scalar
 
-  def refresh(self, *args, **kwargs):
-    # Generate scalar first, then call parent refresh
-    self.scalar = self._generate_scalar()
-    super().refresh(*args, **kwargs)
-
-  def get_operator(self):
-    return f"{self.scalar} \\cdot"
+  @staticmethod
+  def get_operator():
+    return "\\cdot"
 
-  def calculate_single_result(self, vector_a, vector_b):
-    return [self.scalar * component for component in vector_a]
+  @staticmethod
+  def calculate_single_result(vector_a, vector_b):
+    return [vector_b * component for component in vector_a]
 
   def create_subquestion_answers(self, subpart_index, result):
     raise NotImplementedError("Multipart not supported")
 
   def create_single_answers(self, result):
-    self.answers["result"] = ca.AnswerTypes.Vector(result)
+    answer = ca.AnswerTypes.Vector(result)
+    self._single_answer = answer
+    return [answer]
 
-  def _get_body(self):
+  @classmethod
+  def _build_body(cls, context):
     """Build question body and collect answers."""
     body = ca.Section()
 
-    body.add_element(ca.Paragraph([self.get_intro_text()]))
+    body.add_element(ca.Paragraph(["Calculate the following:"]))
 
     # Equation display using MathExpression
-    vector_elem = self._format_vector(self.vector_a)
+    vector_elem = cls._format_vector(context["vector_a"])
     body.add_element(ca.MathExpression([
-        f"{self.scalar} \\cdot ",
+        f"{context['scalar']} \\cdot ",
         vector_elem,
         " = "
     ]))
 
-    # Canvas-only answer field - use stored answer
-    answer = self.answers["result"]
+    answer = ca.AnswerTypes.Vector(context["result"])
     body.add_element(ca.OnlyHtml([ca.Paragraph(["Enter your answer as a column vector:"])]))
     body.add_element(ca.OnlyHtml([answer]))
 
-    return body, list(self.answers.values())
+    return body, [answer]
 
-  def _get_explanation(self):
+  @classmethod
+  def _build_explanation(cls, context):
     """Build question explanation."""
     explanation = ca.Section()
 
     explanation.add_element(ca.Paragraph(["To multiply a vector by a scalar, we multiply each component by the scalar:"]))
 
-    vector_str = r" \\ ".join([str(v) for v in self.vector_a])
-    multiplication_str = r" \\ ".join([f"{self.scalar} \\cdot {v}" for v in self.vector_a])
-    result_str = r" \\ ".join([str(v) for v in self.result])
+    vector_str = r" \\ ".join([str(v) for v in context["vector_a"]])
+    multiplication_str = r" \\ ".join([f"{context['scalar']} \\cdot {v}" for v in context["vector_a"]])
+    result_str = r" \\ ".join([str(v) for v in context["result"]])
 
     explanation.add_element(
         ca.Equation.make_block_equation__multiline_equals(
-            lhs=f"{self.scalar} \\cdot \\vec{{v}}",
+            lhs=f"{context['scalar']} \\cdot \\vec{{v}}",
             rhs=[
-                f"{self.scalar} \\cdot \\begin{{bmatrix}} {vector_str} \\end{{bmatrix}}",
+                f"{context['scalar']} \\cdot \\begin{{bmatrix}} {vector_str} \\end{{bmatrix}}",
                 f"\\begin{{bmatrix}} {multiplication_str} \\end{{bmatrix}}",
                 f"\\begin{{bmatrix}} {result_str} \\end{{bmatrix}}"
             ]
@@ -250,27 +257,32 @@ class VectorDotProduct(VectorMathQuestion):
   MIN_DIMENSION = 2
   MAX_DIMENSION = 4
 
-  def get_operator(self):
+  @staticmethod
+  def get_operator():
     return "\\cdot"
 
-  def calculate_single_result(self, vector_a, vector_b):
+  @staticmethod
+  def calculate_single_result(vector_a, vector_b):
     return sum(vector_a[i] * vector_b[i] for i in range(len(vector_a)))
 
   def create_subquestion_answers(self, subpart_index, result):
     raise NotImplementedError("Multipart not supported")
 
   def create_single_answers(self, result):
-    self.answers["dot_product"] = ca.AnswerTypes.Int(result)
+    answer = ca.AnswerTypes.Int(result)
+    self._single_answer = answer
+    return [answer]
 
-  def _get_body(self):
+  @classmethod
+  def _build_body(cls, context):
     """Build question body and collect answers."""
     body = ca.Section()
 
-    body.add_element(ca.Paragraph([self.get_intro_text()]))
+    body.add_element(ca.Paragraph(["Calculate the following:"]))
 
     # Equation display using MathExpression
-    vector_a_elem = self._format_vector(self.vector_a)
-    vector_b_elem = self._format_vector(self.vector_b)
+    vector_a_elem = cls._format_vector(context["vector_a"])
+    vector_b_elem = cls._format_vector(context["vector_b"])
     body.add_element(ca.MathExpression([
         vector_a_elem,
         " \\cdot ",
@@ -278,22 +290,28 @@ class VectorDotProduct(VectorMathQuestion):
         " = "
     ]))
 
-    # Canvas-only answer field - use stored answer
-    answer = self.answers["dot_product"]
+    answer = ca.AnswerTypes.Int(context["result"])
     body.add_element(ca.OnlyHtml([answer]))
 
-    return body, list(self.answers.values())
+    return body, [answer]
 
-  def _get_explanation(self):
+  @classmethod
+  def _build_explanation(cls, context):
     """Build question explanation."""
     explanation = ca.Section()
 
     explanation.add_element(ca.Paragraph(["The dot product is calculated by multiplying corresponding components and summing the results:"]))
 
-    vector_a_str = r" \\ ".join([str(v) for v in self.vector_a])
-    vector_b_str = r" \\ ".join([str(v) for v in self.vector_b])
-    products_str = " + ".join([f"({self.vector_a[i]} \\cdot {self.vector_b[i]})" for i in range(self.dimension)])
-    calculation_str = " + ".join([str(self.vector_a[i] * self.vector_b[i]) for i in range(self.dimension)])
+    vector_a_str = r" \\ ".join([str(v) for v in context["vector_a"]])
+    vector_b_str = r" \\ ".join([str(v) for v in context["vector_b"]])
+    products_str = " + ".join([
+      f"({context['vector_a'][i]} \\cdot {context['vector_b'][i]})"
+      for i in range(context["dimension"])
+    ])
+    calculation_str = " + ".join([
+      str(context["vector_a"][i] * context["vector_b"][i])
+      for i in range(context["dimension"])
+    ])
 
     explanation.add_element(
         ca.Equation.make_block_equation__multiline_equals(
@@ -302,7 +320,7 @@ class VectorDotProduct(VectorMathQuestion):
                 f"\\begin{{bmatrix}} {vector_a_str} \\end{{bmatrix}} \\cdot \\begin{{bmatrix}} {vector_b_str} \\end{{bmatrix}}",
                 products_str,
                 calculation_str,
-                str(self.result)
+                str(context["result"])
             ]
           )
       )
@@ -316,10 +334,12 @@ class VectorMagnitude(VectorMathQuestion):
   MIN_DIMENSION = 2
   MAX_DIMENSION = 3
 
-  def get_operator(self):
+  @staticmethod
+  def get_operator():
     return "||"
 
-  def calculate_single_result(self, vector_a, vector_b):
+  @staticmethod
+  def calculate_single_result(vector_a, vector_b):
     magnitude_squared = sum(component ** 2 for component in vector_a)
     return math.sqrt(magnitude_squared)
 
@@ -327,29 +347,32 @@ class VectorMagnitude(VectorMathQuestion):
     raise NotImplementedError("Multipart not supported")
 
   def create_single_answers(self, result):
-    self.answers["magnitude"] = ca.AnswerTypes.Float(result)
+    answer = ca.AnswerTypes.Float(result)
+    self._single_answer = answer
+    return [answer]
 
-  def _get_body(self):
+  @classmethod
+  def _build_body(cls, context):
     """Build question body and collect answers."""
     body = ca.Section()
 
-    body.add_element(ca.Paragraph([self.get_intro_text()]))
+    body.add_element(ca.Paragraph(["Calculate the following:"]))
 
     # Equation display using MathExpression
-    vector_elem = self._format_vector(self.vector_a)
+    vector_elem = cls._format_vector(context["vector_a"])
     body.add_element(ca.MathExpression([
         "||",
         vector_elem,
         "|| = "
     ]))
 
-    # Canvas-only answer field - use stored answer
-    answer = self.answers["magnitude"]
+    answer = ca.AnswerTypes.Float(context["result"])
     body.add_element(ca.OnlyHtml([answer]))
 
-    return body, list(self.answers.values())
+    return body, [answer]
 
-  def _get_explanation(self):
+  @classmethod
+  def _build_explanation(cls, context):
     """Build question explanation."""
     explanation = ca.Section()
 
@@ -359,11 +382,11 @@ class VectorMagnitude(VectorMathQuestion):
     ))
 
     # Use LaTeX syntax for make_block_equation__multiline_equals
-    vector_str = r" \\ ".join([str(v) for v in self.vector_a])
-    squares_str = " + ".join([f"{v}^2" for v in self.vector_a])
-    calculation_str = " + ".join([str(v**2) for v in self.vector_a])
-    sum_of_squares = sum(component ** 2 for component in self.vector_a)
-    result_formatted = sorted(ca.Answer.accepted_strings(self.result), key=lambda s: len(s))[0]
+    vector_str = r" \\ ".join([str(v) for v in context["vector_a"]])
+    squares_str = " + ".join([f"{v}^2" for v in context["vector_a"]])
+    calculation_str = " + ".join([str(v**2) for v in context["vector_a"]])
+    sum_of_squares = sum(component ** 2 for component in context["vector_a"])
+    result_formatted = sorted(ca.Answer.accepted_strings(context["result"]), key=lambda s: len(s))[0]
 
     explanation.add_element(
         ca.Equation.make_block_equation__multiline_equals(

QuizGenerator/premade_questions/cst463/models/attention.py

@@ -40,33 +40,35 @@ class AttentionForwardPass(MatrixQuestion, TableQuestionMixin):
     
     return output, attention_weights
   
-  def refresh(self, *args, **kwargs):
-    super().refresh(*args, **kwargs)
-    
-    seq_len = kwargs.get("seq_len", 3)
-    d_k = kwargs.get("key_dimension", 1)  # key/query dimension
-    d_v = kwargs.get("value_dimension", 1)  # value dimension
-    
-    # Small integer matrices
-    self.Q = self.rng.randint(0, 3, size=(seq_len, d_k))
-    self.K = self.rng.randint(0, 3, size=(seq_len, d_k))
-    self.V = self.rng.randint(0, 3, size=(seq_len, d_v))
-
-    self.Q = self.get_rounded_matrix((seq_len, d_k), 0, 3)
-    self.K = self.get_rounded_matrix((seq_len, d_k), 0, 3)
-    self.V = self.get_rounded_matrix((seq_len, d_v), 0, 3)
-    
-    self.output, self.weights = self.simple_attention(self.Q, self.K, self.V)
-    
-    ## Answers:
-    # Q, K, V, output, weights
+  @classmethod
+  def _build_context(cls, *, rng_seed=None, **kwargs):
+    rng = cls.get_rng(rng_seed)
+    digits = cls.get_digits_to_round(digits_to_round=kwargs.get("digits_to_round"))
 
-    self.answers["weights"] = ca.AnswerTypes.Matrix(self.weights, label="Weights")
-    self.answers["output"] = ca.AnswerTypes.Matrix(self.output, label="Output")
-    
-    return True
-  
-  def _get_body(self, **kwargs) -> Tuple[ca.Section, List[ca.Answer]]:
+    seq_len = kwargs.get("seq_len", 3)
+    d_k = kwargs.get("key_dimension", 1)
+    d_v = kwargs.get("value_dimension", 1)
+
+    Q = cls.get_rounded_matrix(rng, (seq_len, d_k), 0, 3, digits)
+    K = cls.get_rounded_matrix(rng, (seq_len, d_k), 0, 3, digits)
+    V = cls.get_rounded_matrix(rng, (seq_len, d_v), 0, 3, digits)
+
+    output, weights = cls.simple_attention(Q, K, V)
+
+    return {
+      "digits": digits,
+      "seq_len": seq_len,
+      "d_k": d_k,
+      "d_v": d_v,
+      "Q": Q,
+      "K": K,
+      "V": V,
+      "output": output,
+      "weights": weights,
+    }
+
+  @classmethod
+  def _build_body(cls, context) -> Tuple[ca.Section, List[ca.Answer]]:
     """Build question body and collect answers."""
     body = ca.Section()
     answers = []
@@ -75,32 +77,30 @@ class AttentionForwardPass(MatrixQuestion, TableQuestionMixin):
       ca.Text("Given the below information about a self attention layer, please calculate the output sequence.")
     )
     body.add_element(
-      self.create_info_table(
+      cls.create_info_table(
         {
-          "Q": ca.Matrix(self.Q),
-          "K": ca.Matrix(self.K),
-          "V": ca.Matrix(self.V),
+          "Q": ca.Matrix(context["Q"]),
+          "K": ca.Matrix(context["K"]),
+          "V": ca.Matrix(context["V"]),
         }
       )
     )
 
-    answers.append(self.answers["weights"])
-    answers.append(self.answers["output"])
+    weights_answer = ca.AnswerTypes.Matrix(context["weights"], label="Weights")
+    output_answer = ca.AnswerTypes.Matrix(context["output"], label="Output")
+    answers.append(weights_answer)
+    answers.append(output_answer)
     body.add_elements([
       ca.LineBreak(),
-      self.answers["weights"],
+      weights_answer,
       ca.LineBreak(),
-      self.answers["output"],
+      output_answer,
     ])
 
     return body, answers
 
-  def get_body(self, **kwargs) -> ca.Section:
-    """Build question body (backward compatible interface)."""
-    body, _ = self._get_body(**kwargs)
-    return body
-  
-  def _get_explanation(self, **kwargs) -> Tuple[ca.Section, List[ca.Answer]]:
+  @classmethod
+  def _build_explanation(cls, context) -> Tuple[ca.Section, List[ca.Answer]]:
     """Build question explanation."""
     explanation = ca.Section()
     digits = ca.Answer.DEFAULT_ROUNDING_DIGITS
@@ -118,12 +118,12 @@ class AttentionForwardPass(MatrixQuestion, TableQuestionMixin):
       ])
     )
 
-    d_k = self.Q.shape[1]
+    d_k = context["Q"].shape[1]
     explanation.add_element(
       ca.Equation(f"\\text{{scores}} = \\frac{{Q K^T}}{{\\sqrt{{d_k}}}} = \\frac{{Q K^T}}{{\\sqrt{{{d_k}}}}}")
     )
 
-    scores = self.Q @ self.K.T / np.sqrt(d_k)
+    scores = context["Q"] @ context["K"].T / np.sqrt(d_k)
 
     explanation.add_element(
       ca.Paragraph([
@@ -178,7 +178,7 @@ class AttentionForwardPass(MatrixQuestion, TableQuestionMixin):
         "Complete attention weight matrix:"
       ])
     )
-    explanation.add_element(ca.Matrix(np.round(self.weights, digits)))
+    explanation.add_element(ca.Matrix(np.round(context["weights"], digits)))
 
     # Step 3: Weighted sum of values
     explanation.add_element(
@@ -196,12 +196,6 @@ class AttentionForwardPass(MatrixQuestion, TableQuestionMixin):
         "Final output:"
       ])
     )
-    explanation.add_element(ca.Matrix(np.round(self.output, digits)))
+    explanation.add_element(ca.Matrix(np.round(context["output"], digits)))
 
     return explanation, []
-
-  def get_explanation(self, **kwargs) -> ca.Section:
-    """Build question explanation (backward compatible interface)."""
-    explanation, _ = self._get_explanation(**kwargs)
-    return explanation
-