QuizGenerator 0.4.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

QuizGenerator/contentast.py

@@ -2,23 +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.
@@ -664,15 +669,19 @@ class ContentAST:
     - Organizing complex question content
 
     Example:
-        def get_body(self):
+        def _get_body(self):
             body = ContentAST.Section()
+            answers = []
             body.add_element(ContentAST.Paragraph(["Calculate the determinant:"]))
 
             matrix_data = [[1, 2], [3, 4]]
             body.add_element(ContentAST.Matrix(data=matrix_data, bracket_type="v"))
 
-            body.add_element(ContentAST.Answer(answer=self.answer, label="Determinant"))
-            return body
+            # Answer extends Leaf - add directly to body
+            ans = ContentAST.Answer.integer("det", self.determinant, label="Determinant")
+            answers.append(ans)
+            body.add_element(ans)
+            return body, answers
     """
     pass
   
@@ -729,23 +738,41 @@ class ContentAST:
       if self.hide_from_latex:
         return ""
 
-      # This is for when we are passing in a code block via a FromText question
-      content = re.sub(
-        r"```\s*(.*)\s*```",
-        r"""
+      # Extract code blocks, render them, and replace with placeholders
+      # This prevents the # escaping from affecting content inside code blocks
+      code_blocks = []
+
+      def save_code_block(match):
+        code_content = match.group(1).strip()
+        # Escape quotes for Typst raw() function
+        escaped_content = code_content.replace('"', r'\"')
+        rendered_block = f"""
         #box(
-          raw("\1",
+          raw("{escaped_content}",
             block: true
           )
         )
-        """,
+        """
+        placeholder = f"__CODE_BLOCK_{len(code_blocks)}__"
+        code_blocks.append(rendered_block)
+        return placeholder
+
+      # Replace code blocks with placeholders
+      content = re.sub(
+        r"```\s*(.*)\s*```",
+        save_code_block,
         self.content,
         flags=re.DOTALL
       )
 
-      # In Typst, # starts code/function calls, so we need to escape it
+      # In Typst, # starts code/function calls, so we need to escape it in regular text
+      # (but not in code blocks, which are now placeholders)
       content = content.replace("# ", r"\# ")
-      
+
+      # Restore code blocks
+      for i, block in enumerate(code_blocks):
+        content = content.replace(f"__CODE_BLOCK_{i}__", block)
+
       if self.emphasis:
         content = f"*{content}*"
       return content
@@ -903,8 +930,19 @@ class ContentAST:
       # Convert subscripts and superscripts from LaTeX to Typst
       # LaTeX uses braces: b_{out}, x_{10}, x^{2}
       # Typst uses parentheses for multi-char: b_(out), x_(10), x^(2)
-      latex_str = re.sub(r'_{([^}]+)}', r'_("\1")', latex_str)  # _{...} -> _(...)
-      latex_str = re.sub(r'\^{([^}]+)}', r'^("\1")', latex_str)  # ^{...} -> ^(...)
+      # Multi-character text subscripts need quotes: L_{base} -> L_("base")
+      # But numbers don't: x_{10} -> x_(10)
+      def convert_sub_super(match):
+        content = match.group(1)
+        prefix = match.group(0)[0]  # '_' or '^'
+        # If it's purely numeric or a single char, no quotes needed
+        if content.isdigit() or len(content) == 1:
+          return f'{prefix}({content})'
+        # If it's multi-char text, quote it
+        return f'{prefix}("{content}")'
+
+      latex_str = re.sub(r'_{([^}]+)}', convert_sub_super, latex_str)
+      latex_str = re.sub(r'\^{([^}]+)}', convert_sub_super, latex_str)
 
       # Convert LaTeX Greek letters to Typst syntax (remove backslash)
       greek_letters = [
@@ -922,19 +960,66 @@ class ContentAST:
       latex_str = latex_str.replace(r'\nabla', 'nabla')
       latex_str = latex_str.replace(r'\times', 'times')
       latex_str = latex_str.replace(r'\cdot', 'dot')
-      latex_str = latex_str.replace(r'\partial', 'diff')
+      latex_str = latex_str.replace(r'\partial', 'partial')
+      latex_str = latex_str.replace(r'\sum', 'sum')
+      latex_str = latex_str.replace(r'\prod', 'product')
+      latex_str = latex_str.replace(r'\int', 'integral')
+      latex_str = latex_str.replace(r'\ln', 'ln')
+      latex_str = latex_str.replace(r'\log', 'log')
+      latex_str = latex_str.replace(r'\exp', 'exp')
+      latex_str = latex_str.replace(r'\sin', 'sin')
+      latex_str = latex_str.replace(r'\cos', 'cos')
+      latex_str = latex_str.replace(r'\tan', 'tan')
+      latex_str = latex_str.replace(r'\max', 'max')
+      latex_str = latex_str.replace(r'\min', 'min')
+      latex_str = latex_str.replace(r'\sqrt', 'sqrt')
+      # Convert \text{...} to "..." for Typst
+      latex_str = re.sub(r'\\text\{([^}]*)\}', r'"\1"', latex_str)
+      # Convert \frac{a}{b} to frac(a, b) for Typst
+      latex_str = re.sub(r'\\frac\{([^}]*)\}\{([^}]*)\}', r'frac(\1, \2)', latex_str)
+
+      # Handle matrix environments (bmatrix, pmatrix, vmatrix, Vmatrix, Bmatrix, matrix)
+      # Map bracket types to Typst delimiters
+      bracket_map = {
+        'bmatrix': '\"[\"',   # square brackets
+        'pmatrix': '\"(\"',   # parentheses (default)
+        'vmatrix': '\"|\"',   # single vertical bars (determinant)
+        'Vmatrix': '\"||\"',  # double vertical bars (norm)
+        'Bmatrix': '\"{\"',   # curly braces
+        'matrix': None,       # no brackets
+      }
+
+      for env_type, delim in bracket_map.items():
+        pattern = rf'\\begin\{{{env_type}\}}(.*?)\\end\{{{env_type}\}}'
+
+        def make_replacer(delimiter):
+          def replace_matrix(match):
+            content = match.group(1)
+            # Split rows by \\ and columns by &
+            rows = content.split(r'\\')
+            rows = [r.strip() for r in rows if r.strip()]
+
+            # Check if it's a vector (single column) or matrix
+            is_vector = all('&' not in row for row in rows)
+
+            if is_vector:
+              # Single column - use semicolons to separate rows in mat()
+              elements = "; ".join(rows)
+            else:
+              # Multiple columns - replace & with , and rows with ;
+              formatted_rows = [row.replace('&', ',').strip() for row in rows]
+              elements = "; ".join(formatted_rows)
 
-      # Handle matrix environments
-      if r'\begin{matrix}' in latex_str:
-        matrix_pattern = r'\[\\begin\{matrix\}(.*?)\\end\{matrix\}\]'
+            if delimiter:
+              return f"mat(delim: {delimiter}, {elements})"
+            else:
+              return f"mat({elements})"
+          return replace_matrix
 
-        def replace_matrix(match):
-          content = match.group(1)
-          elements = content.split(r'\\')
-          elements = [e.strip() for e in elements if e.strip()]
-          return f"vec({', '.join(elements)})"
+        latex_str = re.sub(pattern, make_replacer(delim), latex_str, flags=re.DOTALL)
 
-        latex_str = re.sub(matrix_pattern, replace_matrix, latex_str)
+      # Handle \left\| ... \right\| for norms
+      latex_str = re.sub(r'\\\|', '||', latex_str)
 
       return latex_str
 
@@ -955,6 +1040,125 @@ class ContentAST:
       
       return cls('\n'.join(equation_lines))
 
+  class MathExpression(Leaf):
+    """
+    Compose multiple math elements into a single format-independent expression.
+
+    This allows mixing ContentAST elements (like Matrix) with math operators
+    and symbols, with each part rendering appropriately for the target format.
+
+    Example:
+        # Vector magnitude: ||v|| =
+        body.add_element(ContentAST.MathExpression([
+            "||",
+            ContentAST.Matrix(data=[[1], [2], [3]], bracket_type="b"),
+            "|| = "
+        ]))
+
+        # Vector addition: a + b =
+        body.add_element(ContentAST.MathExpression([
+            ContentAST.Matrix(data=[[1], [2]], bracket_type="b"),
+            " + ",
+            ContentAST.Matrix(data=[[3], [4]], bracket_type="b"),
+            " = "
+        ]))
+
+    Parts can be:
+        - Strings: rendered as-is (math operators, symbols, etc.)
+        - ContentAST elements: call their render method for the target format
+    """
+    def __init__(self, parts, inline=False):
+      super().__init__("[math_expression]")
+      self.parts = parts  # List of strings and/or ContentAST elements
+      self.inline = inline
+
+    def _render_parts(self, output_format, **kwargs):
+      """Render all parts for the given output format."""
+      rendered = []
+      for part in self.parts:
+        if isinstance(part, str):
+          # Convert LaTeX operators to Typst if needed
+          if output_format == ContentAST.OutputFormat.TYPST:
+            part = part.replace(r'\cdot', ' dot ')
+            part = part.replace(r'\times', ' times ')
+            part = part.replace(r'\div', ' div ')
+          rendered.append(part)
+        elif isinstance(part, ContentAST.Element):
+          # Use dedicated math_content methods if available (cleaner than stripping delimiters)
+          if output_format == ContentAST.OutputFormat.HTML:
+            # For HTML (MathJax), use LaTeX math content
+            if hasattr(part, 'math_content_latex'):
+              rendered.append(part.math_content_latex())
+            else:
+              # Fallback: try to extract from render_html
+              html = part.render_html(**kwargs)
+              html = re.sub(r"<[^>]+>", "", html)
+              html = re.sub(r"^\$\$?\s*\\displaystyle\s*", "", html)
+              html = re.sub(r"^\$\$?\s*", "", html)
+              html = re.sub(r"\s*\$\$?$", "", html)
+              rendered.append(html)
+          elif output_format == ContentAST.OutputFormat.TYPST:
+            if hasattr(part, 'math_content_typst'):
+              rendered.append(part.math_content_typst())
+            else:
+              # Fallback: try to extract from render_typst
+              typst = part.render_typst(**kwargs)
+              typst = re.sub(r"^\s*\$\s*", "", typst)
+              typst = re.sub(r"\s*\$\s*$", "", typst)
+              rendered.append(typst)
+          elif output_format == ContentAST.OutputFormat.LATEX:
+            if hasattr(part, 'math_content_latex'):
+              rendered.append(part.math_content_latex())
+            else:
+              latex = part.render_latex(**kwargs)
+              latex = re.sub(r"^\\begin\{flushleft\}", "", latex)
+              latex = re.sub(r"\\end\{flushleft\}$", "", latex)
+              latex = re.sub(r"^\\\[", "", latex)
+              latex = re.sub(r"\\\]$", "", latex)
+              latex = re.sub(r"^\$", "", latex)
+              latex = re.sub(r"\$~?$", "", latex)
+              rendered.append(latex)
+          elif output_format == ContentAST.OutputFormat.MARKDOWN:
+            if hasattr(part, 'math_content_latex'):
+              rendered.append(part.math_content_latex())
+            else:
+              md = part.render_markdown(**kwargs)
+              md = re.sub(r"^\$", "", md)
+              md = re.sub(r"\$$", "", md)
+              rendered.append(md)
+        else:
+          # Convert to string as fallback
+          rendered.append(str(part))
+      return "".join(rendered)
+
+    def render_markdown(self, **kwargs):
+      content = self._render_parts(ContentAST.OutputFormat.MARKDOWN, **kwargs)
+      if self.inline:
+        return f"${content}$"
+      else:
+        return f"$\\displaystyle {content}$"
+
+    def render_html(self, **kwargs):
+      content = self._render_parts(ContentAST.OutputFormat.HTML, **kwargs)
+      if self.inline:
+        return f"\\({content}\\)"
+      else:
+        return f"<div class='math'>$$ \\displaystyle {content} \\; $$</div>"
+
+    def render_latex(self, **kwargs):
+      content = self._render_parts(ContentAST.OutputFormat.LATEX, **kwargs)
+      if self.inline:
+        return f"${content}$~"
+      else:
+        return f"\\begin{{flushleft}}${content}$\\end{{flushleft}}"
+
+    def render_typst(self, **kwargs):
+      content = self._render_parts(ContentAST.OutputFormat.TYPST, **kwargs)
+      if self.inline:
+        return f"${content}$"
+      else:
+        return f" $ {content} $ "
+
   class Matrix(Leaf):
     """
     Mathematical matrix renderer for consistent cross-format display.
