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

QuizGenerator/contentast.py

@@ -2,26 +2,28 @@ from __future__ import annotations
 
 import abc
 import enum
-import re
 import textwrap
 from io import BytesIO
 from typing import List, Callable
 
-import numpy
 import pypandoc
 import markdown
 
-# from QuizGenerator.misc import Answer
-
 from QuizGenerator.qrcode_generator import QuestionQRCode
 import re
 
 import logging
 import os
 import uuid
+import itertools
+import math
+import decimal
+import fractions
+import numpy as np
 
 log = logging.getLogger(__name__)
 
+
 class ContentAST:
   """
   Content Abstract Syntax Tree - The core content system for quiz generation.
@@ -1201,7 +1203,6 @@ class ContentAST:
       super().__init__("[matrix]")
 
       # Convert numpy ndarray to list format if needed
-      import numpy as np
       if isinstance(data, np.ndarray):
         if data.ndim == 1:
           # 1D array: convert to column vector [[v1], [v2], [v3]]
@@ -1291,7 +1292,7 @@ class ContentAST:
     def render_html(self, **kwargs):
       matrix_env = "smallmatrix" if self.inline else f"{self.bracket_type}matrix"
       rows = []
-      if isinstance(self.data, numpy.ndarray):
+      if isinstance(self.data, np.ndarray):
         data = self.data.tolist()
       else:
         data = self.data
@@ -1467,1359 +1468,1183 @@ class ContentAST:
 
       return "\n".join(result)
 
-  class Answer(Leaf):
-    """
-    Unified answer class combining data storage, Canvas export, and rendering.
-
-    Extends ContentAST.Leaf to integrate seamlessly with the ContentAST tree while
-    maintaining all Canvas export functionality.
-
-    CRITICAL: Use this for ALL answer inputs in questions.
-    Creates appropriate input fields that work across both PDF and Canvas formats.
-    In PDF, renders as blank lines for students to fill in.
-    In HTML/Canvas, can display the answer for checking.
-
-    Example:
-        # Basic answer field
-        ans = ContentAST.Answer.integer("result", 42, label="Result", unit="MB")
-        body.add_element(ans)
-        answers.append(ans)  # Track for Canvas export
+  class LineBreak(Text):
+    def __init__(self, *args, **kwargs):
+      super().__init__("\n\n")
+  
+  ## Containers
+  
+  class Paragraph(Container):
     """
+    Text block container with proper spacing and paragraph formatting.
 
-    DEFAULT_ROUNDING_DIGITS = 4
-
-    class AnswerKind(enum.Enum):
-      BLANK = "fill_in_multiple_blanks_question"
-      MULTIPLE_ANSWER = "multiple_answers_question"
-      ESSAY = "essay_question"
-      MULTIPLE_DROPDOWN = "multiple_dropdowns_question"
-      NUMERICAL_QUESTION = "numerical_question"
-
-    class VariableKind(enum.Enum):
-      STR = enum.auto()
-      INT = enum.auto()
-      FLOAT = enum.auto()
-      BINARY = enum.auto()
-      HEX = enum.auto()
-      BINARY_OR_HEX = enum.auto()
-      AUTOFLOAT = enum.auto()
-      LIST = enum.auto()
-      VECTOR = enum.auto()
-      MATRIX = enum.auto()
-
-    def __init__(
-        self,
-        key=None,  # Can be str (new pattern) or Answer object (old wrapper pattern)
-        value=None,
-        kind: 'ContentAST.Answer.AnswerKind' = None,
-        variable_kind: 'ContentAST.Answer.VariableKind' = None,
-        # Data fields (from misc.Answer)
-        display=None,
-        length=None,
-        correct=True,
-        baffles=None,
-        pdf_only=False,
-        # Rendering fields (from ContentAST.Answer)
-        label: str = "",
-        unit: str = "",
-        blank_length=5,
-        # Backward compatibility for old wrapper pattern
-        answer=None  # Old pattern: ContentAST.Answer(answer=misc_answer_obj)
-    ):
-      # BACKWARD COMPATIBILITY: Handle old wrapper pattern
-      # Old: ContentAST.Answer(Answer.string("key", "value"))
-      # Old: ContentAST.Answer(answer=some_answer_obj, label="...")
-      if answer is not None or (key is not None and isinstance(key, ContentAST.Answer)):
-        # Old wrapper pattern detected
-        wrapped_answer = answer if answer is not None else key
-
-        if wrapped_answer is None:
-          raise ValueError("Must provide either 'key' and 'value', or 'answer' parameter")
-
-        # Copy all fields from wrapped answer
-        super().__init__(content=label if label else wrapped_answer.label)
-        self.key = wrapped_answer.key
-        self.value = wrapped_answer.value
-        self.kind = wrapped_answer.kind
-        self.variable_kind = wrapped_answer.variable_kind
-        self.display = wrapped_answer.display
-        self.length = wrapped_answer.length
-        self.correct = wrapped_answer.correct
-        self.baffles = wrapped_answer.baffles
-        self.pdf_only = wrapped_answer.pdf_only
-
-        # Use provided rendering fields or copy from wrapped answer
-        self.label = label if label else wrapped_answer.label
-        self.unit = unit if unit else (wrapped_answer.unit if hasattr(wrapped_answer, 'unit') else "")
-        self.blank_length = blank_length if blank_length != 5 else (wrapped_answer.blank_length if hasattr(wrapped_answer, 'blank_length') else 5)
-        return
-
-      # NEW PATTERN: Normal construction
-      if key is None:
-        raise ValueError("Must provide 'key' parameter for new Answer pattern, or 'answer' parameter for old wrapper pattern")
-
-      # Initialize Leaf with label as content
-      super().__init__(content=label if label else "")
-
-      # Data fields
-      self.key = key
-      self.value = value
-      self.kind = kind if kind is not None else ContentAST.Answer.AnswerKind.BLANK
-      self.variable_kind = variable_kind if variable_kind is not None else ContentAST.Answer.VariableKind.STR
+    IMPORTANT: Use this for grouping text content, especially in question bodies.
+    Automatically handles spacing between paragraphs and combines multiple
+    lines/elements into a cohesive text block.
 
-      # For list values in display, show the first option (or join them with /)
-      if display is not None:
-        self.display = display
-      elif isinstance(value, list) and self.variable_kind == ContentAST.Answer.VariableKind.STR:
-        self.display = value[0] if len(value) == 1 else " / ".join(value)
-      else:
-        self.display = value
+    When to use:
+    - Question instructions or problem statements
+    - Multi-line text content
+    - Grouping related text elements
+    - Any text that should be visually separated as a paragraph
 
-      self.length = length  # Used for bits and hex to be printed appropriately
-      self.correct = correct
-      self.baffles = baffles
-      self.pdf_only = pdf_only
+    When NOT to use:
+    - Single words or short phrases (use ContentAST.Text)
+    - Mathematical content (use ContentAST.Equation)
+    - Structured data (use ContentAST.Table)
 
-      # Rendering fields
-      self.label = label
-      self.unit = unit
-      self.blank_length = blank_length
+    Example:
+        # Multi-line question text
+        body.add_element(ContentAST.Paragraph([
+            "Consider the following system:",
+            "- Process A requires 4MB memory",
+            "- Process B requires 2MB memory",
+            "How much total memory is needed?"
+        ]))
 
-    # Canvas export methods (from misc.Answer)
-    def get_for_canvas(self, single_answer=False) -> List[dict]:
-      """Generate Canvas answer dictionaries based on variable_kind."""
-      import itertools
-      import math
-      import decimal
-      import fractions
+        # Mixed content paragraph
+        para = ContentAST.Paragraph([
+            "The equation ",
+            ContentAST.Equation("x^2 + 1 = 0", inline=True),
+            " has no real solutions."
+        ])
+    """
+    
+    def __init__(self, lines_or_elements: List[str | ContentAST.Element] = None):
+      super().__init__(add_spacing_before=True)
+      for line in lines_or_elements:
+        if isinstance(line, str):
+          self.elements.append(ContentAST.Text(line))
+        else:
+          self.elements.append(line)
+    
+    def render(self, output_format, **kwargs):
+      # Add in new lines to break these up visually
+      return "\n\n" + super().render(output_format, **kwargs) + "\n\n"
+    
+    def render_html(self, **kwargs):
+      return super().render_html(**kwargs) + "<br>"
+    
+    def add_line(self, line: str):
+      self.elements.append(ContentAST.Text(line))
+  
+  class Table(Container):
+    """
+    Structured data table with cross-format rendering and proper formatting.
 
-      # If this answer is PDF-only, don't send it to Canvas
-      if self.pdf_only:
-        return []
+    Creates properly formatted tables that work in PDF, Canvas, and Markdown.
+    Automatically handles headers, alignment, and responsive formatting.
+    All data is converted to ContentAST elements for consistent rendering.
 
-      canvas_answers = []
+    When to use:
+    - Structured data presentation (comparison tables, data sets)
+    - Answer choices in tabular format
+    - Organized information display
+    - Memory layout diagrams, process tables, etc.
 
-      if self.variable_kind == ContentAST.Answer.VariableKind.BINARY:
-        canvas_answers = [
-          {
-            "blank_id": self.key,
-            "answer_text": f"{self.value:0{self.length if self.length is not None else 0}b}",
-            "answer_weight": 100 if self.correct else 0,
-          },
-          {
-            "blank_id": self.key,
-            "answer_text": f"0b{self.value:0{self.length if self.length is not None else 0}b}",
-            "answer_weight": 100 if self.correct else 0,
-          }
-        ]
+    Features:
+    - Automatic alignment control (left, right, center)
+    - Optional headers with proper formatting
+    - Canvas-compatible HTML output
+    - LaTeX booktabs for professional PDF tables
 
-      elif self.variable_kind == ContentAST.Answer.VariableKind.HEX:
-        canvas_answers = [
-          {
-            "blank_id": self.key,
-            "answer_text": f"{self.value:0{(self.length // 8) + 1 if self.length is not None else 0}X}",
-            "answer_weight": 100 if self.correct else 0,
-          },
-          {
-            "blank_id": self.key,
-            "answer_text": f"0x{self.value:0{(self.length // 8) + 1 if self.length is not None else 0}X}",
-            "answer_weight": 100 if self.correct else 0,
-          }
+    Example:
+        # Basic data table
+        data = [
+            ["Process A", "4MB", "Running"],
+            ["Process B", "2MB", "Waiting"]
         ]
+        headers = ["Process", "Memory", "Status"]
+        table = ContentAST.Table(data=data, headers=headers, alignments=["left", "right", "center"])
+        body.add_element(table)
 
-      elif self.variable_kind == ContentAST.Answer.VariableKind.BINARY_OR_HEX:
-        canvas_answers = [
-          {
-            "blank_id": self.key,
-            "answer_text": f"{self.value:0{self.length if self.length is not None else 0}b}",
-            "answer_weight": 100 if self.correct else 0,
-          },
-          {
-            "blank_id": self.key,
-            "answer_text": f"0b{self.value:0{self.length if self.length is not None else 0}b}",
-            "answer_weight": 100 if self.correct else 0,
-          },
-          {
-            "blank_id": self.key,
-            "answer_text": f"{self.value:0{math.ceil(self.length / 8) if self.length is not None else 0}X}",
-            "answer_weight": 100 if self.correct else 0,
-          },
-          {
-            "blank_id": self.key,
-            "answer_text": f"0x{self.value:0{math.ceil(self.length / 8) if self.length is not None else 0}X}",
-            "answer_weight": 100 if self.correct else 0,
-          },
-          {
-            "blank_id": self.key,
-            "answer_text": f"{self.value}",
-            "answer_weight": 100 if self.correct else 0,
-          },
+        # Mixed content table
+        data = [
+            [ContentAST.Text("x"), ContentAST.Equation("x^2", inline=True)],
+            [ContentAST.Text("y"), ContentAST.Equation("y^2", inline=True)]
         ]
-
-      elif self.variable_kind in [
-        ContentAST.Answer.VariableKind.AUTOFLOAT,
-        ContentAST.Answer.VariableKind.FLOAT,
-        ContentAST.Answer.VariableKind.INT
-      ]:
-        if single_answer:
-          canvas_answers = [
-            {
-              "numerical_answer_type": "exact_answer",
-              "answer_text": round(self.value, ContentAST.Answer.DEFAULT_ROUNDING_DIGITS),
-              "answer_exact": round(self.value, ContentAST.Answer.DEFAULT_ROUNDING_DIGITS),
-              "answer_error_margin": 0.1,
-              "answer_weight": 100 if self.correct else 0,
-            }
-          ]
+    """
+    
+    def __init__(self, data, headers=None, alignments=None, padding=False, transpose=False, hide_rules=False):
+      # todo: fix alignments
+      # todo: implement transpose
+      super().__init__()
+      
+      # Normalize data to ContentAST elements
+      self.data = []
+      for row in data:
+        normalized_row = []
+        for cell in row:
+          if isinstance(cell, ContentAST.Element):
+            normalized_row.append(cell)
+          else:
+            normalized_row.append(ContentAST.Text(str(cell)))
+        self.data.append(normalized_row)
+      
+      # Normalize headers to ContentAST elements
+      if headers:
+        self.headers = []
+        for header in headers:
+          if isinstance(header, ContentAST.Element):
+            self.headers.append(header)
+          else:
+            self.headers.append(ContentAST.Text(str(header)))
+      else:
+        self.headers = None
+      
+      self.alignments = alignments
+      self.padding = padding,
+      self.hide_rules = hide_rules
+    
+    def render_markdown(self, **kwargs):
+      # Basic markdown table implementation
+      result = []
+      
+      if self.headers:
+        result.append("| " + " | ".join(str(h) for h in self.headers) + " |")
+        
+        if self.alignments:
+          align_row = []
+          for align in self.alignments:
+            if align == "left":
+              align_row.append(":---")
+            elif align == "right":
+              align_row.append("---:")
+            else:  # center
+              align_row.append(":---:")
+          result.append("| " + " | ".join(align_row) + " |")
         else:
