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

QuizGenerator/mixins.py

@@ -68,19 +68,20 @@ class TableQuestionMixin:
     """
     answer_columns = answer_columns or []
     
-    def format_cell(row_data: Dict, column: str) -> Union[str, ContentAST.Answer]:
+    def format_cell(row_data: Dict, column: str) -> Union[str, Answer]:
       """Format a cell based on whether it should be an answer or plain data"""
       value = row_data.get(column, "")
-      
+
       # If this column should contain answers and the value is an Answer object
+      # Answer extends ContentAST.Leaf, so it can be used directly
       if column in answer_columns and isinstance(value, Answer):
-        return ContentAST.Answer(value)
+        return value
       # If this column should contain answers but we have the answer key
       elif column in answer_columns and isinstance(value, str) and hasattr(self, 'answers'):
         answer_obj = self.answers.get(value)
         if answer_obj:
-          return ContentAST.Answer(answer_obj)
-      
+          return answer_obj
+
       # Otherwise return as plain data
       return str(value)
     
@@ -119,9 +120,9 @@ class TableQuestionMixin:
     # Build data with parameters plus answer row
     data = [[key, str(value)] for key, value in parameter_info.items()]
     
-    # Add answer row
+    # Add answer row - Answer extends ContentAST.Leaf so it can be used directly
     if hasattr(self, 'answers') and answer_key in self.answers:
-      data.append([answer_label, ContentAST.Answer(self.answers[answer_key])])
+      data.append([answer_label, self.answers[answer_key]])
     else:
       data.append([answer_label, f"[{answer_key}]"])  # Fallback
     
@@ -149,16 +150,17 @@ class TableQuestionMixin:
         ContentAST.Table with multiple answer blanks
     """
     
-    def process_cell_value(value: Any) -> Union[str, ContentAST.Answer]:
+    def process_cell_value(value: Any) -> Union[str, Answer]:
       """Convert cell values to appropriate display format"""
-      # If it's already an Answer object, wrap it
+      # If it's already an Answer object, use it directly
+      # Answer extends ContentAST.Leaf so it can be used in the AST
       if isinstance(value, Answer):
-        return ContentAST.Answer(value)
+        return value
       # If it's a string that looks like an answer key, try to resolve it
       elif isinstance(value, str) and value.startswith("answer__") and hasattr(self, 'answers'):
         answer_obj = self.answers.get(value)
         if answer_obj:
-          return ContentAST.Answer(answer_obj)
+          return answer_obj
       # Otherwise return as-is
       return str(value)
     
@@ -493,37 +495,52 @@ class MathOperationQuestion(MultiPartQuestionMixin, abc.ABC):
       subparts.append((operand_a_latex, self.get_operator(), operand_b_latex))
     return subparts
   
-  def get_body(self):
+  def _get_body(self):
+    """Build question body and collect answers."""
     body = ContentAST.Section()
-    
+    answers = []
+
     body.add_element(ContentAST.Paragraph([self.get_intro_text()]))
-    
+
     if self.is_multipart():
       # Use multipart formatting with repeated problem parts
       subpart_data = self.generate_subquestion_data()
       repeated_part = self.create_repeated_problem_part(subpart_data)
       body.add_element(repeated_part)
+      # Collect answers from self.answers dict
+      answers = list(self.answers.values())
     else:
       # Single equation display
       equation_latex = self.format_single_equation(self.operand_a, self.operand_b)
       body.add_element(ContentAST.Equation(f"{equation_latex} = ", inline=False))
-      
+
       # Canvas-only answer fields (hidden from PDF)
-      self._add_single_question_answers(body)
-    
+      single_answers = self._add_single_question_answers(body)
+      if single_answers:
+        answers.extend(single_answers)
+
+    return body, answers
+
+  def get_body(self):
+    """Build question body (backward compatible interface)."""
+    body, _ = self._get_body()
     return body
-  
+
   def _add_single_question_answers(self, body):
-    """Add Canvas-only answer fields for single questions. Subclasses can override."""
+    """Add Canvas-only answer fields for single questions. Subclasses can override.
+
+    Returns:
+        List of Answer objects that were added to the body.
+    """
     # Default implementation - subclasses should override for specific answer formats
-    pass
-  
-  def get_explanation(self):
+    return []
+
+  def _get_explanation(self):
     """Default explanation structure. Subclasses should override for specific explanations."""
     explanation = ContentAST.Section()
