QuizGenerator 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

QuizGenerator/premade_questions/cst334/memory_questions.py

@@ -9,8 +9,8 @@ import logging
 import math
 from typing import List, Optional
 
-from QuizGenerator.contentast import ContentAST
-from QuizGenerator.question import Question, Answer, QuestionRegistry, RegenerableChoiceMixin
+from QuizGenerator.contentast import ContentAST, AnswerTypes
+from QuizGenerator.question import Question, QuestionRegistry, RegenerableChoiceMixin
 from QuizGenerator.mixins import TableQuestionMixin, BodyTemplatesMixin
 
 log = logging.getLogger(__name__)
@@ -40,9 +40,9 @@ class VirtualAddressParts(MemoryQuestion, TableQuestionMixin):
     self.num_bits_vpn = self.num_bits_va - self.num_bits_offset
     
     self.possible_answers = {
-      self.Target.VA_BITS: Answer.integer("answer__num_bits_va", self.num_bits_va, unit="bits"),
-      self.Target.OFFSET_BITS: Answer.integer("answer__num_bits_offset", self.num_bits_offset, unit="bits"),
-      self.Target.VPN_BITS: Answer.integer("answer__num_bits_vpn", self.num_bits_vpn, unit="bits")
+      self.Target.VA_BITS: AnswerTypes.Int(self.num_bits_va, unit="bits"),
+      self.Target.OFFSET_BITS: AnswerTypes.Int(self.num_bits_offset, unit="bits"),
+      self.Target.VPN_BITS: AnswerTypes.Int(self.num_bits_vpn, unit="bits")
     }
     
     # Select what kind of question we are going to be
