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

QuizGenerator/mixins.py

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

QuizGenerator/premade_questions/basic.py

@@ -6,7 +6,7 @@ from typing import List, Dict, Any, Tuple
 import logging
 
 from QuizGenerator.contentast import *
-from QuizGenerator.question import Question, QuestionRegistry, Answer
+from QuizGenerator.question import Question, QuestionRegistry
 from QuizGenerator.mixins import TableQuestionMixin
 
 log = logging.getLogger(__name__)
@@ -25,8 +25,8 @@ class FromText(Question):
     
     return ContentAST.Section([ContentAST.Text(self.text)])
   
-  def get_answers(self, *args, **kwargs) -> Tuple[Answer.AnswerKind, List[Dict[str,Any]]]:
-    return Answer.AnswerKind.ESSAY, []
+  def get_answers(self, *args, **kwargs) -> Tuple[ContentAST.Answer.CanvasAnswerKind, List[Dict[str,Any]]]:
+    return ContentAST.Answer.CanvasAnswerKind.ESSAY, []
 
 
 @QuestionRegistry.register()

QuizGenerator/premade_questions/cst334/languages.py

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