-    
+
     explanation.add_element(ContentAST.Paragraph([self.get_explanation_intro()]))
-    
+
     if self.is_multipart():
       # Handle multipart explanations
       for i, data in enumerate(self.subquestion_data):
@@ -532,7 +549,12 @@ class MathOperationQuestion(MultiPartQuestionMixin, abc.ABC):
     else:
       # Single part explanation
       explanation.add_element(self.create_single_explanation())
-    
+
+    return explanation, []
+
+  def get_explanation(self):
+    """Build question explanation (backward compatible interface)."""
+    explanation, _ = self._get_explanation()
     return explanation
   
   def get_explanation_intro(self):

QuizGenerator/premade_questions/cst334/languages.py

@@ -155,115 +155,115 @@ class ValidStringsInLanguageQuestion(LanguageQuestion):
 
     super().__init__(*args, **kwargs)
 
-    if grammar_str_good is not None and grammar_str_bad is not None:
+    # Store whether grammars are fixed (provided) or should be randomized
+    self.fixed_grammars = grammar_str_good is not None and grammar_str_bad is not None
+    if self.fixed_grammars:
       self.grammar_str_good = grammar_str_good
       self.grammar_str_bad = grammar_str_bad
       self.include_spaces = kwargs.get("include_spaces", False)
       self.MAX_LENGTH = kwargs.get("max_length", 30)
-    else:
-      which_grammar = self.rng.choice(range(4))
-      
-      if which_grammar == 0:
-        # todo: make a few different kinds of grammars that could be picked
-        self.grammar_str_good = """
-          <expression> ::= <term> | <expression> + <term> | <expression> - <term>
-          <term>       ::= <factor> | <term> * <factor> | <term> / <factor>
-          <factor>     ::= <number>
-          <number>     ::= <digit> | <number> <digit>
-          <digit>      ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
-        """
-        # Adding in a plus to number
-        self.grammar_str_bad = """
-          <expression> ::= <term> | <expression> + <term> | <expression> - <term>
-          <term>       ::= <factor> | <term> * <factor> | <term> / <factor>
-          <factor>     ::= <number>
-          <number>     ::= <digit> + | <digit> <number>
-          <digit>      ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
-        """
-        self.include_spaces = False
-        self.MAX_LENGTH = 30
-      elif which_grammar == 1:
-        self.grammar_str_good = """
-          <sentence> ::= <subject> <verb> <object>
-          <subject> ::= The cat | A dog | The bird | A child | <adjective> <animal>
-          <animal> ::= cat | dog | bird | child
-          <adjective> ::= happy | sad | angry | playful
-          <verb> ::= chases | sees | hates | loves
-          <object> ::= the ball | the toy | the tree | <adjective> <object>
-        """
-        self.grammar_str_bad = """
-          <sentence> ::= <subject> <verb> <object>
-          <subject> ::= The human | The dog | A bird | Some child | A <adjective> <animal>
-          <animal> ::= cat | dog | bird | child
-          <adjective> ::= happy | sad | angry | playful
-          <verb> ::= chases | sees | hates | loves
-          <object> ::= the ball | the toy | the tree | <adjective> <object>
-        """
-        self.include_spaces = True
-        self.MAX_LENGTH = 100
-      elif which_grammar == 2:
-        self.grammar_str_good = """
-          <poem> ::= <line> | <line> <poem>
-          <line> ::= <subject> <verb> <object> <modifier>
-          <subject> ::= whispers | shadows | dreams | echoes | <compound-subject>
-          <compound-subject> ::= <subject> and <subject>
-          <verb> ::= dance | dissolve | shimmer | collapse | <compound-verb>
-          <compound-verb> ::= <verb> then <verb>
-          <object> ::= beneath | between | inside | around | <compound-object>
-          <compound-object> ::= <object> through <object>
-          <modifier> ::= silently | violently | mysteriously | endlessly | <recursive-modifier>
-          <recursive-modifier> ::= <modifier> and <modifier>
-        """
-        self.grammar_str_bad = """
-          <bad-poem> ::= <almost-valid-line> | <bad-poem> <bad-poem>
-          <almost-valid-line> ::= <tricky-subject> <tricky-verb> <tricky-object> <tricky-modifier>
-          <tricky-subject> ::= whispers | shadows and and | <duplicate-subject>
-          <duplicate-subject> ::= whispers whispers
-          <tricky-verb> ::= dance | <incorrect-verb-placement> | <verb-verb>
-          <incorrect-verb-placement> ::= dance dance
-          <verb-verb> ::= dance whispers
-          <tricky-object> ::= beneath | <object-verb-swap> | <duplicate-object>
-          <object-verb-swap> ::= dance beneath
-          <duplicate-object> ::= beneath beneath
-          <tricky-modifier> ::= silently | <modifier-subject-swap> | <duplicate-modifier>
-          <modifier-subject-swap> ::= whispers silently
-          <duplicate-modifier> ::= silently silently
-        """
-        self.include_spaces = True
-        self.MAX_LENGTH = 100
-      elif which_grammar == 3:
-        self.grammar_str_good = """
-          <A> ::= a <B> a |
-          <B> ::= b <C> b |
-          <C> ::= c <A> c |
-        """
-        self.grammar_str_bad = """
-          <A> ::= a <B> c
-          <B> ::= b <C> a |
-          <C> ::= c <A> b |
-        """
-        self.include_spaces = False
-        self.MAX_LENGTH = 100
-    
-    self.grammar_good = BNF.parse_bnf(self.grammar_str_good, self.rng)
-    self.grammar_bad = BNF.parse_bnf(self.grammar_str_bad, self.rng)
-    
-    self.num_answer_options = kwargs.get("num_answer_options", 4)
-    self.num_answer_blanks = kwargs.get("num_answer_blanks", 4)
-  
-  def refresh(self, *args, **kwargs):
-    super().refresh(*args, **kwargs)
-    
-    self.answers = {}
-    
+      self.grammar_good = BNF.parse_bnf(self.grammar_str_good, self.rng)
+      self.grammar_bad = BNF.parse_bnf(self.grammar_str_bad, self.rng)
+
     self.num_answer_options = kwargs.get("num_answer_options", 4)
     self.num_answer_blanks = kwargs.get("num_answer_blanks", 4)