-          # Use the accepted_strings helper
-          answer_strings = ContentAST.Answer.accepted_strings(
-            self.value,
-            allow_integer=True,
-            allow_simple_fraction=True,
-            max_denominator=60,
-            allow_mixed=True,
-            include_spaces=False,
-            include_fixed_even_if_integer=True
+          result.append("| " + " | ".join(["---"] * len(self.headers)) + " |")
+      
+      for row in self.data:
+        result.append("| " + " | ".join(str(cell) for cell in row) + " |")
+      
+      return "\n".join(result)
+    
+    def render_html(self, **kwargs):
+      # HTML table implementation
+      result = ["<table border=\"1\" style=\"border-collapse: collapse; width: 100%;\">"]
+      
+      result.append("  <tbody>")
+      
+      # Render headers as bold first row instead of <th> tags for Canvas compatibility
+      if self.headers:
+        result.append("    <tr>")
+        for i, header in enumerate(self.headers):
+          align_attr = ""
+          if self.alignments and i < len(self.alignments):
+            align_attr = f' align="{self.alignments[i]}"'
+          # Render header as bold content in regular <td> tag
+          rendered_header = header.render(output_format="html", **kwargs)
+          result.append(
+            f"      <td style=\"padding: {'5px' if self.padding else '0x'}; font-weight: bold; {align_attr};\"><b>{rendered_header}</b></td>"
           )
+        result.append("    </tr>")
+      
+      # Render data rows
+      for row in self.data:
+        result.append("    <tr>")
+        for i, cell in enumerate(row):
+          if isinstance(cell, ContentAST.Element):
+            cell = cell.render(output_format="html", **kwargs)
+          align_attr = ""
+          if self.alignments and i < len(self.alignments):
+            align_attr = f' align="{self.alignments[i]}"'
+          result.append(f"      <td  style=\"padding: {'5px' if self.padding else '0x'} ; {align_attr};\">{cell}</td>")
+        result.append("    </tr>")
+      result.append("  </tbody>")
+      result.append("</table>")
+      
+      return "\n".join(result)
+    
+    def render_latex(self, **kwargs):
+      # LaTeX table implementation
+      if self.alignments:
+        col_spec = "".join(
+          "l" if a == "left" else "r" if a == "right" else "c"
+          for a in self.alignments
+        )
+      else:
+        col_spec = '|'.join(["l"] * (len(self.headers) if self.headers else len(self.data[0])))
+      
+      result = [f"\\begin{{tabular}}{{{col_spec}}}"]
+      if not self.hide_rules: result.append("\\toprule")
+      
+      if self.headers:
+        # Now all headers are ContentAST elements, so render them consistently
+        rendered_headers = [header.render(output_format="latex", **kwargs) for header in self.headers]
+        result.append(" & ".join(rendered_headers) + " \\\\")
+        if not self.hide_rules: result.append("\\midrule")
+      
+      for row in self.data:
+        # All data cells are now ContentAST elements, so render them consistently
+        rendered_row = [cell.render(output_format="latex", **kwargs) for cell in row]
+        result.append(" & ".join(rendered_row) + " \\\\")
+      
+      if len(self.data) > 1 and not self.hide_rules:
+        result.append("\\bottomrule")
+      result.append("\\end{tabular}")
+      
+      return "\n\n" + "\n".join(result)
+    
+    def render_typst(self, **kwargs):
+      """
+      Render table in Typst format using native table() function.
 
-          canvas_answers = [
-            {
-              "blank_id": self.key,
-              "answer_text": answer_string,
-              "answer_weight": 100 if self.correct else 0,
-            }
-            for answer_string in answer_strings
-          ]
+      Typst syntax:
+      #table(
+        columns: N,
+        align: (left, center, right),
+        [Header1], [Header2],
+        [Cell1], [Cell2]
+      )
+      """
+      # Determine number of columns
+      num_cols = len(self.headers) if self.headers else len(self.data[0])
+      
+      # Build alignment specification
+      if self.alignments:
+        # Map alignment strings to Typst alignment
+        align_map = {"left": "left", "right": "right", "center": "center"}
+        aligns = [align_map.get(a, "left") for a in self.alignments]
+        align_spec = f"align: ({', '.join(aligns)})"
+      else:
+        align_spec = "align: left"
+      
+      # Start table
+      result = [f"table("]
+      result.append(f"  columns: {num_cols},")
+      result.append(f"  {align_spec},")
+      
+      # Add stroke if not hiding rules
+      if not self.hide_rules:
+        result.append(f"  stroke: 0.5pt,")
+      else:
+        result.append(f"  stroke: none,")
+      
+      # Collect all rows (headers + data) and calculate column widths for alignment
+      all_rows = []
+      
+      # Render headers
+      if self.headers:
+        header_cells = []
+        for header in self.headers:
+          rendered = header.render(output_format="typst", **kwargs).strip()
+          header_cells.append(f"[*{rendered}*]")
+        all_rows.append(header_cells)
+      
+      # Render data rows
+      for row in self.data:
+        row_cells = []
+        for cell in row:
+          rendered = cell.render(output_format="typst", **kwargs).strip()
+          row_cells.append(f"[{rendered}]")
+        all_rows.append(row_cells)
+      
+      # Calculate max width for each column
+      col_widths = [0] * num_cols
+      for row in all_rows:
+        for i, cell in enumerate(row):
+          col_widths[i] = max(col_widths[i], len(cell))
+      
+      # Format rows with padding
+      for row in all_rows:
+        padded_cells = []
+        for i, cell in enumerate(row):
+          padded_cells.append(cell.ljust(col_widths[i]))
+        result.append(f"  {', '.join(padded_cells)},")
+      
+      result.append(")")
+      
+      return "\n#box(" + "\n".join(result) + "\n)"
+  
+  class TableGroup(Container):
+    """
+    Container for displaying multiple tables side-by-side in LaTeX, stacked in HTML.
 
-      elif self.variable_kind == ContentAST.Answer.VariableKind.VECTOR:
-        # Get all answer variations
-        answer_variations = [
-          ContentAST.Answer.accepted_strings(dimension_value)
-          for dimension_value in self.value
-        ]
+    Use this when you need to show multiple related tables together, such as
+    multiple page tables in hierarchical paging questions. In LaTeX, tables
+    are displayed side-by-side using minipages. In HTML/Canvas, they're stacked
+    vertically for better mobile compatibility.
 
-        canvas_answers = []
-        for combination in itertools.product(*answer_variations):
-          # Add parentheses format
-          canvas_answers.append({
-            "blank_id": self.key,
-            "answer_weight": 100 if self.correct else 0,
-            "answer_text": f"({', '.join(list(combination))})",
-          })
+    When to use:
+    - Multiple related tables that should be visually grouped
+    - Page tables in hierarchical paging
+    - Comparison of multiple data structures
 
-          # Add non-parentheses format for single-element vectors
-          if len(combination) == 1:
-            canvas_answers.append({
-              "blank_id": self.key,
-              "answer_weight": 100 if self.correct else 0,
-              "answer_text": f"{', '.join(combination)}",
-            })
-        return canvas_answers
+    Features:
+    - Automatic side-by-side layout in PDF (using minipages)
+    - Vertical stacking in HTML for better readability
+    - Automatic width calculation based on number of tables
+    - Optional labels for each table
 
-      elif self.variable_kind == ContentAST.Answer.VariableKind.LIST:
-        canvas_answers = [
-          {
-            "blank_id": self.key,
-            "answer_text": ', '.join(map(str, possible_state)),
-            "answer_weight": 100 if self.correct else 0,
-          }
-          for possible_state in [self.value]
-        ]
+    Example:
+        # Create table group with labels
+        table_group = ContentAST.TableGroup()
 
-      else:
-        # For string answers, check if value is a list of acceptable alternatives
-        if isinstance(self.value, list):
-          canvas_answers = [
-            {
-              "blank_id": self.key,
-              "answer_text": str(alt),
-              "answer_weight": 100 if self.correct else 0,
-            }
-            for alt in self.value
-          ]
-        else:
-          canvas_answers = [{
-            "blank_id": self.key,
-            "answer_text": self.value,
-            "answer_weight": 100 if self.correct else 0,
-          }]
+        table_group.add_table(
+            label="Page Table #0",
+            table=ContentAST.Table(headers=["PTI", "PTE"], data=pt0_data)
+        )
 
-      # Add baffles (incorrect answer choices)
-      if self.baffles is not None:
-        for baffle in self.baffles:
-          canvas_answers.append({
-            "blank_id": self.key,
-            "answer_text": baffle,
-            "answer_weight": 0,
-          })
+        table_group.add_table(
+            label="Page Table #1",
+            table=ContentAST.Table(headers=["PTI", "PTE"], data=pt1_data)
+        )
 
-      return canvas_answers
+        body.add_element(table_group)
+    """
+    def __init__(self):
+      super().__init__()
+      self.tables = []  # List of (label, table) tuples
 
-    def get_display_string(self) -> str:
-      """Get the formatted display string for this answer (for grading/answer keys)."""
-      import math
+    def add_table(self, table: ContentAST.Table, label: str = None):
+      """
+      Add a table to the group with an optional label.
 
-      def fix_negative_zero(x):
-        """Fix -0.0 display issue."""
-        return 0.0 if x == 0 else x
+      Args:
+          table: ContentAST.Table to add
+          label: Optional label to display above the table
+      """
+      self.tables.append((label, table))
 
-      if self.variable_kind == ContentAST.Answer.VariableKind.BINARY_OR_HEX:
-        hex_digits = math.ceil(self.length / 4) if self.length is not None else 0
-        return f"0x{self.value:0{hex_digits}X}"
+    def render_html(self, **kwargs):
+      # Stack tables vertically in HTML
+      result = []
+      for label, table in self.tables:
+        if label:
+          result.append(f"<p><b>{label}</b></p>")
+        result.append(table.render("html", **kwargs))
+      return "\n".join(result)
 
-      elif self.variable_kind == ContentAST.Answer.VariableKind.BINARY:
-        return f"0b{self.value:0{self.length if self.length is not None else 0}b}"
+    def render_latex(self, **kwargs):
+      if not self.tables:
+        return ""
 
-      elif self.variable_kind == ContentAST.Answer.VariableKind.HEX:
-        hex_digits = (self.length // 4) + 1 if self.length is not None else 0
-        return f"0x{self.value:0{hex_digits}X}"
+      # Calculate width based on number of tables
+      num_tables = len(self.tables)
+      if num_tables == 1:
+        width = 0.9
+      elif num_tables == 2:
+        width = 0.45
+      else:  # 3 or more
+        width = 0.30
 
-      elif self.variable_kind == ContentAST.Answer.VariableKind.AUTOFLOAT:
-        rounded = round(self.value, ContentAST.Answer.DEFAULT_ROUNDING_DIGITS)
-        return f"{fix_negative_zero(rounded)}"
+      result = ["\n\n"]  # Add spacing before table group
 
-      elif self.variable_kind == ContentAST.Answer.VariableKind.FLOAT:
-        if isinstance(self.value, (list, tuple)):
-          rounded = round(self.value[0], ContentAST.Answer.DEFAULT_ROUNDING_DIGITS)
-          return f"{fix_negative_zero(rounded)}"
-        rounded = round(self.value, ContentAST.Answer.DEFAULT_ROUNDING_DIGITS)
-        return f"{fix_negative_zero(rounded)}"
+      for i, (label, table) in enumerate(self.tables):
+        result.append(f"\\begin{{minipage}}{{{width}\\textwidth}}")
 
-      elif self.variable_kind == ContentAST.Answer.VariableKind.INT:
-        return str(int(self.value))
+        if label:
+          # Escape # characters in labels for LaTeX
+          escaped_label = label.replace("#", r"\#")
+          result.append(f"\\textbf{{{escaped_label}}}")
+          result.append("\\vspace{0.1cm}")
 
-      elif self.variable_kind == ContentAST.Answer.VariableKind.LIST:
-        return ", ".join(str(v) for v in self.value)
+        # Render the table
+        table_latex = table.render("latex", **kwargs)
+        result.append(table_latex)
 
-      elif self.variable_kind == ContentAST.Answer.VariableKind.VECTOR:
-        def fix_negative_zero(x):
-          return 0.0 if x == 0 else x
-        return ", ".join(str(fix_negative_zero(round(v, ContentAST.Answer.DEFAULT_ROUNDING_DIGITS))) for v in self.value)
+        result.append("\\end{minipage}")
 
-      else:
-        return str(self.display if hasattr(self, 'display') else self.value)
+        # Add horizontal spacing between tables (but not after the last one)
+        if i < num_tables - 1:
+          result.append("\\hfill")
 
-    # Rendering methods (override Leaf's defaults)
-    def render_markdown(self, **kwargs):
-      return f"{self.label + (':' if len(self.label) > 0 else '')} [{self.key}] {self.unit}".strip()
-
-    def render_html(self, show_answers=False, can_be_numerical=False, **kwargs):
-      if can_be_numerical:
-        return f"Calculate {self.label}"
-      if show_answers:
-        answer_display = self.get_display_string()
-        label_part = f"{self.label}:" if self.label else ""
-        unit_part = f" {self.unit}" if self.unit else ""
-        return f"{label_part} <strong>{answer_display}</strong>{unit_part}".strip()
-      else:
-        return self.render_markdown(**kwargs)
-
-    def render_latex(self, **kwargs):
-      return fr"{self.label + (':' if len(self.label) > 0 else '')} \answerblank{{{self.blank_length}}} {self.unit}".strip()
+      return "\n".join(result)
 
     def render_typst(self, **kwargs):
-      """Render answer blank as an underlined space in Typst."""
-      blank_width = self.blank_length * 0.75  # Convert character length to cm
-      blank = f"#fillline(width: {blank_width}cm)"
+      """
+      Render table group in Typst format using grid layout for side-by-side tables.
 
-      label_part = f"{self.label}:" if self.label else ""
-      unit_part = f" {self.unit}" if self.unit else ""
+      Uses Typst's grid() function to arrange tables horizontally with automatic
+      column sizing and spacing.
+      """
+      if not self.tables:
+        return ""
 
-      return f"{label_part} {blank}{unit_part}".strip()
+      num_tables = len(self.tables)
 
-    # Factory methods for common answer types
-    @classmethod
-    def binary_hex(cls, key: str, value: int, length: int = None, **kwargs) -> 'ContentAST.Answer':
-      """Create an answer that accepts binary or hex format"""
-      return cls(
-        key=key,
-        value=value,
-        variable_kind=cls.VariableKind.BINARY_OR_HEX,
-        length=length,
-        **kwargs
-      )
+      # Start grid with equal-width columns and some spacing
+      result = ["\n#grid("]
+      result.append(f"  columns: {num_tables},")
+      result.append(f"  column-gutter: 1em,")
+      result.append(f"  row-gutter: 0.5em,")
 
-    @classmethod
-    def auto_float(cls, key: str, value: float, **kwargs) -> 'ContentAST.Answer':
-      """Create an answer that accepts multiple float formats (decimal, fraction, mixed)"""
-      return cls(
-        key=key,
-        value=value,
-        variable_kind=cls.VariableKind.AUTOFLOAT,
-        **kwargs
-      )
+      # Add each table as a grid cell
+      for label, table in self.tables:
+        result.append("  [")  # Start grid cell
 
-    @classmethod
-    def integer(cls, key: str, value: int, **kwargs) -> 'ContentAST.Answer':
-      """Create an integer answer"""
-      return cls(
-        key=key,
-        value=value,
-        variable_kind=cls.VariableKind.INT,
-        **kwargs
-      )
+        if label:
+          # Escape # characters in labels (already done by Text.render_typst)
+          result.append(f"    *{label}*")
+          result.append("    #v(0.1cm)")
+          result.append("")  # Empty line for spacing
 
-    @classmethod
-    def string(cls, key: str, value: str, **kwargs) -> 'ContentAST.Answer':
-      """Create a string answer"""
-      return cls(
-        key=key,
-        value=value,
-        variable_kind=cls.VariableKind.STR,
-        **kwargs
-      )
+        # Render the table (indent for readability)
+        table_typst = table.render("typst", **kwargs)
+        # Indent each line of the table
+        indented_table = "\n".join(f"    {line}" if line else "" for line in table_typst.split("\n"))
+        result.append(indented_table)
 
-    @classmethod
-    def binary(cls, key: str, value: int, length: int = None, **kwargs) -> 'ContentAST.Answer':
-      """Create a binary-only answer"""
-      return cls(
-        key=key,
-        value=value,
-        variable_kind=cls.VariableKind.BINARY,
-        length=length,
-        **kwargs
-      )
+        result.append("  ],")  # End grid cell
 
-    @classmethod
-    def hex_value(cls, key: str, value: int, length: int = None, **kwargs) -> 'ContentAST.Answer':
-      """Create a hex-only answer"""
-      return cls(
-        key=key,
-        value=value,
-        variable_kind=cls.VariableKind.HEX,
-        length=length,
-        **kwargs
-      )
+      result.append(")")
+      result.append("")  # Empty line after grid
 
-    @classmethod
-    def float_value(cls, key: str, value, **kwargs) -> 'ContentAST.Answer':
-      """Create a simple float answer (no fraction conversion)"""
-      return cls(
-        key=key,
-        value=value,
-        variable_kind=cls.VariableKind.FLOAT,
-        **kwargs
-      )
+      return "\n".join(result)
 
-    @classmethod
-    def list_value(cls, key: str, value: list, **kwargs) -> 'ContentAST.Answer':
-      """Create a list answer (comma-separated values)"""
-      return cls(
-        key=key,
-        value=value,
-        variable_kind=cls.VariableKind.LIST,
-        **kwargs
-      )
+  class AnswerBlock(Table):
+    """
+    Specialized table for organizing multiple answer fields with proper spacing.
 
-    @classmethod
-    def vector_value(cls, key: str, value: List[float], **kwargs) -> 'ContentAST.Answer':
-      """Create a vector answer"""
-      return cls(
-        key=key,
-        value=value,
-        variable_kind=cls.VariableKind.VECTOR,
-        **kwargs
-      )
+    Creates a clean layout for multiple answer inputs with extra vertical
+    spacing in PDF output. Inherits from Table but optimized for answers.
 
-    @classmethod
-    def dropdown(cls, key: str, value: str, baffles: list = None, **kwargs) -> 'ContentAST.Answer':
-      """Create a dropdown answer with wrong answer choices (baffles)"""
-      return cls(
-        key=key,
-        value=value,
-        kind=cls.AnswerKind.MULTIPLE_DROPDOWN,
-        baffles=baffles,
-        **kwargs
-      )
+    When to use:
+    - Questions with multiple answer fields
+    - Organized answer input sections
+    - Better visual grouping of related answers
 
-    @classmethod
-    def multiple_choice(cls, key: str, value: str, baffles: list = None, **kwargs) -> 'ContentAST.Answer':
-      """Create a multiple choice answer with wrong answer choices (baffles)"""
-      return cls(
-        key=key,
-        value=value,
-        kind=cls.AnswerKind.MULTIPLE_ANSWER,
-        baffles=baffles,
-        **kwargs
-      )
+    Example:
+        # Multiple related answers - Answer extends Leaf, use factory methods
+        memory_ans = ContentAST.Answer.integer("memory", self.memory_value, label="Memory used", unit="MB")
+        time_ans = ContentAST.Answer.auto_float("time", self.time_value, label="Execution time", unit="ms")
+        answer_block = ContentAST.AnswerBlock([memory_ans, time_ans])
+        body.add_element(answer_block)
 
-    @classmethod
-    def essay(cls, key: str, **kwargs) -> 'ContentAST.Answer':
-      """Create an essay question (no specific correct answer)"""
-      return cls(
-        key=key,
-        value="",  # Essays don't have predetermined answers
-        kind=cls.AnswerKind.ESSAY,
-        **kwargs
-      )
+        # Single answer with better spacing
+        result_ans = ContentAST.Answer.integer("result", self.result_value, label="Final result")
+        single_answer = ContentAST.AnswerBlock(result_ans)
+    """
+    def __init__(self, answers: ContentAST.Answer|List[ContentAST.Answer]):
+      if not isinstance(answers, list):
+        answers = [answers]
 
-    @classmethod
-    def matrix(cls, key: str, value, **kwargs):
-      """Create a matrix answer (returns MatrixAnswer instance)"""
-      return ContentAST.MatrixAnswer(
-        key=key,
-        value=value,
-        variable_kind=cls.VariableKind.MATRIX,
-        **kwargs
+      super().__init__(
+        data=[
+          [answer]
+          for answer in answers
+        ]
       )
+      self.hide_rules = True
 
-    # Static helper methods
-    @staticmethod
-    def _to_fraction(x):
-      """Convert int/float/decimal.Decimal/fractions.Fraction/str to fractions.Fraction exactly."""
-      import fractions
-      import decimal
-
-      if isinstance(x, fractions.Fraction):
-        return x
-      if isinstance(x, int):
-        return fractions.Fraction(x, 1)
-      if isinstance(x, decimal.Decimal):
-        # exact conversion of decimal.Decimal to fractions.Fraction
-        sign, digits, exp = x.as_tuple()
-        n = 0
-        for d in digits:
-          n = n * 10 + d
-        n = -n if sign else n
-        if exp >= 0:
-          return fractions.Fraction(n * (10 ** exp), 1)
-        else:
-          return fractions.Fraction(n, 10 ** (-exp))
-      if isinstance(x, str):
-        s = x.strip()
-        if '/' in s:
-          a, b = s.split('/', 1)
-          return fractions.Fraction(int(a.strip()), int(b.strip()))
-        return fractions.Fraction(decimal.Decimal(s))
-      # float or other numerics
-      return fractions.Fraction(decimal.Decimal(str(x)))
-
-    @staticmethod
-    def accepted_strings(
-        value,
-        *,
-        allow_integer=True,
-        allow_simple_fraction=True,
-        max_denominator=720,
-        allow_mixed=False,
-        include_spaces=False,
-        include_fixed_even_if_integer=False
-    ):
-      """Return a sorted list of strings you can paste into Canvas as alternate correct answers."""
-      import decimal
-      import fractions
-
-      decimal.getcontext().prec = max(34, (ContentAST.Answer.DEFAULT_ROUNDING_DIGITS or 0) + 10)
-      f = ContentAST.Answer._to_fraction(value)
-      outs = set()
+    def add_element(self, element):
+      self.data.append(element)
 
-      # Integer form
-      if f.denominator == 1 and allow_integer:
-        outs.add(str(f.numerator))
-        if include_fixed_even_if_integer:
-          q = decimal.Decimal(1).scaleb(-ContentAST.Answer.DEFAULT_ROUNDING_DIGITS)
-          d = decimal.Decimal(f.numerator).quantize(q, rounding=decimal.ROUND_HALF_UP)
-          outs.add(format(d, 'f'))
+    def render_latex(self, **kwargs):
+      rendered_content = super().render_latex(**kwargs)
+      content = (
+        r"{"
+        r"\setlength{\extrarowheight}{20pt}"
+        + rendered_content +
+        r"}"
+      )
+      return content
 
-      # Fixed-decimal form
-      q = decimal.Decimal(1).scaleb(-ContentAST.Answer.DEFAULT_ROUNDING_DIGITS)
-      d = (decimal.Decimal(f.numerator) / decimal.Decimal(f.denominator)).quantize(q, rounding=decimal.ROUND_HALF_UP)
-      outs.add(format(d, 'f'))
+  ## Specialized Elements
+  class RepeatedProblemPart(Container):
+    """
+    Multi-part problem renderer for questions with labeled subparts (a), (b), (c), etc.
 
-      # Trimmed decimal
-      if ContentAST.Answer.DEFAULT_ROUNDING_DIGITS:
-        q = decimal.Decimal(1).scaleb(-ContentAST.Answer.DEFAULT_ROUNDING_DIGITS)
-        d = (decimal.Decimal(f.numerator) / decimal.Decimal(f.denominator)).quantize(q, rounding=decimal.ROUND_HALF_UP)
-        s = format(d, 'f').rstrip('0').rstrip('.')
-        if s.startswith('.'):
-          s = '0' + s
-        if s == '-0':
-          s = '0'
-        outs.add(s)
+    Creates the specialized alignat* LaTeX format for multipart math problems
+    where each subpart is labeled and aligned properly. Used primarily for
+    vector math questions that need multiple similar calculations.
 
-      # Simple fraction
-      if allow_simple_fraction:
-        fr = f.limit_denominator(max_denominator)
-        if fr == f:
-          a, b = fr.numerator, fr.denominator
-          outs.add(f"{a}/{b}")
-          if include_spaces:
-            outs.add(f"{a} / {b}")
-          if allow_mixed and b != 1 and abs(a) > b:
-            sign = '-' if a < 0 else ''
-            A = abs(a)
-            whole, rem = divmod(A, b)
-            outs.add(f"{sign}{whole} {rem}/{b}")
+    When to use:
+    - Questions with multiple subparts that need (a), (b), (c) labeling
+    - Vector math problems with repeated calculations
+    - Any math problem where subparts should be aligned
 
-      return sorted(outs, key=lambda s: (len(s), s))
+    Features:
+    - Automatic subpart labeling with (a), (b), (c), etc.
+    - Proper LaTeX alignat* formatting for PDF
+    - HTML fallback with organized layout
+    - Flexible content support (equations, matrices, etc.)
 
-  class MatrixAnswer(Answer):
-    """
-    Matrix answers generate multiple blank_ids (e.g., M_0_0, M_0_1, M_1_0, M_1_1).
+    Example:
+        # Create subparts for vector dot products
+        subparts = [
+            (ContentAST.Matrix([[1], [2]]), "\\cdot", ContentAST.Matrix([[3], [4]])),
+            (ContentAST.Matrix([[5], [6]]), "\\cdot", ContentAST.Matrix([[7], [8]]))
+        ]
+        repeated_part = ContentAST.RepeatedProblemPart(subparts)
+        body.add_element(repeated_part)
     """
+    def __init__(self, subpart_contents):
+      """
+      Create a repeated problem part with multiple subquestions.
 
-    def get_for_canvas(self, single_answer=False) -> List[dict]:
-      """Generate Canvas answers for each matrix element."""
-      import numpy as np
+      Args:
+          subpart_contents: List of content for each subpart.
+                           Each item can be:
+                           - A string (rendered as equation)
+                           - A ContentAST.Element
+                           - A tuple/list of elements to be joined
+      """
+      super().__init__()
+      self.subpart_contents = subpart_contents
 
-      canvas_answers = []
+    def render_markdown(self, **kwargs):
+      result = []
+      for i, content in enumerate(self.subpart_contents):
+        letter = chr(ord('a') + i)  # Convert to (a), (b), (c), etc.
+        if isinstance(content, str):
+          result.append(f"({letter}) {content}")
+        elif isinstance(content, (list, tuple)):
+          content_str = " ".join(str(item) for item in content)
+          result.append(f"({letter}) {content_str}")
+        else:
+          result.append(f"({letter}) {str(content)}")
+      return "\n\n".join(result)
 
-      # Generate a per-index set of answers for each matrix element
-      for i, j in np.ndindex(self.value.shape):
-        entry_strings = ContentAST.Answer.accepted_strings(
-          self.value[i, j],
-          allow_integer=True,
-          allow_simple_fraction=True,
-          max_denominator=60,
-          allow_mixed=True,
-          include_spaces=False,
-          include_fixed_even_if_integer=True
-        )
-        canvas_answers.extend([
-          {
-            "blank_id": f"{self.key}_{i}_{j}",  # Indexed per cell
-            "answer_text": answer_string,
-            "answer_weight": 100 if self.correct else 0,
-          }
-          for answer_string in entry_strings
-        ])
+    def render_html(self, **kwargs):
+      result = []
+      for i, content in enumerate(self.subpart_contents):
+        letter = chr(ord('a') + i)
+        if isinstance(content, str):
+          result.append(f"<p>({letter}) {content}</p>")
+        elif isinstance(content, (list, tuple)):
+          rendered_items = []
+          for item in content:
+            if hasattr(item, 'render'):
+              rendered_items.append(item.render('html', **kwargs))
+            else:
+              rendered_items.append(str(item))
+          content_str = " ".join(rendered_items)
+          result.append(f"<p>({letter}) {content_str}</p>")
+        else:
+          if hasattr(content, 'render'):
+            content_str = content.render('html', **kwargs)
+          else:
+            content_str = str(content)
+          result.append(f"<p>({letter}) {content_str}</p>")
+      return "\n".join(result)
 
-      return canvas_answers
+    def render_latex(self, **kwargs):
+      if not self.subpart_contents:
+        return ""
 
-    def render_html(self, **kwargs):
-      """Render as table of answer blanks."""
-      # Create sub-Answer for each cell
-      data = [
-        [
-          ContentAST.Answer.float_value(
-            key=f"{self.key}_{i}_{j}",
-            value=self.value[i, j],
-            blank_length=5
-          )
-          for j in range(self.value.shape[1])
-        ]
-        for i in range(self.value.shape[0])
-      ]
-      table = ContentAST.Table(data)
+      # Start alignat environment - use 2 columns for alignment
+      result = [r"\begin{alignat*}{2}"]
 
-      if self.label:
-        return ContentAST.Container([
-          ContentAST.Text(f"{self.label} = "),
-          table
-        ]).render_html(**kwargs)
-      return table.render_html(**kwargs)
+      for i, content in enumerate(self.subpart_contents):
+        letter = chr(ord('a') + i)
+        spacing = r"\\[6pt]" if i < len(self.subpart_contents) - 1 else r" \\"
 
-    def render_latex(self, **kwargs):
-      """Render as LaTeX table of answer blanks."""
-      # Create sub-Answer for each cell
-      data = [
-        [
-          ContentAST.Answer.float_value(
-            key=f"{self.key}_{i}_{j}",
-            value=self.value[i, j],
-            blank_length=5
-          )
-          for j in range(self.value.shape[1])
-        ]
-        for i in range(self.value.shape[0])
-      ]
-      table = ContentAST.Table(data)
+        if isinstance(content, str):
+          # Treat as raw LaTeX equation content
+          result.append(f"({letter})\\;& {content} &=&\\; {spacing}")
+        elif isinstance(content, (list, tuple)):
+          # Join multiple elements (e.g., matrix, operator, matrix)
+          rendered_items = []
+          for item in content:
+            if hasattr(item, 'render'):
+              rendered_items.append(item.render('latex', **kwargs))
+            elif isinstance(item, str):
+              rendered_items.append(item)
+            else:
+              rendered_items.append(str(item))
+          content_str = " ".join(rendered_items)
+          result.append(f"({letter})\\;& {content_str} &=&\\; {spacing}")
+        else:
+          # Single element (ContentAST element or string)
+          if hasattr(content, 'render'):
+            content_str = content.render('latex', **kwargs)
+          else:
+            content_str = str(content)
+          result.append(f"({letter})\\;& {content_str} &=&\\; {spacing}")
 
-      if self.label:
-        return ContentAST.Container([
-          ContentAST.Text(f"{self.label} = "),
-          table
-        ]).render_latex(**kwargs)
-      return table.render_latex(**kwargs)
+      result.append(r"\end{alignat*}")
+      return "\n".join(result)
 
-    def render_markdown(self, **kwargs):
-      """Render as markdown table of answer blanks."""
-      # Create sub-Answer for each cell
-      data = [
-        [
-          ContentAST.Answer.float_value(
-            key=f"{self.key}_{i}_{j}",
-            value=self.value[i, j],
-            blank_length=5
-          )
-          for j in range(self.value.shape[1])
-        ]
-        for i in range(self.value.shape[0])
-      ]
-      table = ContentAST.Table(data)
+  class OnlyLatex(Container):
+    """
+    Container element that only renders content in LaTeX/PDF output format.
 
-      if self.label:
-        return ContentAST.Container([
-          ContentAST.Text(f"{self.label} = "),
-          table
-        ]).render_markdown(**kwargs)
-      return table.render_markdown(**kwargs)
+    Use this when you need LaTeX-specific content that should not appear
+    in HTML/Canvas or Markdown outputs. Content is completely hidden
+    from non-LaTeX formats.
 
-    def render_typst(self, **kwargs):
-      """Render as Typst table of answer blanks."""
-      # Create sub-Answer for each cell
-      data = [
-        [
-          ContentAST.Answer.float_value(
-            key=f"{self.key}_{i}_{j}",
-            value=self.value[i, j],
-            blank_length=5
-          )
-          for j in range(self.value.shape[1])
-        ]
-        for i in range(self.value.shape[0])
-      ]
-      table = ContentAST.Table(data)
+    When to use:
+    - LaTeX-specific formatting that has no HTML equivalent
+    - PDF-only instructions or content
+    - Complex LaTeX commands that break HTML rendering
 
-      if self.label:
-        return ContentAST.Container([
-          ContentAST.Text(f"{self.label} = "),
-          table
-        ]).render_typst(**kwargs)
-      return table.render_typst(**kwargs)
+    Example:
+        # LaTeX-only spacing or formatting
+        latex_only = ContentAST.OnlyLatex()
+        latex_only.add_element(ContentAST.Text("\\newpage"))
 
-  class LineBreak(Text):
-    def __init__(self, *args, **kwargs):
-      super().__init__("\n\n")
-  
-  ## Containers
+        # Add to main content - only appears in PDF
+        body.add_element(latex_only)
+    """
+
+    def render(self, output_format: ContentAST.OutputFormat, **kwargs):
+      if output_format not in ("latex", "typst"):
+        return ""
+      return super().render(output_format=output_format, **kwargs)
   
-  class Paragraph(Container):
+  class OnlyHtml(Container):
     """
-    Text block container with proper spacing and paragraph formatting.
+    Container element that only renders content in HTML/Canvas output format.
 
-    IMPORTANT: Use this for grouping text content, especially in question bodies.
-    Automatically handles spacing between paragraphs and combines multiple
-    lines/elements into a cohesive text block.
+    Use this when you need HTML-specific content that should not appear
+    in LaTeX/PDF or Markdown outputs. Content is completely hidden
+    from non-HTML formats.
 
     When to use:
-    - Question instructions or problem statements
-    - Multi-line text content
-    - Grouping related text elements
-    - Any text that should be visually separated as a paragraph
-
-    When NOT to use:
-    - Single words or short phrases (use ContentAST.Text)
-    - Mathematical content (use ContentAST.Equation)
-    - Structured data (use ContentAST.Table)
+    - Canvas-specific instructions or formatting
+    - HTML-only interactive elements
+    - Content that doesn't translate well to PDF
 
     Example:
-        # Multi-line question text
-        body.add_element(ContentAST.Paragraph([
-            "Consider the following system:",
-            "- Process A requires 4MB memory",
-            "- Process B requires 2MB memory",
-            "How much total memory is needed?"
-        ]))
+        # HTML-only instructions
+        html_only = ContentAST.OnlyHtml()
+        html_only.add_element(ContentAST.Text("Click submit when done"))
 
-        # Mixed content paragraph
-        para = ContentAST.Paragraph([
-            "The equation ",
-            ContentAST.Equation("x^2 + 1 = 0", inline=True),
-            " has no real solutions."
-        ])
+        # Add to main content - only appears in Canvas
+        body.add_element(html_only)
     """
     
-    def __init__(self, lines_or_elements: List[str | ContentAST.Element] = None):
-      super().__init__(add_spacing_before=True)
-      for line in lines_or_elements:
-        if isinstance(line, str):
-          self.elements.append(ContentAST.Text(line))
-        else:
-          self.elements.append(line)
-    
     def render(self, output_format, **kwargs):
-      # Add in new lines to break these up visually
-      return "\n\n" + super().render(output_format, **kwargs) + "\n\n"
-    
-    def render_html(self, **kwargs):
-      return super().render_html(**kwargs) + "<br>"
-    
-    def add_line(self, line: str):
-      self.elements.append(ContentAST.Text(line))
+      if output_format != "html":
+        return ""
+      return super().render(output_format, **kwargs)
   
-  class Table(Container):
+  class Answer(Leaf):
     """
-    Structured data table with cross-format rendering and proper formatting.
-
-    Creates properly formatted tables that work in PDF, Canvas, and Markdown.
-    Automatically handles headers, alignment, and responsive formatting.
-    All data is converted to ContentAST elements for consistent rendering.
+    Unified answer class combining data storage, Canvas export, and rendering.
 
-    When to use:
-    - Structured data presentation (comparison tables, data sets)
-    - Answer choices in tabular format
-    - Organized information display
-    - Memory layout diagrams, process tables, etc.
+    Extends ContentAST.Leaf to integrate seamlessly with the ContentAST tree while
+    maintaining all Canvas export functionality.
 
-    Features:
-    - Automatic alignment control (left, right, center)
-    - Optional headers with proper formatting
-    - Canvas-compatible HTML output
-    - LaTeX booktabs for professional PDF tables
+    CRITICAL: Use this for ALL answer inputs in questions.
+    Creates appropriate input fields that work across both PDF and Canvas formats.
+    In PDF, renders as blank lines for students to fill in.
+    In HTML/Canvas, can display the answer for checking.
 
     Example:
-        # Basic data table
-        data = [
-            ["Process A", "4MB", "Running"],
-            ["Process B", "2MB", "Waiting"]
-        ]
-        headers = ["Process", "Memory", "Status"]
-        table = ContentAST.Table(data=data, headers=headers, alignments=["left", "right", "center"])
-        body.add_element(table)
+        # Basic answer field
+        ans = ContentAST.Answer.integer("result", 42, label="Result", unit="MB")
+        body.add_element(ans)
+        answers.append(ans)  # Track for Canvas export
+    """
 
-        # Mixed content table
-        data = [
-            [ContentAST.Text("x"), ContentAST.Equation("x^2", inline=True)],
-            [ContentAST.Text("y"), ContentAST.Equation("y^2", inline=True)]
-        ]
-    """
-    
-    def __init__(self, data, headers=None, alignments=None, padding=False, transpose=False, hide_rules=False):
-      # todo: fix alignments
-      # todo: implement transpose
-      super().__init__()
-      
-      # Normalize data to ContentAST elements
-      self.data = []
-      for row in data:
-        normalized_row = []
-        for cell in row:
-          if isinstance(cell, ContentAST.Element):
-            normalized_row.append(cell)
-          else:
-            normalized_row.append(ContentAST.Text(str(cell)))
-        self.data.append(normalized_row)
-      
-      # Normalize headers to ContentAST elements
-      if headers:
-        self.headers = []
-        for header in headers:
-          if isinstance(header, ContentAST.Element):
-            self.headers.append(header)
-          else:
-            self.headers.append(ContentAST.Text(str(header)))
-      else:
-        self.headers = None
-      
-      self.alignments = alignments
-      self.padding = padding,
-      self.hide_rules = hide_rules
-    
-    def render_markdown(self, **kwargs):
-      # Basic markdown table implementation
-      result = []
-      
-      if self.headers:
-        result.append("| " + " | ".join(str(h) for h in self.headers) + " |")
-        
-        if self.alignments:
-          align_row = []
-          for align in self.alignments:
-            if align == "left":
-              align_row.append(":---")
-            elif align == "right":
-              align_row.append("---:")
-            else:  # center
-              align_row.append(":---:")
-          result.append("| " + " | ".join(align_row) + " |")
-        else:
-          result.append("| " + " | ".join(["---"] * len(self.headers)) + " |")
-      
-      for row in self.data:
-        result.append("| " + " | ".join(str(cell) for cell in row) + " |")
-      
-      return "\n".join(result)
-    
-    def render_html(self, **kwargs):
-      # HTML table implementation
-      result = ["<table border=\"1\" style=\"border-collapse: collapse; width: 100%;\">"]
-      
-      result.append("  <tbody>")
-      
-      # Render headers as bold first row instead of <th> tags for Canvas compatibility
-      if self.headers:
-        result.append("    <tr>")
-        for i, header in enumerate(self.headers):
-          align_attr = ""
-          if self.alignments and i < len(self.alignments):
-            align_attr = f' align="{self.alignments[i]}"'
-          # Render header as bold content in regular <td> tag
-          rendered_header = header.render(output_format="html", **kwargs)
-          result.append(
-            f"      <td style=\"padding: {'5px' if self.padding else '0x'}; font-weight: bold; {align_attr};\"><b>{rendered_header}</b></td>"
-          )
-        result.append("    </tr>")
-      
-      # Render data rows
-      for row in self.data:
-        result.append("    <tr>")
-        for i, cell in enumerate(row):
-          if isinstance(cell, ContentAST.Element):
-            cell = cell.render(output_format="html", **kwargs)
-          align_attr = ""
-          if self.alignments and i < len(self.alignments):
-            align_attr = f' align="{self.alignments[i]}"'
-          result.append(f"      <td  style=\"padding: {'5px' if self.padding else '0x'} ; {align_attr};\">{cell}</td>")
-        result.append("    </tr>")
-      result.append("  </tbody>")
-      result.append("</table>")
-      
-      return "\n".join(result)
-    
-    def render_latex(self, **kwargs):
-      # LaTeX table implementation
-      if self.alignments:
-        col_spec = "".join(
-          "l" if a == "left" else "r" if a == "right" else "c"
-          for a in self.alignments
-        )
-      else:
-        col_spec = '|'.join(["l"] * (len(self.headers) if self.headers else len(self.data[0])))
-      
-      result = [f"\\begin{{tabular}}{{{col_spec}}}"]
-      if not self.hide_rules: result.append("\\toprule")
-      
-      if self.headers:
-        # Now all headers are ContentAST elements, so render them consistently
-        rendered_headers = [header.render(output_format="latex", **kwargs) for header in self.headers]
-        result.append(" & ".join(rendered_headers) + " \\\\")
-        if not self.hide_rules: result.append("\\midrule")
-      
-      for row in self.data:
-        # All data cells are now ContentAST elements, so render them consistently
-        rendered_row = [cell.render(output_format="latex", **kwargs) for cell in row]
-        result.append(" & ".join(rendered_row) + " \\\\")
-      
-      if len(self.data) > 1 and not self.hide_rules:
-        result.append("\\bottomrule")
-      result.append("\\end{tabular}")
-      
-      return "\n\n" + "\n".join(result)
-    
-    def render_typst(self, **kwargs):
-      """
-      Render table in Typst format using native table() function.
-
-      Typst syntax:
-      #table(
-        columns: N,
-        align: (left, center, right),
-        [Header1], [Header2],
-        [Cell1], [Cell2]
-      )
-      """
-      # Determine number of columns
-      num_cols = len(self.headers) if self.headers else len(self.data[0])
-      
-      # Build alignment specification
-      if self.alignments:
-        # Map alignment strings to Typst alignment
-        align_map = {"left": "left", "right": "right", "center": "center"}
-        aligns = [align_map.get(a, "left") for a in self.alignments]
-        align_spec = f"align: ({', '.join(aligns)})"
-      else:
-        align_spec = "align: left"
-      
-      # Start table
-      result = [f"table("]
-      result.append(f"  columns: {num_cols},")
-      result.append(f"  {align_spec},")
-      
-      # Add stroke if not hiding rules
-      if not self.hide_rules:
-        result.append(f"  stroke: 0.5pt,")
-      else:
-        result.append(f"  stroke: none,")
-      
-      # Collect all rows (headers + data) and calculate column widths for alignment
-      all_rows = []
-      
-      # Render headers
-      if self.headers:
-        header_cells = []
-        for header in self.headers:
-          rendered = header.render(output_format="typst", **kwargs).strip()
-          header_cells.append(f"[*{rendered}*]")
-        all_rows.append(header_cells)
-      
-      # Render data rows
-      for row in self.data:
-        row_cells = []
-        for cell in row:
-          rendered = cell.render(output_format="typst", **kwargs).strip()
-          row_cells.append(f"[{rendered}]")
-        all_rows.append(row_cells)
-      
-      # Calculate max width for each column
-      col_widths = [0] * num_cols
-      for row in all_rows:
-        for i, cell in enumerate(row):
-          col_widths[i] = max(col_widths[i], len(cell))
-      
-      # Format rows with padding
-      for row in all_rows:
-        padded_cells = []
-        for i, cell in enumerate(row):
-          padded_cells.append(cell.ljust(col_widths[i]))
-        result.append(f"  {', '.join(padded_cells)},")
-      
-      result.append(")")
-      
-      return "\n#box(" + "\n".join(result) + "\n)"
-  
-  class TableGroup(Container):
-    """
-    Container for displaying multiple tables side-by-side in LaTeX, stacked in HTML.
-
-    Use this when you need to show multiple related tables together, such as
-    multiple page tables in hierarchical paging questions. In LaTeX, tables
-    are displayed side-by-side using minipages. In HTML/Canvas, they're stacked
-    vertically for better mobile compatibility.
-
-    When to use:
-    - Multiple related tables that should be visually grouped
-    - Page tables in hierarchical paging
-    - Comparison of multiple data structures
-
-    Features:
-    - Automatic side-by-side layout in PDF (using minipages)
-    - Vertical stacking in HTML for better readability
-    - Automatic width calculation based on number of tables
-    - Optional labels for each table
-
-    Example:
-        # Create table group with labels
-        table_group = ContentAST.TableGroup()
-
-        table_group.add_table(
-            label="Page Table #0",
-            table=ContentAST.Table(headers=["PTI", "PTE"], data=pt0_data)
-        )
-
-        table_group.add_table(
-            label="Page Table #1",
-            table=ContentAST.Table(headers=["PTI", "PTE"], data=pt1_data)
-        )
-
-        body.add_element(table_group)
-    """
-    def __init__(self):
-      super().__init__()
-      self.tables = []  # List of (label, table) tuples
-
-    def add_table(self, table: ContentAST.Table, label: str = None):
-      """
-      Add a table to the group with an optional label.
-
-      Args:
-          table: ContentAST.Table to add
-          label: Optional label to display above the table
-      """
-      self.tables.append((label, table))
-
-    def render_html(self, **kwargs):
-      # Stack tables vertically in HTML
-      result = []
-      for label, table in self.tables:
-        if label:
-          result.append(f"<p><b>{label}</b></p>")
-        result.append(table.render("html", **kwargs))
-      return "\n".join(result)
-
-    def render_latex(self, **kwargs):
-      if not self.tables:
-        return ""
-
-      # Calculate width based on number of tables
-      num_tables = len(self.tables)
-      if num_tables == 1:
-        width = 0.9
-      elif num_tables == 2:
-        width = 0.45
-      else:  # 3 or more
-        width = 0.30
-
-      result = ["\n\n"]  # Add spacing before table group
-
-      for i, (label, table) in enumerate(self.tables):
-        result.append(f"\\begin{{minipage}}{{{width}\\textwidth}}")
-
-        if label:
-          # Escape # characters in labels for LaTeX
-          escaped_label = label.replace("#", r"\#")
-          result.append(f"\\textbf{{{escaped_label}}}")
-          result.append("\\vspace{0.1cm}")
-
-        # Render the table
-        table_latex = table.render("latex", **kwargs)
-        result.append(table_latex)
-
-        result.append("\\end{minipage}")
-
-        # Add horizontal spacing between tables (but not after the last one)
-        if i < num_tables - 1:
-          result.append("\\hfill")
-
-      return "\n".join(result)
-
-    def render_typst(self, **kwargs):
-      """
-      Render table group in Typst format using grid layout for side-by-side tables.
-
-      Uses Typst's grid() function to arrange tables horizontally with automatic
-      column sizing and spacing.
-      """
-      if not self.tables:
-        return ""
-
-      num_tables = len(self.tables)
-
-      # Start grid with equal-width columns and some spacing
-      result = ["\n#grid("]
-      result.append(f"  columns: {num_tables},")
-      result.append(f"  column-gutter: 1em,")
-      result.append(f"  row-gutter: 0.5em,")
-
-      # Add each table as a grid cell
-      for label, table in self.tables:
-        result.append("  [")  # Start grid cell
-
-        if label:
-          # Escape # characters in labels (already done by Text.render_typst)
-          result.append(f"    *{label}*")
-          result.append("    #v(0.1cm)")
-          result.append("")  # Empty line for spacing
-
-        # Render the table (indent for readability)
-        table_typst = table.render("typst", **kwargs)
-        # Indent each line of the table
-        indented_table = "\n".join(f"    {line}" if line else "" for line in table_typst.split("\n"))
-        result.append(indented_table)
-
-        result.append("  ],")  # End grid cell
+    DEFAULT_ROUNDING_DIGITS = 4
 
-      result.append(")")
-      result.append("")  # Empty line after grid
+    class CanvasAnswerKind(enum.Enum):
+      BLANK = "fill_in_multiple_blanks_question"
+      MULTIPLE_ANSWER = "multiple_answers_question"
+      ESSAY = "essay_question"
+      MULTIPLE_DROPDOWN = "multiple_dropdowns_question"
+      NUMERICAL_QUESTION = "numerical_question"
 
-      return "\n".join(result)
+    class VariableKind(enum.Enum):
+      STR = enum.auto()
+      INT = enum.auto()
+      FLOAT = enum.auto()
+      BINARY = enum.auto()
+      HEX = enum.auto()
+      BINARY_OR_HEX = enum.auto()
+      AUTOFLOAT = enum.auto()
+      LIST = enum.auto()
+      VECTOR = enum.auto()
+      MATRIX = enum.auto()
 
-  class AnswerBlock(Table):
-    """
-    Specialized table for organizing multiple answer fields with proper spacing.
+    def __init__(
+        self,
+        value=None,
+        kind: ContentAST.Answer.CanvasAnswerKind = None,
+        variable_kind: ContentAST.Answer.VariableKind = None,
+        *,
+        # Data fields (from misc.Answer)
+        display=None,
+        length=None,
+        correct=True,
+        baffles=None,
+        pdf_only=False,
+        # Rendering fields (from ContentAST.Answer)
+        label: str = "",
+        unit: str = "",
+        blank_length=5,
+    ):
+      
+      # Initialize Leaf with label as content
+      super().__init__(content=label if label else "")
 
-    Creates a clean layout for multiple answer inputs with extra vertical
-    spacing in PDF output. Inherits from Table but optimized for answers.
+      # Data fields
+      self.key = str(uuid.uuid4())
+      self.value = value
+      self.kind = kind if kind is not None else ContentAST.Answer.CanvasAnswerKind.BLANK
+      self.variable_kind = variable_kind if variable_kind is not None else ContentAST.Answer.VariableKind.STR
 
-    When to use:
-    - Questions with multiple answer fields
-    - Organized answer input sections
-    - Better visual grouping of related answers
+      # For list values in display, show the first option (or join them with /)
+      if display is not None:
+        self.display = display
+      elif isinstance(value, list) and isinstance(self.variable_kind, AnswerTypes.String):
+        self.display = value[0] if len(value) == 1 else " / ".join(value)
+      else:
+        self.display = value
 
-    Example:
-        # Multiple related answers - Answer extends Leaf, use factory methods
-        memory_ans = ContentAST.Answer.integer("memory", self.memory_value, label="Memory used", unit="MB")
-        time_ans = ContentAST.Answer.auto_float("time", self.time_value, label="Execution time", unit="ms")
-        answer_block = ContentAST.AnswerBlock([memory_ans, time_ans])
-        body.add_element(answer_block)
+      self.length = length  # Used for bits and hex to be printed appropriately
+      self.correct = correct
+      self.baffles = baffles
+      self.pdf_only = pdf_only
 
-        # Single answer with better spacing
-        result_ans = ContentAST.Answer.integer("result", self.result_value, label="Final result")
-        single_answer = ContentAST.AnswerBlock(result_ans)
-    """
-    def __init__(self, answers: ContentAST.Answer|List[ContentAST.Answer]):
-      if not isinstance(answers, list):
-        answers = [answers]
+      # Rendering fields
+      self.label = label
+      self.unit = unit
+      self.blank_length = blank_length
 
-      super().__init__(
-        data=[
-          [answer]
-          for answer in answers
+    # Canvas export methods (from misc.Answer)
+    def get_for_canvas(self, single_answer=False) -> List[dict]:
+      """Generate Canvas answer dictionaries based on variable_kind."""
+      
+      # If this answer is PDF-only, don't send it to Canvas
+      if self.pdf_only:
+        return []
+
+      canvas_answers = []
+      if isinstance(self.value, list):
+        canvas_answers = [
+          {
+            "blank_id": self.key,
+            "answer_text": str(alt),
+            "answer_weight": 100 if self.correct else 0,
+          }
+          for alt in self.value
         ]
-      )
-      self.hide_rules = True
+      else:
+        canvas_answers = [{
+          "blank_id": self.key,
+          "answer_text": self.value,
+          "answer_weight": 100 if self.correct else 0,
+        }]
 
-    def add_element(self, element):
-      self.data.append(element)
+      # Add baffles (incorrect answer choices)
+      if self.baffles is not None:
+        for baffle in self.baffles:
+          canvas_answers.append({
+            "blank_id": self.key,
+            "answer_text": baffle,
+            "answer_weight": 0,
+          })
 
-    def render_latex(self, **kwargs):
-      rendered_content = super().render_latex(**kwargs)
-      content = (
-        r"{"
-        r"\setlength{\extrarowheight}{20pt}"
-        + rendered_content +
-        r"}"
-      )
-      return content
+      return canvas_answers
 
-  ## Specialized Elements
-  class RepeatedProblemPart(Container):
-    """
-    Multi-part problem renderer for questions with labeled subparts (a), (b), (c), etc.
+    def get_display_string(self) -> str:
+      """Get the formatted display string for this answer (for grading/answer keys)."""
+      return str(self.display if hasattr(self, 'display') else self.value)
 
-    Creates the specialized alignat* LaTeX format for multipart math problems
-    where each subpart is labeled and aligned properly. Used primarily for
-    vector math questions that need multiple similar calculations.
+    # Rendering methods (override Leaf's defaults)
+    def render_markdown(self, **kwargs):
+      return f"{self.label + (':' if len(self.label) > 0 else '')} [{self.key}] {self.unit}".strip()
 
-    When to use:
-    - Questions with multiple subparts that need (a), (b), (c) labeling
-    - Vector math problems with repeated calculations
-    - Any math problem where subparts should be aligned
+    def render_html(self, show_answers=False, can_be_numerical=False, **kwargs):
+      if can_be_numerical:
+        return f"Calculate {self.label}"
+      if show_answers:
+        answer_display = self.get_display_string()
+        label_part = f"{self.label}:" if self.label else ""
+        unit_part = f" {self.unit}" if self.unit else ""
+        return f"{label_part} <strong>{answer_display}</strong>{unit_part}".strip()
+      else:
+        return self.render_markdown(**kwargs)
 
-    Features:
-    - Automatic subpart labeling with (a), (b), (c), etc.
-    - Proper LaTeX alignat* formatting for PDF
-    - HTML fallback with organized layout
-    - Flexible content support (equations, matrices, etc.)
+    def render_latex(self, **kwargs):
+      return fr"{self.label + (':' if len(self.label) > 0 else '')} \answerblank{{{self.blank_length}}} {self.unit}".strip()
 
-    Example:
-        # Create subparts for vector dot products
-        subparts = [
-            (ContentAST.Matrix([[1], [2]]), "\\cdot", ContentAST.Matrix([[3], [4]])),
-            (ContentAST.Matrix([[5], [6]]), "\\cdot", ContentAST.Matrix([[7], [8]]))
-        ]
-        repeated_part = ContentAST.RepeatedProblemPart(subparts)
-        body.add_element(repeated_part)
-    """
-    def __init__(self, subpart_contents):
-      """
-      Create a repeated problem part with multiple subquestions.
+    def render_typst(self, **kwargs):
+      """Render answer blank as an underlined space in Typst."""
+      blank_width = self.blank_length * 0.75  # Convert character length to cm
+      blank = f"#fillline(width: {blank_width}cm)"
 
-      Args:
-          subpart_contents: List of content for each subpart.
-                           Each item can be:
-                           - A string (rendered as equation)
-                           - A ContentAST.Element
-                           - A tuple/list of elements to be joined
-      """
-      super().__init__()
-      self.subpart_contents = subpart_contents
+      label_part = f"{self.label}:" if self.label else ""
+      unit_part = f" {self.unit}" if self.unit else ""
 
-    def render_markdown(self, **kwargs):
-      result = []
-      for i, content in enumerate(self.subpart_contents):
-        letter = chr(ord('a') + i)  # Convert to (a), (b), (c), etc.
-        if isinstance(content, str):
-          result.append(f"({letter}) {content}")
-        elif isinstance(content, (list, tuple)):
-          content_str = " ".join(str(item) for item in content)
-          result.append(f"({letter}) {content_str}")
-        else:
-          result.append(f"({letter}) {str(content)}")
-      return "\n\n".join(result)
+      return f"{label_part} {blank}{unit_part}".strip()
+    
+    # Factory methods for common answer types
+    @classmethod
+    def dropdown(cls, value: str, baffles: list = None, **kwargs) -> 'ContentAST.Answer':
+      """Create a dropdown answer with wrong answer choices (baffles)"""
+      return cls(
+        value=value,
+        kind=cls.CanvasAnswerKind.MULTIPLE_DROPDOWN,
+        baffles=baffles,
+        **kwargs
+      )
 
-    def render_html(self, **kwargs):
-      result = []
-      for i, content in enumerate(self.subpart_contents):
-        letter = chr(ord('a') + i)
-        if isinstance(content, str):
-          result.append(f"<p>({letter}) {content}</p>")
-        elif isinstance(content, (list, tuple)):
-          rendered_items = []
-          for item in content:
-            if hasattr(item, 'render'):
-              rendered_items.append(item.render('html', **kwargs))
-            else:
-              rendered_items.append(str(item))
-          content_str = " ".join(rendered_items)
-          result.append(f"<p>({letter}) {content_str}</p>")
-        else:
-          if hasattr(content, 'render'):
-            content_str = content.render('html', **kwargs)
-          else:
-            content_str = str(content)
-          result.append(f"<p>({letter}) {content_str}</p>")
-      return "\n".join(result)
+    @classmethod
+    def multiple_choice(cls, key: str, value: str, baffles: list = None, **kwargs) -> 'ContentAST.Answer':
+      """Create a multiple choice answer with wrong answer choices (baffles)"""
+      return cls(
+        value=value,
+        kind=cls.CanvasAnswerKind.MULTIPLE_ANSWER,
+        baffles=baffles,
+        **kwargs
+      )
 
-    def render_latex(self, **kwargs):
-      if not self.subpart_contents:
-        return ""
+    # Static helper methods
+    @staticmethod
+    def _to_fraction(x):
+      """Convert int/float/decimal.Decimal/fractions.Fraction/str to fractions.Fraction exactly."""
+      if isinstance(x, fractions.Fraction):
+        return x
+      if isinstance(x, int):
+        return fractions.Fraction(x, 1)
+      if isinstance(x, decimal.Decimal):
+        # exact conversion of decimal.Decimal to fractions.Fraction
+        sign, digits, exp = x.as_tuple()
+        n = 0
+        for d in digits:
+          n = n * 10 + d
+        n = -n if sign else n
+        if exp >= 0:
+          return fractions.Fraction(n * (10 ** exp), 1)
+        else:
+          return fractions.Fraction(n, 10 ** (-exp))
+      if isinstance(x, str):
+        s = x.strip()
+        if '/' in s:
+          a, b = s.split('/', 1)
+          return fractions.Fraction(int(a.strip()), int(b.strip()))
+        return fractions.Fraction(decimal.Decimal(s))
+      # float or other numerics
+      return fractions.Fraction(decimal.Decimal(str(x)))
 
-      # Start alignat environment - use 2 columns for alignment
-      result = [r"\begin{alignat*}{2}"]
+    @staticmethod
+    def accepted_strings(
+        value,
+        *,
+        allow_integer=True,
+        allow_simple_fraction=True,
+        max_denominator=720,
+        allow_mixed=False,
+        include_spaces=False,
+        include_fixed_even_if_integer=False
+    ):
+      """Return a sorted list of strings you can paste into Canvas as alternate correct answers."""
+      decimal.getcontext().prec = max(34, (ContentAST.Answer.DEFAULT_ROUNDING_DIGITS or 0) + 10)
+      f = ContentAST.Answer._to_fraction(value)
+      outs = set()
 
-      for i, content in enumerate(self.subpart_contents):
-        letter = chr(ord('a') + i)
-        spacing = r"\\[6pt]" if i < len(self.subpart_contents) - 1 else r" \\"
+      # Integer form
+      if f.denominator == 1 and allow_integer:
+        outs.add(str(f.numerator))
+        if include_fixed_even_if_integer:
+          q = decimal.Decimal(1).scaleb(-ContentAST.Answer.DEFAULT_ROUNDING_DIGITS)
+          d = decimal.Decimal(f.numerator).quantize(q, rounding=decimal.ROUND_HALF_UP)
+          outs.add(format(d, 'f'))
 
-        if isinstance(content, str):
-          # Treat as raw LaTeX equation content
-          result.append(f"({letter})\\;& {content} &=&\\; {spacing}")
-        elif isinstance(content, (list, tuple)):
-          # Join multiple elements (e.g., matrix, operator, matrix)
-          rendered_items = []
-          for item in content:
-            if hasattr(item, 'render'):
-              rendered_items.append(item.render('latex', **kwargs))
-            elif isinstance(item, str):
-              rendered_items.append(item)
-            else:
-              rendered_items.append(str(item))
-          content_str = " ".join(rendered_items)
-          result.append(f"({letter})\\;& {content_str} &=&\\; {spacing}")
-        else:
-          # Single element (ContentAST element or string)
-          if hasattr(content, 'render'):
-            content_str = content.render('latex', **kwargs)
+      # Simple fraction
+      if allow_simple_fraction:
+        fr = f.limit_denominator(max_denominator)
+        if fr == f:
+          a, b = fr.numerator, fr.denominator
+          if fr.denominator > 1:
+            outs.add(f"{a}/{b}")
+            if include_spaces:
+              outs.add(f"{a} / {b}")
+            if allow_mixed and b != 1 and abs(a) > b:
+              sign = '-' if a < 0 else ''
+              A = abs(a)
+              whole, rem = divmod(A, b)
+              outs.add(f"{sign}{whole} {rem}/{b}")
           else:
-            content_str = str(content)
-          result.append(f"({letter})\\;& {content_str} &=&\\; {spacing}")
-
-      result.append(r"\end{alignat*}")
-      return "\n".join(result)
+            return sorted(outs, key=lambda s: (len(s), s))
 
-  class OnlyLatex(Container):
-    """
-    Container element that only renders content in LaTeX/PDF output format.
+      # Fixed-decimal form
+      q = decimal.Decimal(1).scaleb(-ContentAST.Answer.DEFAULT_ROUNDING_DIGITS)
+      d = (decimal.Decimal(f.numerator) / decimal.Decimal(f.denominator)).quantize(q, rounding=decimal.ROUND_HALF_UP)
+      outs.add(format(d, 'f'))
 
-    Use this when you need LaTeX-specific content that should not appear
-    in HTML/Canvas or Markdown outputs. Content is completely hidden
-    from non-LaTeX formats.
+      # Trimmed decimal
+      if ContentAST.Answer.DEFAULT_ROUNDING_DIGITS:
+        q = decimal.Decimal(1).scaleb(-ContentAST.Answer.DEFAULT_ROUNDING_DIGITS)
+        d = (decimal.Decimal(f.numerator) / decimal.Decimal(f.denominator)).quantize(q, rounding=decimal.ROUND_HALF_UP)
+        s = format(d, 'f').rstrip('0').rstrip('.')
+        if s.startswith('.'):
+          s = '0' + s
+        if s == '-0':
+          s = '0'
+        outs.add(s)
 
-    When to use:
-    - LaTeX-specific formatting that has no HTML equivalent
-    - PDF-only instructions or content
-    - Complex LaTeX commands that break HTML rendering
+      return sorted(outs, key=lambda s: (len(s), s))
+    
+    @staticmethod
+    def fix_negative_zero(x):
+      """Fix -0.0 display issue."""
+      return 0.0 if x == 0 else x
 
-    Example:
-        # LaTeX-only spacing or formatting
-        latex_only = ContentAST.OnlyLatex()
-        latex_only.add_element(ContentAST.Text("\\newpage"))
 
-        # Add to main content - only appears in PDF
-        body.add_element(latex_only)
+class AnswerTypes:
+  # Multibase answers that can accept either hex, binary or decimal
+  class MultiBase(ContentAST.Answer):
+    """
+    These are answers that can accept answers in any sort of format, and default to displaying in hex when written out.
+    This will be the parent class for Binary, Hex, and Integer answers most likely.
     """
+    def get_for_canvas(self, single_answer=False) -> List[dict]:
 
-    def render(self, output_format: ContentAST.OutputFormat, **kwargs):
-      if output_format not in ("latex", "typst"):
-        return ""
-      return super().render(output_format=output_format, **kwargs)
+      canvas_answers = [
+        {
+          "blank_id": self.key,
+          "answer_text": f"{self.value:0{self.length if self.length is not None else 0}b}",
+          "answer_weight": 100 if self.correct else 0,
+        },
+        {
+          "blank_id": self.key,
+          "answer_text": f"0b{self.value:0{self.length if self.length is not None else 0}b}",
+          "answer_weight": 100 if self.correct else 0,
+        },
+        {
+          "blank_id": self.key,
+          "answer_text": f"{self.value:0{math.ceil(self.length / 8) if self.length is not None else 0}X}",
+          "answer_weight": 100 if self.correct else 0,
+        },
+        {
+          "blank_id": self.key,
+          "answer_text": f"0x{self.value:0{math.ceil(self.length / 8) if self.length is not None else 0}X}",
+          "answer_weight": 100 if self.correct else 0,
+        },
+        {
+          "blank_id": self.key,
+          "answer_text": f"{self.value}",
+          "answer_weight": 100 if self.correct else 0,
+        },
+      ]
+      
+      return canvas_answers
+
+    def get_display_string(self) -> str:
+      # This is going to be the default for multi-base answers, but may change later.
+      hex_digits = (self.length // 4) + 1 if self.length is not None else 0
+      return f"0x{self.value:0{hex_digits}X}"
   
-  class OnlyHtml(Container):
-    """
-    Container element that only renders content in HTML/Canvas output format.
+  class Hex(MultiBase):
+    pass
+  
+  class Binary(MultiBase):
+    def get_display_string(self) -> str:
+      return f"0b{self.value:0{self.length if self.length is not None else 0}b}"
+  
+  class Decimal(MultiBase):
+    def get_display_string(self) -> str:
+      return f"{self.value:0{self.length if self.length is not None else 0}}"
 
-    Use this when you need HTML-specific content that should not appear
-    in LaTeX/PDF or Markdown outputs. Content is completely hidden
-    from non-HTML formats.
+  # Concrete type answers
+  class Float(ContentAST.Answer):
+    def get_for_canvas(self, single_answer=False) -> List[dict]:
+      if single_answer:
+        canvas_answers = [
+          {
+            "numerical_answer_type": "exact_answer",
+            "answer_text": round(self.value, ContentAST.Answer.DEFAULT_ROUNDING_DIGITS),
+            "answer_exact": round(self.value, ContentAST.Answer.DEFAULT_ROUNDING_DIGITS),
+            "answer_error_margin": 0.1,
+            "answer_weight": 100 if self.correct else 0,
+          }
+        ]
+      else:
+        # Use the accepted_strings helper
+        answer_strings = ContentAST.Answer.accepted_strings(
+          self.value,
+          allow_integer=True,
+          allow_simple_fraction=True,
+          max_denominator=60,
+          allow_mixed=True,
+          include_spaces=False,
+          include_fixed_even_if_integer=True
+        )
+        
+        canvas_answers = [
+          {
+            "blank_id": self.key,
+            "answer_text": answer_string,
+            "answer_weight": 100 if self.correct else 0,
+          }
+          for answer_string in answer_strings
+        ]
+      return canvas_answers
+  
+    def get_display_string(self) -> str:
+      rounded = round(self.value, ContentAST.Answer.DEFAULT_ROUNDING_DIGITS)
+      return f"{self.fix_negative_zero(rounded)}"
+  
+  class Int(ContentAST.Answer):
 
-    When to use:
-    - Canvas-specific instructions or formatting
-    - HTML-only interactive elements
-    - Content that doesn't translate well to PDF
+    # Canvas export methods (from misc.Answer)
+    def get_for_canvas(self, single_answer=False) -> List[dict]:
+      canvas_answers = [
+        {
+          "blank_id": self.key,
+          "answer_text": str(int(self.value)),
+          "answer_weight": 100 if self.correct else 0,
+        }
+      ]
+      return canvas_answers
 
-    Example:
-        # HTML-only instructions
-        html_only = ContentAST.OnlyHtml()
-        html_only.add_element(ContentAST.Text("Click submit when done"))
+  # Open Ended
+  class OpenEnded(ContentAST.Answer):
+    def __init__(self, *args, **kwargs):
+      super().__init__(*args, **kwargs)
+      self.kind=ContentAST.Answer.CanvasAnswerKind.ESSAY
+  
+  class String(ContentAST.Answer):
+    pass
+  
+  class List(ContentAST.Answer):
+    def __init__(self, order_matters=True, *args, **kwargs):
+      super().__init__(*args, **kwargs)
+      self.order_matters = order_matters
+    
+    def get_for_canvas(self, single_answer=False):
+      if self.order_matters:
+        canvas_answers = [
+          {
+            "blank_id": self.key,
+            "answer_text": ', '.join(map(str, self.value)),
+            "answer_weight": 100 if self.correct else 0,
+          },
+          {
+            "blank_id": self.key,
+            "answer_text": ','.join(map(str, self.value)),
+            "answer_weight": 100 if self.correct else 0,
+          }
+        ]
+      else:
+        canvas_answers = []
+        
+        # With spaces
+        canvas_answers.extend([
+          {
+            "blank_id": self.key,
+            "answer_text": ', '.join(map(str, possible_state)),
+            "answer_weight": 100 if self.correct else 0,
+          }
+          for possible_state in itertools.permutations(self.value)
+        ])
+        
+        # Without spaces
+        canvas_answers.extend([
+          {
+            "blank_id": self.key,
+            "answer_text": ','.join(map(str, possible_state)),
+            "answer_weight": 100 if self.correct else 0,
+          }
+          for possible_state in itertools.permutations(self.value)
+        ])
+      return canvas_answers
 
-        # Add to main content - only appears in Canvas
-        body.add_element(html_only)
+    def get_display_string(self) -> str:
+      """Get the formatted display string for this answer (for grading/answer keys)."""
+      return ", ".join(str(v) for v in self.value)
+
+  # Math types
+  class Vector(ContentAST.Answer):
+    """
+    These are self-contained vectors that will go in a single answer block
     """
     
-    def render(self, output_format, **kwargs):
-      if output_format != "html":
-        return ""
-      return super().render(output_format, **kwargs)
+    # Canvas export methods (from misc.Answer)
+    def get_for_canvas(self, single_answer=False) -> List[dict]:
+      # Get all answer variations
+      answer_variations = [
+        ContentAST.Answer.accepted_strings(dimension_value)
+        for dimension_value in self.value
+      ]
+      
+      canvas_answers = []
+      for combination in itertools.product(*answer_variations):
+        # Add without anything surrounding
+        canvas_answers.extend([
+          {
+            "blank_id": self.key,
+            "answer_weight": 100 if self.correct else 0,
+            "answer_text": f"{', '.join(combination)}",
+          },
+          {
+            "blank_id": self.key,
+            "answer_weight": 100 if self.correct else 0,
+            "answer_text": f"{','.join(combination)}",
+          },
+          # Add parentheses format
+          {
+            "blank_id": self.key,
+            "answer_weight": 100 if self.correct else 0,
+            "answer_text": f"({', '.join(list(combination))})",
+          },
+          {
+            "blank_id": self.key,
+            "answer_weight": 100 if self.correct else 0,
+            "answer_text": f"({','.join(list(combination))})",
+          },
+          # Add square brackets
+          {
+            "blank_id": self.key,
+            "answer_weight": 100 if self.correct else 0,
+            "answer_text": f"[{', '.join(list(combination))}]",
+          },
+          {
+            "blank_id": self.key,
+            "answer_weight": 100 if self.correct else 0,
+            "answer_text": f"[{','.join(list(combination))}]",
+          }
+        ])
+      return canvas_answers
+      
+    def get_display_string(self) -> str:
+      return ", ".join(
+        str(self.fix_negative_zero(round(v, ContentAST.Answer.DEFAULT_ROUNDING_DIGITS))).rstrip('0').rstrip('.') for v in self.value
+      )
+      
+  class CompoundAnswers(ContentAST.Answer):
+    pass
+    """
+    Going forward, this might make a lot of sense to have a SubAnswer class that we can iterate over.
+    We would convert into this shared format and just iterate over it whenever we need to.
+    """
+  
+  class Matrix(CompoundAnswers):
+    """
+    Matrix answers generate multiple blank_ids (e.g., M_0_0, M_0_1, M_1_0, M_1_1).
+    """
+    
+    def __init__(self, value, *args, **kwargs):
+      super().__init__(value=value, *args, **kwargs)
+      
+      self.data = [
+        [
+          AnswerTypes.Float(
+            value=self.value[i, j],
+            blank_length=5
+          )
+          for j in range(self.value.shape[1])
+        ]
+        for i in range(self.value.shape[0])
+      ]
+    
+    def get_for_canvas(self, single_answer=False) -> List[dict]:
+      """Generate Canvas answers for each matrix element."""
+      canvas_answers = []
+      
+      for sub_answer in itertools.chain.from_iterable(self.data):
+        canvas_answers.extend(sub_answer.get_for_canvas())
+      
+      return canvas_answers
+    
+    def render(self, *args, **kwargs) -> str:
+      table = ContentAST.Table(self.data)
+    
+      if self.label:
+        return ContentAST.Container(
+          [
+            ContentAST.Text(f"{self.label} = "),
+            table
+          ]
+        ).render(*args, **kwargs)
+      return table.render(*args, **kwargs)
+