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

QuizGenerator/premade_questions/cst463/gradient_descent/gradient_descent_questions.py

@@ -15,6 +15,11 @@ from .misc import generate_function, format_vector
 log = logging.getLogger(__name__)
 
 
+# Note: This file does not use ContentAST.Answer wrappers - it uses TableQuestionMixin
+# which handles answer display through create_answer_table(). The answers are created
+# with labels embedded at creation time in refresh().
+
+
 class GradientDescentQuestion(Question, abc.ABC):
   def __init__(self, *args, **kwargs):
     kwargs["topic"] = kwargs.get("topic", Question.Topic.ML_OPTIMIZATION)
@@ -86,30 +91,32 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
     
     # Set up answers
     self.answers = {}
-    
+
     # Answers for each step
     for i, result in enumerate(self.gradient_descent_results):
       step = result['step']
-      
+
       # Location answer
       location_key = f"answer__location_{step}"
-      self.answers[location_key] = Answer.vector_value(location_key, list(result['location']))
-      
+      self.answers[location_key] = Answer.vector_value(location_key, list(result['location']), label=f"Location at step {step}")
+
       # Gradient answer
       gradient_key = f"answer__gradient_{step}"
-      self.answers[gradient_key] = Answer.vector_value(gradient_key, list(result['gradient']))
-      
+      self.answers[gradient_key] = Answer.vector_value(gradient_key, list(result['gradient']), label=f"Gradient at step {step}")
+
       # Update answer
       update_key = f"answer__update_{step}"
-      self.answers[update_key] = Answer.vector_value(update_key, list(result['update']))
+      self.answers[update_key] = Answer.vector_value(update_key, list(result['update']), label=f"Update at step {step}")
   
-  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 = []
+
     # Introduction
     objective = "minimize" if self.minimize else "maximize"
     sign = "-" if self.minimize else "+"
-    
+
     body.add_element(
       ContentAST.Paragraph(
         [
@@ -122,7 +129,7 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
         ]
       )
     )
-    
+
     # Create table data - use ContentAST.Equation for proper LaTeX rendering in headers
     headers = [
       "n",
@@ -131,36 +138,49 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
       ContentAST.Equation("\\alpha \\cdot \\nabla f", inline=True)
     ]
     table_rows = []
-    
+
     for i in range(self.num_steps):
       step = i + 1
       row = {"n": str(step)}
-      
+
       if step == 1:
-        
+
         # Fill in starting location for first row with default formatting
         row["location"] = f"{format_vector(self.starting_point)}"
         row[headers[2]] = f"answer__gradient_{step}"  # gradient column
         row[headers[3]] = f"answer__update_{step}"  # update column
+        # Collect answers for this step (no location answer for step 1)
+        answers.append(self.answers[f"answer__gradient_{step}"])
+        answers.append(self.answers[f"answer__update_{step}"])
       else:
         # Subsequent rows - all answer fields
         row["location"] = f"answer__location_{step}"
         row[headers[2]] = f"answer__gradient_{step}"  # gradient column
         row[headers[3]] = f"answer__update_{step}"  # update column
+        # Collect all answers for this step
+        answers.append(self.answers[f"answer__location_{step}"])
+        answers.append(self.answers[f"answer__gradient_{step}"])
+        answers.append(self.answers[f"answer__update_{step}"])
       table_rows.append(row)
-    
+
     # Create the table using mixin
     gradient_table = self.create_answer_table(
       headers=headers,
       data_rows=table_rows,
       answer_columns=["location", headers[2], headers[3]]  # Use actual header objects
     )
-    
+
     body.add_element(gradient_table)
-    
+
+    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(
@@ -201,7 +221,7 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
         ]
       )
     )
-    
+
     # Add completed table showing all solutions
     explanation.add_element(
       ContentAST.Paragraph(
@@ -210,7 +230,7 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
         ]
       )
     )
-    
+
     # Create filled solution table
     solution_headers = [
       "n",
@@ -218,31 +238,31 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
       ContentAST.Equation("\\nabla f", inline=True),
       ContentAST.Equation("\\alpha \\cdot \\nabla f", inline=True)
     ]