-    
-    self.refresh()
+
+  def _select_random_grammar(self):
+    """Select and set a random grammar. Called from refresh() to ensure each PDF gets different grammar."""
+    which_grammar = self.rng.choice(range(4))
+
+    if which_grammar == 0:
+      # todo: make a few different kinds of grammars that could be picked
+      self.grammar_str_good = """
+        <expression> ::= <term> | <expression> + <term> | <expression> - <term>
+        <term>       ::= <factor> | <term> * <factor> | <term> / <factor>
+        <factor>     ::= <number>
+        <number>     ::= <digit> | <number> <digit>
+        <digit>      ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+      """
+      # Adding in a plus to number
+      self.grammar_str_bad = """
+        <expression> ::= <term> | <expression> + <term> | <expression> - <term>
+        <term>       ::= <factor> | <term> * <factor> | <term> / <factor>
+        <factor>     ::= <number>
+        <number>     ::= <digit> + | <digit> <number>
+        <digit>      ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+      """
+      self.include_spaces = False
+      self.MAX_LENGTH = 30
+    elif which_grammar == 1:
+      self.grammar_str_good = """
+        <sentence> ::= <subject> <verb> <object>
+        <subject> ::= The cat | A dog | The bird | A child | <adjective> <animal>
+        <animal> ::= cat | dog | bird | child
+        <adjective> ::= happy | sad | angry | playful
+        <verb> ::= chases | sees | hates | loves
+        <object> ::= the ball | the toy | the tree | <adjective> <object>
+      """
+      self.grammar_str_bad = """
+        <sentence> ::= <subject> <verb> <object>
+        <subject> ::= The human | The dog | A bird | Some child | A <adjective> <animal>
+        <animal> ::= cat | dog | bird | child
+        <adjective> ::= happy | sad | angry | playful
+        <verb> ::= chases | sees | hates | loves
+        <object> ::= the ball | the toy | the tree | <adjective> <object>
+      """
+      self.include_spaces = True
+      self.MAX_LENGTH = 100
+    elif which_grammar == 2:
+      self.grammar_str_good = """
+        <poem> ::= <line> | <line> <poem>
+        <line> ::= <subject> <verb> <object> <modifier>
+        <subject> ::= whispers | shadows | dreams | echoes | <compound-subject>
+        <compound-subject> ::= <subject> and <subject>
+        <verb> ::= dance | dissolve | shimmer | collapse | <compound-verb>
+        <compound-verb> ::= <verb> then <verb>
+        <object> ::= beneath | between | inside | around | <compound-object>
+        <compound-object> ::= <object> through <object>
+        <modifier> ::= silently | violently | mysteriously | endlessly | <recursive-modifier>
+        <recursive-modifier> ::= <modifier> and <modifier>
+      """
+      self.grammar_str_bad = """
+        <bad-poem> ::= <almost-valid-line> | <bad-poem> <bad-poem>
+        <almost-valid-line> ::= <tricky-subject> <tricky-verb> <tricky-object> <tricky-modifier>
+        <tricky-subject> ::= whispers | shadows and and | <duplicate-subject>
+        <duplicate-subject> ::= whispers whispers
+        <tricky-verb> ::= dance | <incorrect-verb-placement> | <verb-verb>
+        <incorrect-verb-placement> ::= dance dance
+        <verb-verb> ::= dance whispers
+        <tricky-object> ::= beneath | <object-verb-swap> | <duplicate-object>
+        <object-verb-swap> ::= dance beneath
+        <duplicate-object> ::= beneath beneath
+        <tricky-modifier> ::= silently | <modifier-subject-swap> | <duplicate-modifier>
+        <modifier-subject-swap> ::= whispers silently
+        <duplicate-modifier> ::= silently silently
+      """
+      self.include_spaces = True
+      self.MAX_LENGTH = 100
+    elif which_grammar == 3:
+      self.grammar_str_good = """
+        <A> ::= a <B> a |
+        <B> ::= b <C> b |
+        <C> ::= c <A> c |
+      """
+      self.grammar_str_bad = """
+        <A> ::= a <B> c
+        <B> ::= b <C> a |
+        <C> ::= c <A> b |
+      """
+      self.include_spaces = False
+      self.MAX_LENGTH = 100
+
+    self.grammar_good = BNF.parse_bnf(self.grammar_str_good, self.rng)
+    self.grammar_bad = BNF.parse_bnf(self.grammar_str_bad, self.rng)
   
   def refresh(self, *args, **kwargs):
     super().refresh(*args, **kwargs)