@@ -233,6 +233,7 @@ class CachingQuestion(MemoryQuestion, RegenerableChoiceMixin, TableQuestionMixin
     number_of_hits = 0
     for (request_number, request) in enumerate(self.requests):
       was_hit, evicted, cache_state = self.cache.query_cache(request, request_number)
+      log.debug(f"cache_state: \"{cache_state}\"")
       if was_hit:
         number_of_hits += 1
       self.request_results[request_number] = {
@@ -244,24 +245,17 @@ class CachingQuestion(MemoryQuestion, RegenerableChoiceMixin, TableQuestionMixin
       
       self.answers.update(
         {
-          f"answer__hit-{request_number}": Answer.string(
-            f"answer__hit-{request_number}", ('hit' if was_hit else 'miss')
-          ),
-          f"answer__evicted-{request_number}": Answer.string(
-            f"answer__evicted-{request_number}", ('-' if evicted is None else f"{evicted}")
-          ),
-          f"answer__cache_state-{request_number}": Answer.list_value(
-            f"answer__cache_state-{request_number}", copy.copy(cache_state)
-          ),
+          f"answer__hit-{request_number}": AnswerTypes.String(('hit' if was_hit else 'miss')),
+          f"answer__evicted-{request_number}": AnswerTypes.String(('-' if evicted is None else f"{evicted}")),
+          f"answer__cache_state-{request_number}": AnswerTypes.List(value=copy.copy(cache_state), order_matters=True),
         }
       )
     
     self.hit_rate = 100 * number_of_hits / (self.num_requests)
     self.answers.update(
       {
-        "answer__hit_rate": Answer.auto_float(
-          "answer__hit_rate", self.hit_rate,
-          label=f"Hit rate, excluding non-capacity misses. Round to {Answer.DEFAULT_ROUNDING_DIGITS} decimal digits if appropriate.",
+        "answer__hit_rate": AnswerTypes.Float(self.hit_rate,
+          label=f"Hit rate, excluding non-capacity misses",
           unit="%"
         )
       }
@@ -399,13 +393,12 @@ class BaseAndBounds(MemoryAccessQuestion, TableQuestionMixin, BodyTemplatesMixin
     self.virtual_address = self.rng.randint(1, int(self.bounds / self.PROBABILITY_OF_VALID))
     
     if self.virtual_address < self.bounds:
-      self.answers["answer"] = Answer.binary_hex(
-        "answer__physical_address",
+      self.answers["answer"] = AnswerTypes.Hex(
         self.base + self.virtual_address,
         length=math.ceil(math.log2(self.base + self.virtual_address))
       )
     else:
-      self.answers["answer"] = Answer.string("answer__physical_address", "INVALID")
+      self.answers["answer"] = AnswerTypes.String("INVALID")
   
   def _get_body(self):
     """Build question body and collect answers."""
@@ -586,21 +579,15 @@ class Segmentation(MemoryAccessQuestion, TableQuestionMixin, BodyTemplatesMixin)
     
     # Set answers based on whether it's in bounds or not
     if self.__within_bounds(self.segment, self.offset, self.bounds[self.segment]):
-      self.answers["answer__physical_address"] = Answer.binary_hex(
-        "answer__physical_address",
+      self.answers["answer__physical_address"] = AnswerTypes.Binary(
         self.physical_address,
         length=self.physical_bits,
         label="Physical Address"
       )
     else:
-      self.answers["answer__physical_address"] = Answer.string(
-        "answer__physical_address",
-        "INVALID",
-        label="Physical Address"
-      )
+      self.answers["answer__physical_address"] = AnswerTypes.String("INVALID", label="Physical Address")
 
-    self.answers["answer__segment"] = Answer.string("answer__segment", self.segment,
-                                                    label="Segment name")
+    self.answers["answer__segment"] = AnswerTypes.String(self.segment, label="Segment name")
   
   def _get_body(self):
     """Build question body and collect answers."""
@@ -825,29 +812,27 @@ class Paging(MemoryAccessQuestion, TableQuestionMixin, BodyTemplatesMixin):
 
     self.answers.update(
       {
-        "answer__vpn": Answer.binary_hex("answer__vpn", self.vpn, length=self.num_bits_vpn, label="VPN"),
-        "answer__offset": Answer.binary_hex("answer__offset", self.offset, length=self.num_bits_offset, label="Offset"),
-        "answer__pte": Answer.binary_hex("answer__pte", self.pte, length=(self.num_bits_pfn + 1), label="PTE"),
+        "answer__vpn": AnswerTypes.Binary(self.vpn, length=self.num_bits_vpn, label="VPN"),
+        "answer__offset": AnswerTypes.Binary(self.offset, length=self.num_bits_offset, label="Offset"),
+        "answer__pte": AnswerTypes.Binary(self.pte, length=(self.num_bits_pfn + 1), label="PTE"),
       }
     )
 
     if self.is_valid:
       self.answers.update(
         {
-          "answer__is_valid": Answer.string("answer__is_valid", "VALID", label="VALID or INVALID?"),
-          "answer__pfn": Answer.binary_hex("answer__pfn", self.pfn, length=self.num_bits_pfn, label="PFN"),
-          "answer__physical_address": Answer.binary_hex(
-            "answer__physical_address", self.physical_address,
-            length=(self.num_bits_pfn + self.num_bits_offset), label="Physical Address"
+          "answer__is_valid": AnswerTypes.String("VALID", label="VALID or INVALID?"),
+          "answer__pfn": AnswerTypes.Binary(self.pfn, length=self.num_bits_pfn, label="PFN"),
+          "answer__physical_address": AnswerTypes.Binary(self.physical_address, length=(self.num_bits_pfn + self.num_bits_offset), label="Physical Address"
           ),
         }
       )
     else:
       self.answers.update(
         {
-          "answer__is_valid": Answer.string("answer__is_valid", "INVALID", label="VALID or INVALID?"),
-          "answer__pfn": Answer.string("answer__pfn", "INVALID", label="PFN"),
-          "answer__physical_address": Answer.string("answer__physical_address", "INVALID", label="Physical Address"),
+          "answer__is_valid": AnswerTypes.String("INVALID", label="VALID or INVALID?"),
+          "answer__pfn": AnswerTypes.String("INVALID", label="PFN"),
+          "answer__physical_address": AnswerTypes.String("INVALID", label="Physical Address"),
         }
       )
   
@@ -1187,19 +1172,19 @@ class HierarchicalPaging(MemoryAccessQuestion, TableQuestionMixin, BodyTemplates
 
     # Set up answers
     self.answers.update({
-      "answer__pdi": Answer.binary_hex("answer__pdi", self.pdi, length=self.num_bits_pdi,
+      "answer__pdi": AnswerTypes.Binary(self.pdi, length=self.num_bits_pdi,
                                        label="PDI (Page Directory Index)"),
-      "answer__pti": Answer.binary_hex("answer__pti", self.pti, length=self.num_bits_pti,
+      "answer__pti": AnswerTypes.Binary(self.pti, length=self.num_bits_pti,
                                        label="PTI (Page Table Index)"),
-      "answer__offset": Answer.binary_hex("answer__offset", self.offset, length=self.num_bits_offset,
+      "answer__offset": AnswerTypes.Binary(self.offset, length=self.num_bits_offset,
                                           label="Offset"),
-      "answer__pd_entry": Answer.binary_hex("answer__pd_entry", self.pd_entry, length=(self.num_bits_pfn + 1),
+      "answer__pd_entry": AnswerTypes.Binary(self.pd_entry, length=(self.num_bits_pfn + 1),
                                             label="PD Entry (from Page Directory)"),
       "answer__pt_number": (
-        Answer.binary_hex("answer__pt_number", self.page_table_number, length=self.num_bits_pfn,
+        AnswerTypes.Binary(self.page_table_number, length=self.num_bits_pfn,
                           label="Page Table Number")
         if self.pd_valid
-        else Answer.string("answer__pt_number", "INVALID", label="Page Table Number")
+        else AnswerTypes.String("INVALID", label="Page Table Number")
       ),
     })
 
@@ -1207,31 +1192,29 @@ class HierarchicalPaging(MemoryAccessQuestion, TableQuestionMixin, BodyTemplates
     # (regardless of whether that PTE is valid or invalid)
     if self.pd_valid:
       self.answers.update({
-        "answer__pte": Answer.binary_hex("answer__pte", self.pte, length=(self.num_bits_pfn + 1),
+        "answer__pte": AnswerTypes.Binary(self.pte, length=(self.num_bits_pfn + 1),
                                          label="PTE (from Page Table)"),
       })
     else:
       # If PD is invalid, student can't look up the page table
       # Accept both "INVALID" (for consistency) and "N/A" (for accuracy)
       self.answers.update({
-        "answer__pte": Answer.string("answer__pte", ["INVALID", "N/A"], label="PTE (from Page Table)"),
+        "answer__pte": AnswerTypes.String(["INVALID", "N/A"], label="PTE (from Page Table)"),
       })
 
     # Validity, PFN, and Physical Address depend on BOTH levels being valid
     if self.pd_valid and self.pt_valid:
       self.answers.update({
-        "answer__is_valid": Answer.string("answer__is_valid", "VALID", label="VALID or INVALID?"),
-        "answer__pfn": Answer.binary_hex("answer__pfn", self.pfn, length=self.num_bits_pfn, label="PFN"),
-        "answer__physical_address": Answer.binary_hex(
-          "answer__physical_address", self.physical_address,
-          length=(self.num_bits_pfn + self.num_bits_offset), label="Physical Address"
+        "answer__is_valid": AnswerTypes.String("VALID", label="VALID or INVALID?"),
+        "answer__pfn": AnswerTypes.Binary(self.pfn, length=self.num_bits_pfn, label="PFN"),
+        "answer__physical_address": AnswerTypes.Binary(self.physical_address, length=(self.num_bits_pfn + self.num_bits_offset), label="Physical Address"
         ),
       })
     else:
       self.answers.update({
-        "answer__is_valid": Answer.string("answer__is_valid", "INVALID", label="VALID or INVALID?"),
-        "answer__pfn": Answer.string("answer__pfn", "INVALID", label="PFN"),
-        "answer__physical_address": Answer.string("answer__physical_address", "INVALID", label="Physical Address"),
+        "answer__is_valid": AnswerTypes.String("INVALID", label="VALID or INVALID?"),
+        "answer__pfn": AnswerTypes.String("INVALID", label="PFN"),
+        "answer__physical_address": AnswerTypes.String("INVALID", label="Physical Address"),
       })
 
   def _get_body(self, *args, **kwargs):

QuizGenerator/premade_questions/cst334/persistence_questions.py

@@ -5,8 +5,8 @@ import abc
 import difflib
 import logging
 
-from QuizGenerator.question import Question, Answer, QuestionRegistry
-from QuizGenerator.contentast import ContentAST
+from QuizGenerator.question import Question, QuestionRegistry
+from QuizGenerator.contentast import ContentAST, AnswerTypes
 from QuizGenerator.mixins import TableQuestionMixin, BodyTemplatesMixin
 
 log = logging.getLogger(__name__)
@@ -36,22 +36,10 @@ class HardDriveAccessTime(IOQuestion, TableQuestionMixin, BodyTemplatesMixin):
     self.disk_access_delay = self.access_delay * self.number_of_reads + self.transfer_delay
     
     self.answers.update({
-      "answer__rotational_delay": Answer.float_value(
-        "answer__rotational_delay",
-        self.rotational_delay
-      ),
-      "answer__access_delay": Answer.float_value(
-        "answer__access_delay",
-        self.access_delay
-      ),
-      "answer__transfer_delay": Answer.float_value(
-        "answer__transfer_delay",
-        self.transfer_delay
-      ),
-      "answer__disk_access_delay": Answer.float_value(
-        "answer__disk_access_delay",
-        self.disk_access_delay
-      ),
+      "answer__rotational_delay"  : AnswerTypes.Float(self.rotational_delay),
+      "answer__access_delay"      : AnswerTypes.Float(self.access_delay),
+      "answer__transfer_delay"    : AnswerTypes.Float(self.transfer_delay),
+      "answer__disk_access_delay" : AnswerTypes.Float(self.disk_access_delay),
     })
   
   def _get_body(self, *args, **kwargs):
@@ -190,10 +178,10 @@ class INodeAccesses(IOQuestion, TableQuestionMixin, BodyTemplatesMixin):
     self.inode_index_in_block = int(self.inode_address_in_block / self.inode_size)
     
     self.answers.update({
-      "answer__inode_address": Answer.integer("answer__inode_address", self.inode_address),
-      "answer__inode_block": Answer.integer("answer__inode_block", self.inode_block),
-      "answer__inode_address_in_block": Answer.integer("answer__inode_address_in_block", self.inode_address_in_block),
-      "answer__inode_index_in_block": Answer.integer("answer__inode_index_in_block", self.inode_index_in_block),
+      "answer__inode_address": AnswerTypes.Int(self.inode_address),
+      "answer__inode_block": AnswerTypes.Int(self.inode_block),
+      "answer__inode_address_in_block": AnswerTypes.Int(self.inode_address_in_block),
+      "answer__inode_index_in_block": AnswerTypes.Int(self.inode_index_in_block),
     })
   
   def _get_body(self):
@@ -334,7 +322,7 @@ class VSFS_states(IOQuestion):
   
   def __init__(self, *args, **kwargs):
     super().__init__(*args, **kwargs)
-    self.answer_kind = Answer.AnswerKind.MULTIPLE_DROPDOWN
+    self.answer_kind = ContentAST.Answer.CanvasAnswerKind.MULTIPLE_DROPDOWN
     
     self.num_steps = kwargs.get("num_steps", 10)
   
@@ -356,11 +344,8 @@ class VSFS_states(IOQuestion):
     ))
     self.rng.shuffle(wrong_answers)
     
-    self.answers["answer__cmd"] = Answer(
-      "answer__cmd",
+    self.answers["answer__cmd"] = ContentAST.Answer.dropdown(
       f"{operations[-1]['cmd']}",
-      kind=Answer.AnswerKind.MULTIPLE_DROPDOWN,
-      correct=True,
       baffles=list(set([op['cmd'] for op in operations[:-1] if op != operations[-1]['cmd']])),
       label="Command"
     )

QuizGenerator/premade_questions/cst334/process.py

@@ -13,8 +13,8 @@ from typing import List
 
 import matplotlib.pyplot as plt
 
-from QuizGenerator.contentast import ContentAST
-from QuizGenerator.question import Question, Answer, QuestionRegistry, RegenerableChoiceMixin
+from QuizGenerator.contentast import ContentAST, AnswerTypes
+from QuizGenerator.question import Question, QuestionRegistry, RegenerableChoiceMixin
 from QuizGenerator.mixins import TableQuestionMixin, BodyTemplatesMixin
 
 log = logging.getLogger(__name__)
@@ -356,23 +356,15 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
     
     for job_id in sorted(self.job_stats.keys()):
       self.answers.update({
-        f"answer__response_time_job{job_id}": Answer.auto_float(
-          f"answer__response_time_job{job_id}",
-          self.job_stats[job_id]["Response"]
-        ),
-        f"answer__turnaround_time_job{job_id}": Answer.auto_float(
-          f"answer__turnaround_time_job{job_id}",
-          self.job_stats[job_id]["TAT"]
-        ),
+        f"answer__response_time_job{job_id}": AnswerTypes.Float(self.job_stats[job_id]["Response"]),
+        f"answer__turnaround_time_job{job_id}": AnswerTypes.Float(self.job_stats[job_id]["TAT"]),
       })
     self.answers.update({
-      "answer__average_response_time": Answer.auto_float(
-        "answer__average_response_time",
+      "answer__average_response_time": AnswerTypes.Float(
         sum([job.response_time for job in jobs]) / len(jobs),
         label="Overall average response time"
       ),
-      "answer__average_turnaround_time": Answer.auto_float(
-        "answer__average_turnaround_time",
+      "answer__average_turnaround_time": AnswerTypes.Float(
         sum([job.turnaround_time for job in jobs]) / len(jobs),
         label="Overall average TAT"
       )
@@ -388,7 +380,7 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
         Tuple of (body_ast, answers_list)
     """
     from typing import List
-    answers: List[Answer] = []
+    answers: List[ContentAST.Answer] = []
 
     # Create table data for scheduling results
     table_rows = []
@@ -427,7 +419,7 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
     )
 
     instructions = ContentAST.OnlyHtml([ContentAST.Paragraph([
-      f"Please format answer as fractions, mixed numbers, or numbers rounded to a maximum of {Answer.DEFAULT_ROUNDING_DIGITS} digits after the decimal. "
+      f"Please format answer as fractions, mixed numbers, or numbers rounded to a maximum of {ContentAST.Answer.DEFAULT_ROUNDING_DIGITS} digits after the decimal. "
       "Examples of appropriately formatted answers would be `0`, `3/2`, `1 1/3`, `1.6667`, and `1.25`. "
       "Note that answers that can be rounded to whole numbers should be, rather than being left in fractional form."
     ])])
@@ -915,16 +907,13 @@ class MLFQQuestion(ProcessQuestion, TableQuestionMixin, BodyTemplatesMixin):
 
     for job_id in sorted(self.job_stats.keys()):
       self.answers.update({
-        f"answer__turnaround_time_job{job_id}": Answer.auto_float(
-          f"answer__turnaround_time_job{job_id}",
-          self.job_stats[job_id]["TAT"]
-        )
+        f"answer__turnaround_time_job{job_id}": AnswerTypes.Float(self.job_stats[job_id]["TAT"])
       })
 
     return self.is_interesting()
 
   def _get_body(self, *args, **kwargs):
-    answers: List[Answer] = []
+    answers: List[ContentAST.Answer] = []
 
     queue_rows = []
     for i in reversed(range(self.num_queues)):
@@ -964,7 +953,7 @@ class MLFQQuestion(ProcessQuestion, TableQuestionMixin, BodyTemplatesMixin):
 
     instructions = (
       f"Compute the turnaround time (TAT) for each job. "
-      f"Round to at most {Answer.DEFAULT_ROUNDING_DIGITS} digits after the decimal."
+      f"Round to at most {ContentAST.Answer.DEFAULT_ROUNDING_DIGITS} digits after the decimal."
     )
 
     body = ContentAST.Section()

QuizGenerator/premade_questions/cst463/gradient_descent/gradient_calculation.py

@@ -5,8 +5,8 @@ import logging
 from typing import List, Tuple
 import sympy as sp
 
-from QuizGenerator.contentast import ContentAST
-from QuizGenerator.question import Question, Answer, QuestionRegistry
+from QuizGenerator.contentast import ContentAST, AnswerTypes
+from QuizGenerator.question import Question, QuestionRegistry
 from .misc import generate_function, format_vector
 
 log = logging.getLogger(__name__)
@@ -57,7 +57,7 @@ class DerivativeQuestion(Question, abc.ABC):
       # Use auto_float for Canvas compatibility with integers and decimals
       # Label includes the partial derivative notation
       label = f"∂f/∂x_{i} at ({eval_point_str})"
-      self.answers[answer_key] = Answer.auto_float(answer_key, gradient_value, label=label)
+      self.answers[answer_key] = AnswerTypes.Float(gradient_value, label=label)
 
   def _create_gradient_vector_answer(self) -> None:
     """Create a single gradient vector answer for PDF format."""
@@ -75,9 +75,9 @@ class DerivativeQuestion(Question, abc.ABC):
 
     # Format as vector for display using consistent formatting
     vector_str = format_vector(gradient_values)
-    self.answers["gradient_vector"] = Answer.string("gradient_vector", vector_str, pdf_only=True)
+    self.answers["gradient_vector"] = AnswerTypes.String(vector_str, pdf_only=True)
 
-  def _get_body(self, **kwargs) -> Tuple[ContentAST.Section, List[Answer]]:
+  def _get_body(self, **kwargs) -> Tuple[ContentAST.Section, List[ContentAST.Answer]]:
     """Build question body and collect answers."""
     body = ContentAST.Section()
     answers = []
@@ -131,7 +131,7 @@ class DerivativeQuestion(Question, abc.ABC):
     body, _ = self._get_body(**kwargs)
     return body
 
-  def _get_explanation(self, **kwargs) -> Tuple[ContentAST.Section, List[Answer]]:
+  def _get_explanation(self, **kwargs) -> Tuple[ContentAST.Section, List[ContentAST.Answer]]:
     """Build question explanation."""
     explanation = ContentAST.Section()
 
@@ -162,14 +162,14 @@ class DerivativeQuestion(Question, abc.ABC):
       partial_expr = self.gradient_function[i]
       partial_value = partial_expr.subs(subs_map)
 
-      # Use Answer.accepted_strings for clean numerical formatting
+      # Use ContentAST.Answer.accepted_strings for clean numerical formatting
       try:
         numerical_value = float(partial_value)
       except (TypeError, ValueError):
         numerical_value = float(partial_value.evalf())
 
       # Get clean string representation
-      clean_value = sorted(Answer.accepted_strings(numerical_value), key=lambda s: len(s))[0]
+      clean_value = sorted(ContentAST.Answer.accepted_strings(numerical_value), key=lambda s: len(s))[0]
 
       explanation.add_element(
         ContentAST.Paragraph([
@@ -284,7 +284,7 @@ class DerivativeChain(DerivativeQuestion):
     f = sp.Function('f')
     self.equation = sp.Eq(f(*self.variables), self.function)
 
-  def _get_explanation(self, **kwargs) -> Tuple[ContentAST.Section, List[Answer]]:
+  def _get_explanation(self, **kwargs) -> Tuple[ContentAST.Section, List[ContentAST.Answer]]:
     """Build question explanation."""
     explanation = ContentAST.Section()
 
@@ -369,14 +369,14 @@ class DerivativeChain(DerivativeQuestion):
       partial_expr = self.gradient_function[i]
       partial_value = partial_expr.subs(subs_map)
 
-      # Use Answer.accepted_strings for clean numerical formatting
+      # Use ContentAST.Answer.accepted_strings for clean numerical formatting
       try:
         numerical_value = float(partial_value)
       except (TypeError, ValueError):
         numerical_value = float(partial_value.evalf())
 
       # Get clean string representation
-      clean_value = sorted(Answer.accepted_strings(numerical_value), key=lambda s: len(s))[0]
+      clean_value = sorted(ContentAST.Answer.accepted_strings(numerical_value), key=lambda s: len(s))[0]
 
       explanation.add_element(
         ContentAST.Paragraph([

QuizGenerator/premade_questions/cst463/gradient_descent/gradient_descent_questions.py

@@ -6,8 +6,8 @@ import math
 from typing import List, Tuple, Callable, Union, Any
 import sympy as sp
 
-from QuizGenerator.contentast import ContentAST
-from QuizGenerator.question import Question, Answer, QuestionRegistry
+from QuizGenerator.contentast import ContentAST, AnswerTypes
+from QuizGenerator.question import Question, QuestionRegistry
 from QuizGenerator.mixins import TableQuestionMixin, BodyTemplatesMixin
 
 from .misc import generate_function, format_vector
@@ -98,17 +98,17 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
 
       # Location answer
       location_key = f"answer__location_{step}"
-      self.answers[location_key] = Answer.vector_value(location_key, list(result['location']), label=f"Location at step {step}")
+      self.answers[location_key] = AnswerTypes.Vector(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']), label=f"Gradient at step {step}")
+      self.answers[gradient_key] = AnswerTypes.Vector(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']), label=f"Update at step {step}")
+      self.answers[update_key] = AnswerTypes.Vector(list(result['update']), label=f"Update at step {step}")
   
-  def _get_body(self, **kwargs) -> Tuple[ContentAST.Section, List[Answer]]:
+  def _get_body(self, **kwargs) -> Tuple[ContentAST.Section, List[ContentAST.Answer]]:
     """Build question body and collect answers."""
     body = ContentAST.Section()
     answers = []
@@ -179,7 +179,7 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
     body, _ = self._get_body(**kwargs)
     return body
   
-  def _get_explanation(self, **kwargs) -> Tuple[ContentAST.Section, List[Answer]]:
+  def _get_explanation(self, **kwargs) -> Tuple[ContentAST.Section, List[ContentAST.Answer]]:
     """Build question explanation."""
     explanation = ContentAST.Section()
 

QuizGenerator/premade_questions/cst463/gradient_descent/loss_calculations.py

@@ -6,8 +6,8 @@ import math
 import numpy as np
 from typing import List, Tuple, Dict, Any
 
-from QuizGenerator.contentast import ContentAST
-from QuizGenerator.question import Question, Answer, QuestionRegistry
+from QuizGenerator.contentast import ContentAST, AnswerTypes
+from QuizGenerator.question import Question, QuestionRegistry
 from QuizGenerator.mixins import TableQuestionMixin, BodyTemplatesMixin
 
 log = logging.getLogger(__name__)
@@ -73,12 +73,12 @@ 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], label=f"Sample {i+1} loss")
+      self.answers[f"loss_{i}"] = AnswerTypes.Float(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, label="Overall loss")
+    self.answers["overall_loss"] = AnswerTypes.Float(self.overall_loss, label="Overall loss")
 
-  def _get_body(self, **kwargs) -> Tuple[ContentAST.Element, List[Answer]]:
+  def _get_body(self, **kwargs) -> Tuple[ContentAST.Element, List[ContentAST.Answer]]:
     """Build question body and collect answers."""
     body = ContentAST.Section()
     answers = []
@@ -115,7 +115,7 @@ class LossQuestion(Question, TableQuestionMixin, BodyTemplatesMixin, abc.ABC):
     """Create the data table with answer fields."""
     pass
 
-  def _get_explanation(self, **kwargs) -> Tuple[ContentAST.Element, List[Answer]]:
+  def _get_explanation(self, **kwargs) -> Tuple[ContentAST.Element, List[ContentAST.Answer]]:
     """Build question explanation."""
     explanation = ContentAST.Section()
 

QuizGenerator/premade_questions/cst463/gradient_descent/misc.py

@@ -2,7 +2,7 @@
 from typing import List, Tuple, Callable, Union, Any
 import sympy as sp
 
-from QuizGenerator.misc import Answer
+from QuizGenerator.contentast import ContentAST
 
 def generate_function(rng, num_variables: int, max_degree: int, use_quadratic: bool = True) -> tuple[Any, sp.Expr, sp.MutableDenseMatrix, sp.Equality]:
   """
@@ -61,7 +61,7 @@ def format_vector(vec: List[float]) -> str:
   
   vector_string = ', '.join(
     [
-      sorted(Answer.accepted_strings(v), key=lambda s: len(s))[0]
+      sorted(ContentAST.Answer.accepted_strings(v), key=lambda s: len(s))[0]
       for v in vec
     ]
   )

QuizGenerator/premade_questions/cst463/math_and_data/matrix_questions.py

@@ -2,8 +2,8 @@
 import abc
 import logging
 
-from QuizGenerator.question import Question, QuestionRegistry, Answer
-from QuizGenerator.contentast import ContentAST
+from QuizGenerator.question import Question, QuestionRegistry
+from QuizGenerator.contentast import ContentAST, AnswerTypes
 from QuizGenerator.mixins import MathOperationQuestion
 
 log = logging.getLogger(__name__)
@@ -21,7 +21,7 @@ class MatrixMathQuestion(MathOperationQuestion, Question):
     - ContentAST.Matrix for mathematical matrices
     - ContentAST.Equation.make_block_equation__multiline_equals for step-by-step solutions
     - ContentAST.OnlyHtml for Canvas-specific content
-    - Answer.integer for numerical answers
+    - ContentAST.Answer.integer for numerical answers
     """
     def __init__(self, *args, **kwargs):
         kwargs["topic"] = kwargs.get("topic", Question.Topic.MATH)
@@ -169,7 +169,7 @@ class MatrixAddition(MatrixMathQuestion):
             for i in range(rows):
                 for j in range(cols):
                     answer_key = f"answer_{i}_{j}"
-                    self.answers[answer_key] = Answer.integer(answer_key, result[i][j])
+                    self.answers[answer_key] = AnswerTypes.Int(result[i][j])
         else:
             # For multipart questions, use subpart letter format
             letter = chr(ord('a') + subpart_index)
@@ -178,7 +178,7 @@ class MatrixAddition(MatrixMathQuestion):
             for i in range(rows):
                 for j in range(cols):
                     answer_key = f"subpart_{letter}_{i}_{j}"
-                    self.answers[answer_key] = Answer.integer(answer_key, result[i][j])
+                    self.answers[answer_key] = AnswerTypes.Int(result[i][j])
 
     def refresh(self, *args, **kwargs):
         """Override refresh to set rows/cols for compatibility."""
@@ -299,7 +299,7 @@ class MatrixScalarMultiplication(MatrixMathQuestion):
             for i in range(rows):
                 for j in range(cols):
                     answer_key = f"answer_{i}_{j}"
-                    self.answers[answer_key] = Answer.integer(answer_key, result[i][j])
+                    self.answers[answer_key] = AnswerTypes.Int(result[i][j])
         else:
             # For multipart questions, use subpart letter format
             letter = chr(ord('a') + subpart_index)
@@ -308,7 +308,7 @@ class MatrixScalarMultiplication(MatrixMathQuestion):
             for i in range(rows):
                 for j in range(cols):
                     answer_key = f"subpart_{letter}_{i}_{j}"
-                    self.answers[answer_key] = Answer.integer(answer_key, result[i][j])
+                    self.answers[answer_key] = AnswerTypes.Int(result[i][j])
 
     def refresh(self, *args, **kwargs):
         """Override refresh to handle different scalars per subpart."""
@@ -501,31 +501,27 @@ 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,
-                                                             label="Number of rows in result")
-                self.answers["result_cols"] = Answer.integer("result_cols", self.result_cols,
-                                                             label="Number of columns in result")
+                self.answers["result_rows"] = AnswerTypes.Int(self.result_rows, label="Number of rows in result")
+                self.answers["result_cols"] = AnswerTypes.Int(self.result_cols, label="Number of columns in result")
 
                 # Matrix element answers
                 for i in range(self.max_dim):
                     for j in range(self.max_dim):
                         answer_key = f"answer_{i}_{j}"
                         if i < self.result_rows and j < self.result_cols:
-                            self.answers[answer_key] = Answer.integer(answer_key, result[i][j])
+                            self.answers[answer_key] = AnswerTypes.Int(result[i][j])
                         else:
-                            self.answers[answer_key] = Answer.string(answer_key, "-")
+                            self.answers[answer_key] = AnswerTypes.String("-")
             else:
                 # Multiplication not possible
-                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")
+                self.answers["result_rows"] = AnswerTypes.String("-", label="Number of rows in result")
+                self.answers["result_cols"] = AnswerTypes.String("-", label="Number of columns in result")
 
                 # All matrix elements are "-"
                 for i in range(self.max_dim):
                     for j in range(self.max_dim):
                         answer_key = f"answer_{i}_{j}"
-                        self.answers[answer_key] = Answer.string(answer_key, "-")
+                        self.answers[answer_key] = AnswerTypes.String("-")
         else:
             # For multipart questions, use subpart letter format
             letter = chr(ord('a') + subpart_index)
@@ -537,7 +533,7 @@ class MatrixMultiplication(MatrixMathQuestion):
                 for i in range(rows):
                     for j in range(cols):
                         answer_key = f"subpart_{letter}_{i}_{j}"
-                        self.answers[answer_key] = Answer.integer(answer_key, result[i][j])
+                        self.answers[answer_key] = AnswerTypes.Int(result[i][j])
 
     def _add_single_question_answers(self, body):
         """Add Canvas-only answer fields for MatrixMultiplication with dash instruction.