-    
+
     solution_rows = []
     for i, result in enumerate(self.gradient_descent_results):
       step = result['step']
       row = {"n": str(step)}
-      
+
       row["location"] = f"{format_vector(result['location'])}"
       row[solution_headers[2]] = f"{format_vector(result['gradient'])}"
       row[solution_headers[3]] = f"{format_vector(result['update'])}"
-    
+
       solution_rows.append(row)
-    
+
     # Create solution table (non-answer table, just display)
     solution_table = self.create_answer_table(
       headers=solution_headers,
       data_rows=solution_rows,
       answer_columns=[]  # No answer columns since this is just for display
     )
-    
+
     explanation.add_element(solution_table)
-    
+
     # Step-by-step explanation
     for i, result in enumerate(self.gradient_descent_results):
       step = result['step']
-      
+
       explanation.add_element(
         ContentAST.Paragraph(
           [
@@ -250,7 +270,7 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
           ]
         )
       )
-      
+
       explanation.add_element(
         ContentAST.Paragraph(
           [
@@ -258,7 +278,7 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
           ]
         )
       )
-      
+
       explanation.add_element(
         ContentAST.Paragraph(
           [
@@ -266,7 +286,7 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
           ]
         )
       )
-      
+
       explanation.add_element(
         ContentAST.Paragraph(
           [
@@ -278,13 +298,13 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
           ]
         )
       )
-      
+
       if step < len(self.gradient_descent_results):
         # Calculate next location for display
         current_loc = result['location']
         update = result['update']
         next_loc = [current_loc[j] - update[j] for j in range(len(current_loc))]
-        
+
         explanation.add_element(
           ContentAST.Paragraph(
             [
@@ -292,7 +312,7 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
             ]
           )
         )
-    
+
     function_values = [r['function_value'] for r in self.gradient_descent_results]
     explanation.add_element(
       ContentAST.Paragraph(
@@ -301,5 +321,10 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
         ]
       )
     )
-    
+
+    return explanation, []
+
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    """Build question explanation (backward compatible interface)."""
+    explanation, _ = self._get_explanation(**kwargs)
     return explanation

QuizGenerator/premade_questions/cst463/gradient_descent/loss_calculations.py

@@ -13,6 +13,9 @@ from QuizGenerator.mixins import TableQuestionMixin, BodyTemplatesMixin
 log = logging.getLogger(__name__)
 
 
+# Note: This file migrates to the _get_body()/_get_explanation() pattern
+
+
 class LossQuestion(Question, TableQuestionMixin, BodyTemplatesMixin, abc.ABC):
   """Base class for loss function calculation questions."""
 
@@ -70,14 +73,15 @@ class LossQuestion(Question, TableQuestionMixin, BodyTemplatesMixin, abc.ABC):
 
     # Individual loss answers
     for i in range(self.num_samples):
-      self.answers[f"loss_{i}"] = Answer.float_value(f"loss_{i}", self.individual_losses[i])
+      self.answers[f"loss_{i}"] = Answer.float_value(f"loss_{i}", self.individual_losses[i], label=f"Sample {i+1} loss")
 
     # Overall loss answer
-    self.answers["overall_loss"] = Answer.float_value("overall_loss", self.overall_loss)
+    self.answers["overall_loss"] = Answer.float_value("overall_loss", self.overall_loss, label="Overall loss")
 
-  def get_body(self) -> ContentAST.Element:
-    """Generate the question body with data table."""
+  def _get_body(self, **kwargs) -> Tuple[ContentAST.Element, List[Answer]]:
+    """Build question body and collect answers."""
     body = ContentAST.Section()
+    answers = []
 
     # Question description
     body.add_element(ContentAST.Paragraph([
@@ -85,15 +89,25 @@ class LossQuestion(Question, TableQuestionMixin, BodyTemplatesMixin, abc.ABC):
       f"and the overall {self._get_loss_function_short_name()}."
     ]))
 
-    # Data table
+    # Data table (contains individual loss answers)
     body.add_element(self._create_data_table())
 
+    # Collect individual loss answers
+    for i in range(self.num_samples):
+      answers.append(self.answers[f"loss_{i}"])
+
     # Overall loss question
     body.add_element(ContentAST.Paragraph([
       f"Overall {self._get_loss_function_short_name()}: "
     ]))