@@ -999,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]]
@@ -1038,6 +1241,42 @@ class ContentAST:
       matrix_content = r" \\ ".join(rows)
       return f"\\begin{{{bracket_type}matrix}} {matrix_content} \\end{{{bracket_type}matrix}}"
 
+    def math_content_latex(self):
+      """Return raw LaTeX math content without delimiters (for use in MathExpression)."""
+      return ContentAST.Matrix.to_latex(self.data, self.bracket_type)
+
+    def math_content_typst(self):
+      """Return raw Typst math content without delimiters (for use in MathExpression)."""
+      # Build matrix content
+      rows = []
+      for row in self.data:
+        rows.append(", ".join(str(cell) for cell in row))
+
+      # Check if it's a vector (single column)
+      is_vector = all(len(row) == 1 for row in self.data)
+
+      if is_vector:
+        # Use vec() for vectors
+        matrix_content = ", ".join(str(row[0]) for row in self.data)
+        result = f"vec({matrix_content})"
+      else:
+        # Use mat() for matrices with semicolons separating rows
+        matrix_content = "; ".join(rows)
+        result = f"mat({matrix_content})"
+
+      # Add bracket delimiters if needed
+      if self.bracket_type == "b":  # square brackets
+        matrix_content_inner = ", ".join(str(row[0]) for row in self.data) if is_vector else "; ".join(rows)
+        result = f"mat(delim: \"[\", {matrix_content_inner})" if not is_vector else f"vec(delim: \"[\", {matrix_content_inner})"
+      elif self.bracket_type == "v":  # vertical bars (determinant)
+        result = f"mat(delim: \"|\", {'; '.join(rows)})"
+      elif self.bracket_type == "V":  # double vertical bars (norm)
+        result = f"mat(delim: \"||\", {'; '.join(rows)})"
+      elif self.bracket_type == "B":  # curly braces
+        result = f"mat(delim: \"{{\", {'; '.join(rows)})"
+
+      return result
+
     def render_markdown(self, **kwargs):
       matrix_env = "smallmatrix" if self.inline else f"{self.bracket_type}matrix"
       rows = []