-    
+
+    # Re-select random grammar for each refresh if not using fixed grammars
+    if not self.fixed_grammars:
+      self._select_random_grammar()
+
     self.answers = {}
     
     self.answers.update(
@@ -337,46 +337,55 @@ class ValidStringsInLanguageQuestion(LanguageQuestion):
       )
   
   
-  def get_body(self, *args, **kwargs) -> ContentAST.Section:
+  def _get_body(self, *args, **kwargs):
+    """Build question body and collect answers."""
+    answers = list(self.answers.values())
+
     body = ContentAST.Section()
-    
-    body.add_elements([
-      ContentAST.Paragraph([
-        ContentAST.OnlyHtml([
-          ContentAST.Text("Given the following grammar, which of the below strings are part of the language?")
-        ]),
-        ContentAST.OnlyLatex([
-          ContentAST.Text(
-            "Given the following grammar "
-            "please circle any provided strings that are part of the language (or indicate clearly if there are none), "
-            "and on each blank line provide generate a new, unique string that is part of the language."
-          )
+
+    body.add_element(
+      ContentAST.OnlyHtml([
+        ContentAST.Paragraph([
+          "Given the following grammar, which of the below strings are part of the language?"
         ])
       ])
-    ])
-    
-    body.add_element(
-      ContentAST.Code(self.grammar_good.get_grammar_string())
     )
-    
-    # Add in some answers as latex-only options to be circled
     body.add_element(
       ContentAST.OnlyLatex([
-        ContentAST.Text(f"- `{str(answer)}`")
-        for answer in self.featured_answers
+        ContentAST.Paragraph([
+          "Given the following grammar "
+          "please circle any provided strings that are part of the language (or indicate clearly if there are none), "
+          "and on each blank line provide generate a new, unique string that is part of the language."
+        ])
       ])
     )
-    
+
+    body.add_element(
+      ContentAST.Code(self.grammar_good.get_grammar_string())
+    )
+
+    # Add in some answers as latex-only options to be circled
+    latex_list = ContentAST.OnlyLatex([])
+    for answer in self.featured_answers:
+      latex_list.add_element(ContentAST.Paragraph([f"- `{str(answer)}`"]))
+    body.add_element(latex_list)
+
     # For Latex-only, ask students to generate some more.
     body.add_element(
       ContentAST.OnlyLatex([
-        ContentAST.AnswerBlock([ContentAST.Answer(Answer.string(f"blank_line_{i}", f"blank_line_{i}"), label=f"blank_line_{i}") for i in range(self.num_answer_blanks)])
+        ContentAST.AnswerBlock([Answer.string(f"blank_line_{i}", "", label="") for i in range(self.num_answer_blanks)])
       ])
     )
-    
+
+    return body, answers
+
+  def get_body(self, *args, **kwargs) -> ContentAST.Section:
+    """Build question body (backward compatible interface)."""
+    body, _ = self._get_body(*args, **kwargs)
     return body
   
-  def get_explanation(self, *args, **kwargs) -> ContentAST.Section:
+  def _get_explanation(self, *args, **kwargs):
+    """Build question explanation."""
     explanation = ContentAST.Section()
     explanation.add_element(
       ContentAST.Paragraph([
@@ -384,6 +393,11 @@ class ValidStringsInLanguageQuestion(LanguageQuestion):
         "Unfortunately, there isn't space here to demonstrate the derivation so please work through them on your own!"
       ])
     )
+    return explanation, []
+
+  def get_explanation(self, *args, **kwargs) -> ContentAST.Section:
+    """Build question explanation (backward compatible interface)."""
+    explanation, _ = self._get_explanation(*args, **kwargs)
     return explanation
 
   def get_answers(self, *args, **kwargs) -> Tuple[Answer.AnswerKind, List[Dict[str,Any]]]:

QuizGenerator/premade_questions/cst334/math_questions.py

@@ -31,11 +31,16 @@ class BitsAndBytes(MathQuestion):
     self.num_bytes = int(math.pow(2, self.num_bits))
     
     if self.from_binary:
-      self.answers = {"answer" : Answer.integer("num_bytes", self.num_bytes)}
+      self.answers = {"answer": Answer.integer("num_bytes", self.num_bytes,
+                                               label="Address space size", unit="Bytes")}
     else:
-      self.answers = {"answer" : Answer.integer("num_bits", self.num_bits)}
+      self.answers = {"answer": Answer.integer("num_bits", self.num_bits,
+                                               label="Number of bits in address", unit="bits")}
   
-  def get_body(self, **kwargs) -> ContentAST.Section:
+  def _get_body(self, **kwargs):
+    """Build question body and collect answers."""
+    answers = [self.answers['answer']]
+
     body = ContentAST.Section()
     body.add_element(
       ContentAST.Paragraph([
@@ -45,31 +50,17 @@ class BitsAndBytes(MathQuestion):
         f"{'do we need to address our memory' if not self.from_binary else 'of memory can be addressed'}?"
       ])
     )
-    
-    if self.from_binary:
-      body.add_element(
-        ContentAST.AnswerBlock(
-          ContentAST.Answer(
-            answer=self.answers['answer'],
-            label="Address space size",
-            unit="Bytes"
-          ),
-        )
-      )
-    else:
-      body.add_element(
-        ContentAST.AnswerBlock(
-          ContentAST.Answer(
-            answer=self.answers['answer'],
-            label="Number of bits in address",
-            unit="bits"
-          ),
-        )
-      )
-      
+
+    body.add_element(ContentAST.AnswerBlock(self.answers['answer']))
+
+    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):
     explanation = ContentAST.Section()
     
     explanation.add_element(
@@ -94,7 +85,12 @@ class BitsAndBytes(MathQuestion):
       explanation.add_element(
         ContentAST.Equation(f"log_{{2}}({self.num_bytes} \\text{{bytes}}) = \\textbf{{{self.num_bits}}}\\text{{bits}}")
       )
-    
+
+    return explanation, []
+
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    """Build question explanation (backward compatible interface)."""
+    explanation, _ = self._get_explanation(**kwargs)
     return explanation
 
 
@@ -115,13 +111,18 @@ class HexAndBinary(MathQuestion):
     self.binary_val = f"0b{self.value:0{4*self.number_of_hexits}b}"
     
     if self.from_binary:
-      self.answers['answer'] = Answer.string("hex_val", self.hex_val)
+      self.answers['answer'] = Answer.string("hex_val", self.hex_val,
+                                             label="Value in hex")
     else:
-      self.answers['answer'] = Answer.string("binary_val", self.binary_val)
+      self.answers['answer'] = Answer.string("binary_val", self.binary_val,
+                                             label="Value in binary")
   
-  def get_body(self, **kwargs) -> ContentAST.Section:
+  def _get_body(self, **kwargs):
+    """Build question body and collect answers."""
+    answers = [self.answers['answer']]
+
     body = ContentAST.Section()
-    
+
     body.add_element(
       ContentAST.Paragraph([
         f"Given the number {self.hex_val if not self.from_binary else self.binary_val} "
@@ -129,19 +130,17 @@ class HexAndBinary(MathQuestion):
         "Please include base indicator all padding zeros as appropriate (e.g. 0x01 should be 0b00000001)",
       ])
     )
-    
-    body.add_element(
-      ContentAST.AnswerBlock([
-        ContentAST.Answer(
-          answer = self.answers['answer'],
-          label=f"Value in {'hex' if self.from_binary else 'binary'}: ",
-        )
-      ])
-    )
-    
+
+    body.add_element(ContentAST.AnswerBlock(self.answers['answer']))
+
+    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):
     explanation = ContentAST.Section()
     
     paragraph = ContentAST.Paragraph([
@@ -188,10 +187,15 @@ class HexAndBinary(MathQuestion):
           f"Which gives us our binary value of: 0b{binary_str}"
         ])
       )
-      
+
+    return explanation, []
+
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    """Build question explanation (backward compatible interface)."""
+    explanation, _ = self._get_explanation(**kwargs)
     return explanation
-  
-  
+
+
 @QuestionRegistry.register()
 class AverageMemoryAccessTime(MathQuestion):
   
@@ -219,7 +223,8 @@ class AverageMemoryAccessTime(MathQuestion):
     self.amat = self.hit_rate * self.hit_latency + (1 - self.hit_rate) * self.miss_latency
     
     self.answers = {
-      "amat": Answer.float_value("answer__amat", self.amat)
+      "amat": Answer.float_value("answer__amat", self.amat,
+                                 label="Average Memory Access Time", unit="cycles")
     }
     
     # Finally, do the self.rngizing of the question, to avoid these being non-deterministic
@@ -228,9 +233,12 @@ class AverageMemoryAccessTime(MathQuestion):
     # At this point, everything in the question should be set.
     pass
   
-  def get_body(self, **kwargs) -> ContentAST.Section:
+  def _get_body(self, **kwargs):
+    """Build question body and collect answers."""
+    answers = [self.answers["amat"]]
+
     body = ContentAST.Section()
-    
+
     # Add in background information
     body.add_element(
       ContentAST.Paragraph([
@@ -245,32 +253,31 @@ class AverageMemoryAccessTime(MathQuestion):
       ["Hit Latency", f"{self.hit_latency} cycles"],
       ["Miss Latency", f"{self.miss_latency} cycles"]
     ]
-    
+
     # Add in either miss rate or hit rate -- we only need one of them
     if self.show_miss_rate:
       table_data.append(["Miss Rate", f"{100 * (1 - self.hit_rate): 0.2f}%"])
     else:
       table_data.append(["Hit Rate", f"{100 * self.hit_rate: 0.2f}%"])
-    
+
     body.add_element(
       ContentAST.Table(
         data=table_data
       )
     )
-    
-    body.add_element(
-      ContentAST.AnswerBlock([
-        ContentAST.Answer(
-          answer=self.answers["amat"],
-          label="Average Memory Access Time",
-          unit="cycles"
-        )
-      ])
-    )
-    
+
+    body.add_element(ContentAST.LineBreak())
+
+    body.add_element(ContentAST.AnswerBlock(self.answers["amat"]))
+
+    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):
     explanation = ContentAST.Section()
     
     # Add in General explanation
@@ -292,6 +299,11 @@ class AverageMemoryAccessTime(MathQuestion):
         ]
       )
     )
-    
+
+    return explanation, []
+
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    """Build question explanation (backward compatible interface)."""
+    explanation, _ = self._get_explanation(**kwargs)
     return explanation