QuizGenerator 0.6.1__tar.gz → 0.6.3__tar.gz

{quizgenerator-0.6.1 → quizgenerator-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuizGenerator
-Version: 0.6.1
+Version: 0.6.3
 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

{quizgenerator-0.6.1 → quizgenerator-0.6.3}/QuizGenerator/canvas/canvas_interface.py

@@ -154,7 +154,8 @@ class CanvasCourse(LMSWrapper):
         # Get the question in a format that is ready for canvas (e.g. json)
         # Use large gaps between base seeds to avoid overlap with backoff attempts
         # Each variation gets seeds: base_seed, base_seed+1, base_seed+2, ... for backoffs
-        base_seed = attempt_number * 1000
+        # Include question_i in the seed so different questions get different seed spaces
+        base_seed = (question_i * 100_000) + (attempt_number * 1000)
         question_for_canvas = question.get__canvas(self.course, canvas_quiz, rng_seed=base_seed)
 
         question_fingerprint = question_for_canvas["question_text"]

{quizgenerator-0.6.1 → quizgenerator-0.6.3}/QuizGenerator/contentast.py

@@ -2315,61 +2315,53 @@ class ContentAST:
       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)
+    def accepted_strings(value, max_denominator=720):
+      """
+      Return a sorted list of acceptable answer strings for Canvas.
+
+      Generates:
+      - Integer form (if value is a whole number)
+      - Fixed decimal with DEFAULT_ROUNDING_DIGITS (e.g., "1.0000")
+      - Trimmed decimal without trailing zeros (e.g., "1.25")
+      - Simple fraction if exactly representable (e.g., "5/4")
+
+      Examples:
+        1 → ["1", "1.0000"]
+        1.25 → ["1.25", "1.2500", "5/4"]
+        0.123444... → ["0.1234"]
+      """
+      rounding_digits = ContentAST.Answer.DEFAULT_ROUNDING_DIGITS
+      decimal.getcontext().prec = max(34, rounding_digits + 10)
+
       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'))
-
-      # 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:
-            return sorted(outs, key=lambda s: (len(s), s))
-
-      # 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)
+      # Round to our standard precision first
+      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)
+
+      # Fixed decimal form (e.g., "1.2500")
+      fixed_str = format(rounded_decimal, 'f')
+      outs.add(fixed_str)
+
+      # Trimmed decimal form (e.g., "1.25")
+      trimmed_str = fixed_str.rstrip('0').rstrip('.')
+      if trimmed_str.startswith('.'):
+        trimmed_str = '0' + trimmed_str
+      outs.add(trimmed_str)
+
+      # Integer form (if it's a whole number after rounding)
+      if rounded_decimal == rounded_decimal.to_integral_value():
+        outs.add(str(int(rounded_decimal)))
+
+      # Fraction form (only if exactly representable with reasonable denominator)
+      f = ContentAST.Answer._to_fraction(rounded_decimal)
+      fr = f.limit_denominator(max_denominator)
+      if fr == f and fr.denominator > 1:
+        outs.add(f"{fr.numerator}/{fr.denominator}")
 
       return sorted(outs, key=lambda s: (len(s), s))
     
@@ -2378,6 +2370,10 @@ class ContentAST:
       """Fix -0.0 display issue."""
       return 0.0 if x == 0 else x
 
+    @staticmethod
+    def get_spacing_variations_of_list(l, remove_space=False):
+      return [', '.join(l)] + ([', '.join(l)] if remove_space else [])
+    
 
 class AnswerTypes:
   # Multibase answers that can accept either hex, binary or decimal
@@ -2451,12 +2447,7 @@ class AnswerTypes:
         # 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
+          max_denominator=60
         )
         
         canvas_answers = [
@@ -2505,37 +2496,23 @@ class AnswerTypes:
         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_text": spacing_variation,
             "answer_weight": 100 if self.correct else 0,
           }
+          for spacing_variation in self.get_spacing_variations_of_list(map(str, self.value))
         ]
       else:
         canvas_answers = []
-        
-        # With spaces
-        canvas_answers.extend([
+        canvas_answers = [
           {
             "blank_id": self.key,
-            "answer_text": ', '.join(map(str, possible_state)),
+            "answer_text": spacing_variation,
             "answer_weight": 100 if self.correct else 0,
           }
           for possible_state in itertools.permutations(self.value)
-        ])
+          for spacing_variation in self.get_spacing_variations_of_list(possible_state)
+        ]
         