@@ -1053,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
@@ -1154,8 +1393,6 @@ class ContentAST:
     def _ensure_image_saved(self):
       """Save image data to file if not already saved."""
       if self.path is None:
-        import os
-        import uuid
 
         # Create imgs directory if it doesn't exist (use absolute path)
         img_dir = os.path.abspath("imgs")
@@ -1231,81 +1468,6 @@ class ContentAST:
 
       return "\n".join(result)
 
-  class Answer(Leaf):
-    """
-    Answer input field that renders as blanks in PDF and shows answers in HTML.
-
-    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.
-
-    When to use:
-    - Any place where students need to input an answer
-    - Numerical answers, short text answers, etc.
-    - Questions requiring fill-in-the-blank responses
-
-    Example:
-        # Basic answer field
-        body.add_element(ContentAST.Answer(
-            answer=self.answer,
-            label="Result",
-            unit="MB"
-        ))
-
-        # Multiple choice or complex answers
-        body.add_element(ContentAST.Answer(
-            answer=[self.answer_a, self.answer_b],
-            label="Choose the best answer"
-        ))
-    """
-    
-    def __init__(self, answer, label: str = "", unit: str = "", blank_length=5):
-      super().__init__(label)
-      self.answer = answer
-      self.label = label
-      self.unit = unit
-      self.length = blank_length
-    
-    def render_markdown(self, **kwargs):
-      if not isinstance(self.answer, list):
-        key_to_display = self.answer.key
-      else:
-        key_to_display = self.answer[0].key
-      return f"{self.label + (':' if len(self.label) > 0 else '')} [{key_to_display}] {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 and self.answer:
-        # Show actual answer value using formatted display string
-        if not isinstance(self.answer, list):
-          answer_display = self.answer.get_display_string()
-        else:
-          answer_display = ", ".join(a.get_display_string() for a in self.answer)
-        
-        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:
-        # Default behavior: show [key]
-        return self.render_markdown(**kwargs)
-    
-    def render_latex(self, **kwargs):
-      return fr"{self.label + (':' if len(self.label) > 0 else '')} \answerblank{{{self.length}}} {self.unit}".strip()
-    
-    def render_typst(self, **kwargs):
-      """Render answer blank as an underlined space in Typst."""
-      # Use the fillline function defined in TYPST_HEADER
-      # Width is based on self.length (in cm)
-      blank_width = self.length * 0.75  # Convert character length to cm
-      blank = f"#fillline(width: {blank_width}cm)"
-      
-      label_part = f"{self.label}:" if self.label else ""
-      unit_part = f" {self.unit}" if self.unit else ""
-      
-      return f"{label_part} {blank}{unit_part}".strip()
-  
   class LineBreak(Text):
     def __init__(self, *args, **kwargs):
       super().__init__("\n\n")