-    body.add_element(ContentAST.Answer(self.answers["overall_loss"]))
+    answers.append(self.answers["overall_loss"])
+    body.add_element(self.answers["overall_loss"])
+
+    return body, answers
 
+  def get_body(self, **kwargs) -> ContentAST.Element:
+    """Build question body (backward compatible interface)."""
+    body, _ = self._get_body(**kwargs)
     return body
 
   @abc.abstractmethod
@@ -101,8 +115,8 @@ class LossQuestion(Question, TableQuestionMixin, BodyTemplatesMixin, abc.ABC):
     """Create the data table with answer fields."""
     pass
 
-  def get_explanation(self) -> ContentAST.Element:
-    """Generate detailed explanation of the loss calculations."""
+  def _get_explanation(self, **kwargs) -> Tuple[ContentAST.Element, List[Answer]]:
+    """Build question explanation."""
     explanation = ContentAST.Section()
 
     explanation.add_element(ContentAST.Paragraph([
@@ -121,6 +135,11 @@ class LossQuestion(Question, TableQuestionMixin, BodyTemplatesMixin, abc.ABC):
     # Overall loss calculation
     explanation.add_element(self._create_overall_loss_explanation())
 
+    return explanation, []
+
+  def get_explanation(self, **kwargs) -> ContentAST.Element:
+    """Build question explanation (backward compatible interface)."""
+    explanation, _ = self._get_explanation(**kwargs)
     return explanation
 
   @abc.abstractmethod

QuizGenerator/premade_questions/cst463/math_and_data/matrix_questions.py

@@ -36,15 +36,22 @@ class MatrixMathQuestion(MathOperationQuestion, Question):
         return [[f"{prefix}{matrix[i][j]}" for j in range(len(matrix[0]))] for i in range(len(matrix))]
 
     def _create_answer_table(self, rows, cols, answers_dict, answer_prefix="answer"):
-        """Create a table with answer blanks for matrix results."""
+        """Create a table with answer blanks for matrix results.
+
+        Returns:
+            Tuple of (table, answers_list)
+        """
         table_data = []
+        answers = []
         for i in range(rows):
             row = []
             for j in range(cols):
                 answer_key = f"{answer_prefix}_{i}_{j}"
-                row.append(ContentAST.Answer(answer=answers_dict[answer_key]))
+                ans = answers_dict[answer_key]
+                row.append(ans)
+                answers.append(ans)
             table_data.append(row)
-        return ContentAST.Table(data=table_data, padding=True)
+        return ContentAST.Table(data=table_data, padding=True), answers
 
     # Implement MathOperationQuestion abstract methods
 
@@ -64,23 +71,23 @@ class MatrixMathQuestion(MathOperationQuestion, Question):
         return f"{operand_a_latex} {self.get_operator()} {operand_b_latex}"
 
     def _add_single_question_answers(self, body):
-        """Add Canvas-only answer fields for single questions."""
+        """Add Canvas-only answer fields for single questions.
+
+        Returns:
+            List of Answer objects that were added to the body.
+        """
+        answers = []
+
         # For matrices, we typically show result dimensions and answer table
         if hasattr(self, 'result_rows') and hasattr(self, 'result_cols'):
             # Matrix multiplication case with dimension answers
             if hasattr(self, 'answers') and "result_rows" in self.answers:
+                rows_ans = self.answers["result_rows"]
+                cols_ans = self.answers["result_cols"]
+                answers.extend([rows_ans, cols_ans])
                 body.add_element(
                     ContentAST.OnlyHtml([
-                        ContentAST.AnswerBlock([
-                            ContentAST.Answer(
-                                answer=self.answers["result_rows"],
-                                label="Number of rows in result"
-                            ),
-                            ContentAST.Answer(
-                                answer=self.answers["result_cols"],
-                                label="Number of columns in result"
-                            )
-                        ])
+                        ContentAST.AnswerBlock([rows_ans, cols_ans])
                     ])
                 )
 
@@ -88,21 +95,27 @@ class MatrixMathQuestion(MathOperationQuestion, Question):
         if hasattr(self, 'result') and self.result:
             rows = len(self.result)
             cols = len(self.result[0])
+            table, table_answers = self._create_answer_table(rows, cols, self.answers)
+            answers.extend(table_answers)
             body.add_element(
                 ContentAST.OnlyHtml([
                     ContentAST.Paragraph(["Result matrix:"]),
-                    self._create_answer_table(rows, cols, self.answers)
+                    table
                 ])
             )
         elif hasattr(self, 'max_dim'):
             # Matrix multiplication with max dimensions
+            table, table_answers = self._create_answer_table(self.max_dim, self.max_dim, self.answers)
+            answers.extend(table_answers)
             body.add_element(
                 ContentAST.OnlyHtml([
                     ContentAST.Paragraph(["Result matrix (use '-' if cell doesn't exist):"]),
-                    self._create_answer_table(self.max_dim, self.max_dim, self.answers)
+                    table
                 ])
             )
 
+        return answers
+
     # Abstract methods that subclasses must implement
     @abc.abstractmethod
     def get_operator(self):
@@ -488,8 +501,10 @@ class MatrixMultiplication(MatrixMathQuestion):
             # For single questions, use the old answer format
             # Dimension answers
             if result is not None:
-                self.answers["result_rows"] = Answer.integer("result_rows", self.result_rows)
-                self.answers["result_cols"] = Answer.integer("result_cols", self.result_cols)
+                self.answers["result_rows"] = Answer.integer("result_rows", self.result_rows,
+                                                             label="Number of rows in result")
+                self.answers["result_cols"] = Answer.integer("result_cols", self.result_cols,
+                                                             label="Number of columns in result")
 
                 # Matrix element answers
                 for i in range(self.max_dim):
@@ -501,8 +516,10 @@ class MatrixMultiplication(MatrixMathQuestion):
                             self.answers[answer_key] = Answer.string(answer_key, "-")
             else:
                 # Multiplication not possible
-                self.answers["result_rows"] = Answer.string("result_rows", "-")
-                self.answers["result_cols"] = Answer.string("result_cols", "-")
+                self.answers["result_rows"] = Answer.string("result_rows", "-",
+                                                            label="Number of rows in result")
+                self.answers["result_cols"] = Answer.string("result_cols", "-",
+                                                            label="Number of columns in result")
 
                 # All matrix elements are "-"
                 for i in range(self.max_dim):
@@ -523,32 +540,36 @@ class MatrixMultiplication(MatrixMathQuestion):
                         self.answers[answer_key] = Answer.integer(answer_key, result[i][j])
 
     def _add_single_question_answers(self, body):
-        """Add Canvas-only answer fields for MatrixMultiplication with dash instruction."""
+        """Add Canvas-only answer fields for MatrixMultiplication with dash instruction.
+
+        Returns:
+            List of Answer objects that were added to the body.
+        """
+        answers = []
+
         # Dimension answers for matrix multiplication
         if hasattr(self, 'answers') and "result_rows" in self.answers:
+            rows_ans = self.answers["result_rows"]
+            cols_ans = self.answers["result_cols"]
+            answers.extend([rows_ans, cols_ans])
             body.add_element(
                 ContentAST.OnlyHtml([
-                    ContentAST.AnswerBlock([
-                        ContentAST.Answer(
-                            answer=self.answers["result_rows"],
-                            label="Number of rows in result"
-                        ),
-                        ContentAST.Answer(
-                            answer=self.answers["result_cols"],
-                            label="Number of columns in result"
-                        )
-                    ])
+                    ContentAST.AnswerBlock([rows_ans, cols_ans])
                 ])
             )
 
         # Matrix result table with dash instruction
+        table, table_answers = self._create_answer_table(self.max_dim, self.max_dim, self.answers)
+        answers.extend(table_answers)
         body.add_element(
             ContentAST.OnlyHtml([
                 ContentAST.Paragraph(["Result matrix (use '-' if cell doesn't exist):"]),
-                self._create_answer_table(self.max_dim, self.max_dim, self.answers)
+                table
             ])
         )
 
+        return answers
+
     def refresh(self, *args, **kwargs):
         """Override refresh to handle matrix attributes."""
         super().refresh(*args, **kwargs)