-        # 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:
@@ -2558,41 +2535,19 @@ class AnswerTypes:
       
       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))}]",
-          }
-        ])
+        for spacing_variation in self.get_spacing_variations_of_list(list(combination)):
+          canvas_answers.extend([
+            {
+              "blank_id": self.key,
+              "answer_weight": 100 if self.correct else 0,
+              "answer_text": f"{spacing_variation}",
+            }, # without parenthesis
+            {
+              "blank_id": self.key,
+              "answer_weight": 100 if self.correct else 0,
+              "answer_text": f"({spacing_variation})",
+            } # with parenthesis
+          ])
       return canvas_answers
       
     def get_display_string(self) -> str:

{quizgenerator-0.6.1 → quizgenerator-0.6.3}/QuizGenerator/generate.py

@@ -50,6 +50,8 @@ def parse_args():
   # Testing flags
   parser.add_argument("--test_all", type=int, default=0, metavar="N",
                      help="Generate N variations of ALL registered questions to test they work correctly")
+  parser.add_argument("--test_questions", nargs='+', metavar="NAME",
+                     help="Only test specific question types by name (use with --test_all)")
   parser.add_argument("--strict", action="store_true",
                      help="With --test_all, skip PDF/Canvas generation if any questions fail")
 
@@ -79,7 +81,8 @@ def test_all_questions(
     generate_pdf: bool = False,
     use_typst: bool = True,
     canvas_course=None,
-    strict: bool = False
+    strict: bool = False,
+    question_filter: list = None
 ):
   """
   Test all registered questions by generating N variations of each.
@@ -93,11 +96,26 @@ def test_all_questions(
     use_typst: If True, use Typst for PDF generation; otherwise use LaTeX
     canvas_course: If provided, push a test quiz to this Canvas course
     strict: If True, skip PDF/Canvas generation if any questions fail
+    question_filter: If provided, only test questions whose names contain one of these strings (case-insensitive)
   """
   # Ensure all premade questions are loaded
   QuestionRegistry.load_premade_questions()
 
   registered_questions = QuestionRegistry._registry
+
+  # Filter questions if a filter list is provided
+  if question_filter:
+    filter_lower = [f.lower() for f in question_filter]
+    registered_questions = {
+      name: cls for name, cls in registered_questions.items()
+      if any(f in name.lower() for f in filter_lower)
+    }
+    if not registered_questions:
+      print(f"No questions matched filter: {question_filter}")
+      print(f"Available questions: {sorted(QuestionRegistry._registry.keys())}")
+      return False
+    print(f"Filtered to {len(registered_questions)} questions matching: {question_filter}")
+
   total_questions = len(registered_questions)
 
   # Test defaults for questions that require external input
@@ -437,7 +455,8 @@ def main():
       generate_pdf=True,
       use_typst=getattr(args, 'typst', True),
       canvas_course=canvas_course,
-      strict=args.strict
+      strict=args.strict,
+      question_filter=args.test_questions
     )
     exit(0 if success else 1)
 

{quizgenerator-0.6.1 → quizgenerator-0.6.3}/QuizGenerator/premade_questions/cst334/process.py

@@ -324,7 +324,7 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
           jobs_to_run=jobs,
           selector=(lambda j, curr_time: (j.last_run, j.job_id)),
           preemptable=True,
-          time_quantum=1e-04
+          time_quantum=1e-05
         )
       case _:
         self.run_simulation(

{quizgenerator-0.6.1 → quizgenerator-0.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "QuizGenerator"
-version = "0.6.1"
+version = "0.6.3"
 description = "Generate randomized quiz questions for Canvas LMS and PDF exams"
 readme = "README.md"
 license = {text = "GPL-3.0-or-later"}

{quizgenerator-0.6.1 → quizgenerator-0.6.3}/pyproject_prev.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "QuizGenerator"
-version = "0.6.0"
+version = "0.6.2"
 description = "Generate randomized quiz questions for Canvas LMS and PDF exams"
 readme = "README.md"
 license = {text = "GPL-3.0-or-later"}

{quizgenerator-0.6.1 → quizgenerator-0.6.3}/uv.lock

@@ -1214,7 +1214,7 @@ wheels = [
 
 [[package]]
 name = "quizgenerator"
-version = "0.6.1"
+version = "0.6.3"
 source = { editable = "." }
 dependencies = [
     { name = "canvasapi" },