@@ -1745,18 +1907,15 @@ class ContentAST:
     - Better visual grouping of related answers
 
     Example:
-        # Multiple related answers
-        answers = [
-            ContentAST.Answer(answer=self.memory_answer, label="Memory used", unit="MB"),
-            ContentAST.Answer(answer=self.time_answer, label="Execution time", unit="ms")
-        ]
-        answer_block = ContentAST.AnswerBlock(answers)
+        # 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)
 
         # Single answer with better spacing
-        single_answer = ContentAST.AnswerBlock(
-            ContentAST.Answer(answer=self.result, label="Final result")
-        )
+        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):
@@ -1920,9 +2079,9 @@ class ContentAST:
         # Add to main content - only appears in PDF
         body.add_element(latex_only)
     """
-    
+
     def render(self, output_format: ContentAST.OutputFormat, **kwargs):
-      if output_format != "latex":
+      if output_format not in ("latex", "typst"):
         return ""
       return super().render(output_format=output_format, **kwargs)
   
@@ -1952,4 +2111,537 @@ class ContentAST:
       if output_format != "html":
         return ""
       return super().render(output_format, **kwargs)
+  
+  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
+    """
+
+    DEFAULT_ROUNDING_DIGITS = 4
+
+    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"
+
+    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,
+        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 "")
+
+      # 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
+
+      # 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
+
+      self.length = length  # Used for bits and hex to be printed appropriately
+      self.correct = correct
+      self.baffles = baffles
+      self.pdf_only = pdf_only
+
+      # Rendering fields
+      self.label = label
+      self.unit = unit
+      self.blank_length = blank_length
+
+    # 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
+        ]
+      else:
+        canvas_answers = [{
+          "blank_id": self.key,
+          "answer_text": self.value,
+          "answer_weight": 100 if self.correct else 0,
+        }]
+
+      # 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,
+          })
+
+      return canvas_answers
+
+    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)
+
+    # 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()
+
+    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)"
+
+      label_part = f"{self.label}:" if self.label else ""
+      unit_part = f" {self.unit}" if self.unit else ""
+
+      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
+      )
+
+    @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
+      )
+
+    # 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)))
+
+    @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()
+
+      # 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'))
+
+      # 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'))
+
+      # 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)
+
+      # 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}")
+
+      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
+
+
+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]:
+
+      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 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}}"
+
+  # 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):
+
+    # 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
+
+  # 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
+
+    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
+    """
+    
+    # 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)
+