QuizGenerator 0.8.0__tar.gz → 0.9.0__tar.gz

{quizgenerator-0.8.0 → quizgenerator-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuizGenerator
-Version: 0.8.0
+Version: 0.9.0
 Summary: Generate randomized quiz questions for Canvas LMS and PDF exams
 Project-URL: Homepage, https://github.com/OtterDen-Lab/QuizGenerator
 Project-URL: Documentation, https://github.com/OtterDen-Lab/QuizGenerator/tree/main/documentation
@@ -150,26 +150,29 @@ All questions follow the same three‑method flow:
 
 ```python
 class MyQuestion(Question):
-    def _build_context(self, *, rng_seed=None, **kwargs):
+    @classmethod
+    def _build_context(cls, *, rng_seed=None, **kwargs):
         context = super()._build_context(rng_seed=rng_seed, **kwargs)
-        rng = context["rng"]
+        rng = context.rng
         context["value"] = rng.randint(1, 10)
         return context
 
-    def _build_body(self, context):
+    @classmethod
+    def _build_body(cls, context):
         body = ca.Section()
         body.add_element(ca.Paragraph([f"Value: {context['value']}"]))
         body.add_element(ca.AnswerTypes.Int(context["value"], label="Value"))
         return body
 
-    def _build_explanation(self, context):
+    @classmethod
+    def _build_explanation(cls, context):
         explanation = ca.Section()
         explanation.add_element(ca.Paragraph([f"Answer: {context['value']}"]))
         return explanation
 ```
 
 Notes:
-- Always use `context["rng"]` for deterministic randomness.
+- Always use `context.rng` (or `context["rng"]`) for deterministic randomness.
 - Avoid `refresh()`; it is no longer part of the API.
 
 ## Built-in Question Types

{quizgenerator-0.8.0 → quizgenerator-0.9.0}/QuizGenerator/contentast.py

@@ -668,7 +668,7 @@ class Section(Container):
   - Organizing complex question content
 
   Example:
-      def _build_body(self, context):
+      def _build_body(cls, context):
           body = Section()
           answers = []
           body.add_element(Paragraph(["Calculate the determinant:"]))
@@ -2263,6 +2263,10 @@ class Answer(Leaf):
     unit_part = f" {self.unit}" if self.unit else ""
 
     return f"{label_part} {blank}{unit_part}".strip()
+
+  @classmethod
+  def get_entry_warning(cls) -> List[str] | None:
+    return None
   
   # Factory methods for common answer types
   @classmethod
@@ -2330,17 +2334,19 @@ class Answer(Leaf):
       0.123444... → ["0.1234"]
     """
     rounding_digits = Answer.DEFAULT_ROUNDING_DIGITS
-    decimal.getcontext().prec = max(34, rounding_digits + 10)
-
     outs = set()
 
     # Round to our standard precision first
+    decimal.getcontext().prec = max(34, rounding_digits + 10)
     q = decimal.Decimal(1).scaleb(-rounding_digits)
-    rounded_decimal = decimal.Decimal(str(value)).quantize(q, rounding=decimal.ROUND_HALF_UP)
-
-    # Normalize negative zero to positive zero
-    if rounded_decimal == 0:
-      rounded_decimal = abs(rounded_decimal)
+    if isinstance(value, str) and '/' in value:
+      f = Answer._to_fraction(value)
+      decimal_value = decimal.Decimal(f.numerator) / decimal.Decimal(f.denominator)
+    elif isinstance(value, fractions.Fraction):
+      decimal_value = decimal.Decimal(value.numerator) / decimal.Decimal(value.denominator)
+    else:
+      decimal_value = decimal.Decimal(str(value))
+    rounded_decimal = decimal_value.quantize(q, rounding=decimal.ROUND_HALF_UP)
 
     # Fixed decimal form (e.g., "1.2500")
     fixed_str = format(rounded_decimal, 'f')
@@ -2431,6 +2437,15 @@ class AnswerTypes:
 
   # Concrete type answers
   class Float(Answer):
+    @classmethod
+    def get_entry_warning(cls) -> List[str] | None:
+      digits = Answer.DEFAULT_ROUNDING_DIGITS
+      return [
+        f"Round floats to {digits} decimal places (fewer if exact, e.g., `1.25`). "
+        "No mixed numbers (e.g. use `5/4`, not `1 1/4`). "
+        "Integers as integers (e.g., `2`, not `2/1`)."
+      ]
+
     def get_for_canvas(self, single_answer=False) -> List[dict]:
       if single_answer:
         canvas_answers = [
@@ -2460,8 +2475,8 @@ class AnswerTypes:
       return canvas_answers
 
     def get_display_string(self) -> str:
-      rounded = round(self.value, Answer.DEFAULT_ROUNDING_DIGITS)
-      return f"{self.fix_negative_zero(rounded)}"
+      answer_strings = Answer.accepted_strings(self.value)
+      return answer_strings[0] if len(answer_strings) > 0 else f"{self.value}"
 
   class Int(Answer):
 
@@ -2486,6 +2501,10 @@ class AnswerTypes:
     pass
 
   class List(Answer):
+    @classmethod
+    def get_entry_warning(cls) -> List[str] | None:
+      return ["Enter lists as comma-separated values with a space after the comma (e.g., `1, 2, 3`)."]
+
     def __init__(self, order_matters=True, *args, **kwargs):
       super().__init__(*args, **kwargs)
       self.order_matters = order_matters
@@ -2523,6 +2542,13 @@ class AnswerTypes:
     """
     These are self-contained vectors that will go in a single answer block
     """
+
+    @classmethod
+    def get_entry_warning(cls) -> List[str] | None:
+      return [
+        "Enter vectors as comma-separated values with a space after the comma, "
+        "with optional parentheses (e.g., `1, 2` or `(1, 2)`)."
+      ]
   
   # Canvas export methods (from misc.Answer)
     def get_for_canvas(self, single_answer=False) -> List[dict]:
@@ -2565,6 +2591,13 @@ class AnswerTypes:
     """
     Matrix answers generate multiple blank_ids (e.g., M_0_0, M_0_1, M_1_0, M_1_1).
     """
+
+    @classmethod
+    def get_entry_warning(cls) -> List[str] | None:
+      return [
+        "For result matrices, enter `-` in any cell that does not exist.",
+        *AnswerTypes.Float.get_entry_warning()
+      ]
   
     def __init__(self, value, *args, **kwargs):
       super().__init__(value=value, *args, **kwargs)

{quizgenerator-0.8.0 → quizgenerator-0.9.0}/QuizGenerator/generate.py

@@ -153,7 +153,7 @@ def test_all_questions(
         )
 
         # Generate the question (this calls refresh and builds the AST)
-        instance = question.instantiate(rng_seed=seed)
+        instance = question.instantiate(rng_seed=seed, max_backoff_attempts=200)
         question_ast = question._build_question_ast(instance)
 
         # Try rendering to both formats to catch format-specific issues

{quizgenerator-0.8.0 → quizgenerator-0.9.0}/QuizGenerator/mixins.py

@@ -419,8 +419,10 @@ class MathOperationQuestion(MultiPartQuestionMixin, abc.ABC):
       subparts.append((operand_a_latex, self.get_operator(), operand_b_latex))
     return subparts
   
-  def _build_body(self, context):
+  @classmethod
+  def _build_body(cls, context):
     """Build question body and collect answers."""
+    self = context
     body = ca.Section()
     answers = []
 
@@ -453,8 +455,10 @@ class MathOperationQuestion(MultiPartQuestionMixin, abc.ABC):
     # Default implementation - subclasses should override for specific answer formats
     return []
 
-  def _build_explanation(self, context):
+  @classmethod
+  def _build_explanation(cls, context):
     """Default explanation structure. Subclasses should override for specific explanations."""
+    self = context
     explanation = ca.Section()
 
     explanation.add_element(ca.Paragraph([self.get_explanation_intro()]))

{quizgenerator-0.8.0 → quizgenerator-0.9.0}/QuizGenerator/premade_questions/basic.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 from typing import Tuple, List
+from types import SimpleNamespace
 import random
 
 import logging
@@ -17,19 +18,23 @@ log = logging.getLogger(__name__)
 class FromText(Question):
   
   def __init__(self, *args, text, **kwargs):
+    kwargs["text"] = text
     super().__init__(*args, **kwargs)
     self.text = text
     self.possible_variations = 1
   
-  def _build_context(self, *, rng_seed=None, **kwargs):
+  @classmethod
+  def _build_context(cls, *, rng_seed=None, **kwargs):
     context = super()._build_context(rng_seed=rng_seed, **kwargs)
-    context["text"] = self.text
+    context["text"] = kwargs.get("text", "")
     return context
   
-  def _build_body(self, context) -> Tuple[ca.Element, List[ca.Answer]]:
+  @classmethod
+  def _build_body(cls, context) -> Tuple[ca.Element, List[ca.Answer]]:
     return ca.Section([ca.Text(context["text"])]), []
 
-  def _build_explanation(self, context) -> Tuple[ca.Element, List[ca.Answer]]:
+  @classmethod
+  def _build_explanation(cls, context) -> Tuple[ca.Element, List[ca.Answer]]:
     return ca.Section(), []
 
 
@@ -43,6 +48,7 @@ class FromGenerator(FromText, TableQuestionMixin):
     if generator is None:
       generator = text
     
+    kwargs["generator"] = generator
     super().__init__(*args, text="", **kwargs)
     self.possible_variations = kwargs.get("possible_variations", float('inf'))
     
@@ -72,15 +78,51 @@ class FromGenerator(FromText, TableQuestionMixin):
     # Attach the function dynamically
     attach_function_to_object(self, generator, "generator")
 
-  def _build_context(self, *, rng_seed=None, **kwargs):
+  @staticmethod
+  def _compile_generator(function_code, function_name="generator"):
+    # Provide a deterministic RNG handle for generator snippets.
+    function_code = "rng = self.rng\n" + function_code
+
+    local_namespace = {
+      'ca': ca,
+      'Section': ca.Section,
+      'Text': ca.Text,
+      'Table': ca.Table,
+      'Paragraph': ca.Paragraph
+    }
+
+    exec_globals = {**globals(), **local_namespace}
+    exec(
+      f"def {function_name}(self):\n" + "\n".join(f"    {line}" for line in function_code.splitlines()),
+      exec_globals,
+      local_namespace
+    )
+    return local_namespace[function_name]
+
+  @classmethod
+  def _build_context(cls, *, rng_seed=None, **kwargs):
     context = super()._build_context(rng_seed=rng_seed, **kwargs)
+    for key, value in kwargs.items():
+      if key not in context:
+        context[key] = value
     # Preserve prior behavior for generators that use the global random module.
     random.seed(rng_seed)
+    generator_text = kwargs.get("generator")
+    if generator_text is not None:
+      context["generator_fn"] = cls._compile_generator(generator_text)
+      context["generator_scope"] = SimpleNamespace(
+        rng=context.rng,
+        **context.data
+      )
     return context
 
-  def _build_body(self, context) -> Tuple[ca.Element, List[ca.Answer]]:
+  @classmethod
+  def _build_body(cls, context) -> Tuple[ca.Element, List[ca.Answer]]:
     try:
-      generated_content = self.generator()
+      generator_fn = context.get("generator_fn")
+      if generator_fn is None:
+        raise TypeError("No generator provided for FromGenerator.")
+      generated_content = generator_fn(context.get("generator_scope"))
       if isinstance(generated_content, ca.Section):
         body = generated_content
       elif isinstance(generated_content, str):

{quizgenerator-0.8.0 → quizgenerator-0.9.0}/QuizGenerator/premade_questions/cst334/process.py

@@ -433,13 +433,7 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
       f"Break any ties using the job number."
     )
 
-    instructions = ca.OnlyHtml([ca.Paragraph([
-      f"Please format answer as fractions, mixed numbers, or numbers rounded to a maximum of {ca.Answer.DEFAULT_ROUNDING_DIGITS} digits after the decimal. "
-      "Examples of appropriately formatted answers would be `0`, `3/2`, `1 1/3`, `1.6667`, and `1.25`. "
-      "Note that answers that can be rounded to whole numbers should be, rather than being left in fractional form."
-    ])])
-
-    body = cls.create_fill_in_table_body(intro_text, instructions, scheduling_table)
+    body = cls.create_fill_in_table_body(intro_text, None, scheduling_table)
     body.add_element(average_block)
     return body