QuizGenerator 0.8.1__py3-none-any.whl → 0.10.0__py3-none-any.whl

QuizGenerator/README.md

@@ -0,0 +1,5 @@
+
+
+## Installation
+
+Note, you will need to install `pandoc` prior to running since it is used to convert to HTML (for canvas) and Latex (for PDF)`

QuizGenerator/canvas/canvas_interface.py

@@ -37,8 +37,12 @@ NUM_WORKERS = 4
 
 
 class CanvasInterface:
-  def __init__(self, *, prod=False):
-    dotenv.load_dotenv(os.path.join(os.path.expanduser("~"), ".env"))
+  def __init__(self, *, prod=False, env_path: str | None = None):
+    default_env = os.path.join(os.path.expanduser("~"), ".env")
+    if env_path and os.path.exists(env_path):
+      dotenv.load_dotenv(env_path)
+    elif os.path.exists(default_env):
+      dotenv.load_dotenv(default_env)
 
     self.prod = prod
     if self.prod:

QuizGenerator/contentast.py

@@ -23,6 +23,21 @@ import numpy as np
 
 log = logging.getLogger(__name__)
 
+_PANDOC_OK = None
+
+
+def _ensure_pandoc() -> bool:
+  global _PANDOC_OK
+  if _PANDOC_OK is not None:
+    return _PANDOC_OK
+  try:
+    pypandoc.get_pandoc_version()
+    _PANDOC_OK = True
+  except Exception as exc:
+    _PANDOC_OK = False
+    log.warning(f"Pandoc not found or unusable: {exc}")
+  return _PANDOC_OK
+
 
 """
 Content Abstract Syntax Tree - The core content system for quiz generation.
@@ -221,6 +236,9 @@ class Leaf(Element):
           return html_output.strip()
         
         case _:
+          if not _ensure_pandoc():
+            log.warning(f"Pandoc unavailable; returning raw markdown for {output_format} output.")
+            return str_to_convert
           output = pypandoc.convert_text(
             str_to_convert,
             output_format,
@@ -549,16 +567,18 @@ class Question(Container):
           
           # Build extra_data dict with regeneration metadata if available
           extra_data = {}
-          if hasattr(self, 'question_class_name') and hasattr(self, 'generation_seed') and hasattr(
-              self, 'question_version'
-          ):
-            if self.question_class_name and self.generation_seed is not None and self.question_version:
+          if hasattr(self, 'question_class_name') and hasattr(self, 'generation_seed'):
+            if self.question_class_name and self.generation_seed is not None:
               extra_data['question_type'] = self.question_class_name
               extra_data['seed'] = self.generation_seed
-              extra_data['version'] = self.question_version
+              if hasattr(self, 'question_version') and self.question_version:
+                extra_data['version'] = self.question_version
               # Include question-specific configuration parameters if available
               if hasattr(self, 'config_params') and self.config_params:
                 extra_data['config'] = self.config_params
+              # Include context-derived extras if available
+              if hasattr(self, 'qr_context_extras') and self.qr_context_extras:
+                extra_data['context'] = self.qr_context_extras
           
           qr_path = QuestionQRCode.generate_qr_pdf(
             self.question_number,
@@ -615,16 +635,18 @@ class Question(Container):
         
         # Build extra_data dict with regeneration metadata if available
         extra_data = {}
-        if hasattr(self, 'question_class_name') and hasattr(self, 'generation_seed') and hasattr(
-            self, 'question_version'
-        ):
-          if self.question_class_name and self.generation_seed is not None and self.question_version:
+        if hasattr(self, 'question_class_name') and hasattr(self, 'generation_seed'):
+          if self.question_class_name and self.generation_seed is not None:
             extra_data['question_type'] = self.question_class_name
             extra_data['seed'] = self.generation_seed
-            extra_data['version'] = self.question_version
+            if hasattr(self, 'question_version') and self.question_version:
+              extra_data['version'] = self.question_version
             # Include question-specific configuration parameters if available
             if hasattr(self, 'config_params') and self.config_params:
               extra_data['config'] = self.config_params
+            # Include context-derived extras if available
+            if hasattr(self, 'qr_context_extras') and self.qr_context_extras:
+              extra_data['context'] = self.qr_context_extras
         
         # Generate QR code PNG
         qr_path = QuestionQRCode.generate_qr_pdf(
@@ -668,7 +690,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:"]))

QuizGenerator/generate.py

@@ -32,7 +32,18 @@ def parse_args():
   
   parser.add_argument("--debug", action="store_true", help="Set logging level to debug")
 
-  parser.add_argument("--quiz_yaml", default=os.path.join(os.path.dirname(os.path.abspath(__file__)), "example_files/exam_generation.yaml"))
+  parser.add_argument(
+    "--yaml",
+    dest="quiz_yaml",
+    default=None,
+    help="Path to quiz YAML configuration"
+  )
+  parser.add_argument(
+    "--quiz_yaml",
+    dest="quiz_yaml",
+    default=None,
+    help=argparse.SUPPRESS  # Backwards-compatible alias for --yaml
+  )
   parser.add_argument("--seed", type=int, default=None,
                      help="Random seed for quiz generation (default: None for random)")
 
@@ -45,7 +56,10 @@ def parse_args():
   
   # PDF Flags
   parser.add_argument("--num_pdfs", default=0, type=int, help="How many PDF quizzes to create")
-  parser.add_argument("--latex", action="store_false", dest="typst", help="Use Typst instead of LaTeX for PDF generation")
+  parser.add_argument("--latex", action="store_false", dest="typst", help="Use LaTeX instead of Typst for PDF generation")
+  parser.set_defaults(typst=True)
+  parser.add_argument("--typst_measurement", action="store_true",
+                     help="Use Typst measurement for layout optimization (experimental)")
 
   # Testing flags
   parser.add_argument("--test_all", type=int, default=0, metavar="N",
@@ -54,6 +68,8 @@ def parse_args():
                      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")
+  parser.add_argument("--skip_missing_extras", action="store_true",
+                     help="With --test_all, skip questions that fail due to missing optional dependencies")
 
   subparsers = parser.add_subparsers(dest='command')
   test_parser = subparsers.add_parser("TEST")
@@ -65,6 +81,10 @@ def parse_args():
     log.error("Must provide course_id when pushing to canvas")
     exit(8)
 
+  if args.test_all <= 0 and not args.quiz_yaml:
+    log.error("Must provide --yaml unless using --test_all")
+    exit(8)
+
   return args
 
 
@@ -82,7 +102,8 @@ def test_all_questions(
     use_typst: bool = True,
     canvas_course=None,
     strict: bool = False,
-    question_filter: list = None
+    question_filter: list = None,
+    skip_missing_extras: bool = False
 ):
   """
   Test all registered questions by generating N variations of each.
@@ -129,6 +150,7 @@ def test_all_questions(
   print("=" * 70)
 
   failed_questions = []
+  skipped_questions = []
   successful_questions = []
   # Collect question instances for PDF/Canvas generation
   test_question_instances = []
@@ -153,7 +175,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
@@ -174,6 +196,14 @@ def test_all_questions(
         # If we got here, the question works - save the instance
         test_question_instances.append(question)
 
+      except ImportError as e:
+        if skip_missing_extras:
+          skipped_questions.append(question_name)
+          log.warning(f"Skipping {question_name} due to missing optional dependency: {e}")
+          question_failures = []
+          break
+        tb = traceback.format_exc()
+        question_failures.append(f"  Variation {variation+1}: Generation failed - {e}\n{tb}")
       except Exception as e:
         tb = traceback.format_exc()
         question_failures.append(f"  Variation {variation+1}: Generation failed - {e}\n{tb}")
@@ -183,6 +213,8 @@ def test_all_questions(
       for failure in question_failures:
         print(failure)
       failed_questions.append((question_name, question_failures))
+    elif question_name in skipped_questions:
+      print("  SKIPPED (missing optional dependency)")
     else:
       print(f"  OK ({num_variations}/{num_variations} variations)")
       successful_questions.append(question_name)
@@ -194,11 +226,17 @@ def test_all_questions(
   print(f"Total question types: {total_questions}")
   print(f"Successful: {len(successful_questions)}")
   print(f"Failed: {len(failed_questions)}")
+  if skipped_questions:
+    print(f"Skipped (missing extras): {len(set(skipped_questions))}")
 
   if failed_questions:
     print("\nFailed questions:")
     for name, failures in failed_questions:
       print(f"  - {name}: {len(failures)} failures")
+  if skipped_questions:
+    print("\nSkipped questions (missing extras):")
+    for name in sorted(set(skipped_questions)):
+      print(f"  - {name}")
 
   print("=" * 70)
 
@@ -367,14 +405,15 @@ def generate_quiz(
     delete_assignment_group=False,
     use_typst=False,
     use_typst_measurement=False,
-    base_seed=None
+    base_seed=None,
+    env_path=None
 ):
 
   quizzes = Quiz.from_yaml(path_to_quiz_yaml)
 
   # Handle Canvas uploads with shared assignment group
   if num_canvas > 0:
-    canvas_interface = CanvasInterface(prod=use_prod)
+    canvas_interface = CanvasInterface(prod=use_prod, env_path=env_path)
     canvas_course = canvas_interface.get_course(course_id=course_id)
 
     # Create assignment group once, with delete flag if specified
@@ -448,7 +487,7 @@ def main():
     # Set up Canvas course if course_id provided
     canvas_course = None
     if args.course_id:
-      canvas_interface = CanvasInterface(prod=args.prod)
+      canvas_interface = CanvasInterface(prod=args.prod, env_path=args.env)
       canvas_course = canvas_interface.get_course(course_id=args.course_id)
 
     success = test_all_questions(
@@ -457,7 +496,8 @@ def main():
       use_typst=getattr(args, 'typst', True),
       canvas_course=canvas_course,
       strict=args.strict,
-      question_filter=args.test_questions
+      question_filter=args.test_questions,
+      skip_missing_extras=args.skip_missing_extras
     )
     exit(0 if success else 1)
 
@@ -471,9 +511,10 @@ def main():
     use_prod=args.prod,
     course_id=args.course_id,
     delete_assignment_group=getattr(args, 'delete_assignment_group', False),
-    use_typst=getattr(args, 'typst', False),
+    use_typst=getattr(args, 'typst', True),
     use_typst_measurement=getattr(args, 'typst_measurement', False),
-    base_seed=getattr(args, 'seed', None)
+    base_seed=getattr(args, 'seed', None),
+    env_path=args.env
   )
 
 

QuizGenerator/logging.yaml

@@ -0,0 +1,55 @@
+version: 1
+disable_existing_loggers: false
+
+formatters:
+  standard:
+    format: '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    datefmt: '%Y-%m-%d %H:%M:%S'
+  
+  detailed:
+    format: '%(asctime)s - %(name)s - %(levelname)s - %(module)s - %(funcName)s:%(lineno)d - %(message)s'
+    datefmt: '%Y-%m-%d %H:%M:%S'
+
+  simple:
+    format: '%(levelname)s - %(message)s'
+
+handlers:
+  console:
+    class: logging.StreamHandler
+    level: INFO
+    formatter: standard
+    stream: ext://sys.stdout
+
+  file:
+    class: logging.FileHandler
+    level: INFO
+    formatter: detailed
+    filename: ${LOG_FILE:-teachingtools.log}
+    mode: a
+
+  error_file:
+    class: logging.FileHandler
+    level: ERROR
+    formatter: detailed
+    filename: ${ERROR_LOG_FILE:-teachingtools_errors.log}
+    mode: a
+
+loggers:
+  QuizGenerator:
+    level: INFO
+    handlers: [console, file]
+    propagate: false
+    
+  lms_interface:
+    level: INFO
+    handlers: [console, file]
+    propagate: false
+
+  canvasapi:
+    level: WARNING
+    handlers: [console]
+    propagate: false
+
+root:
+  level: INFO
+  handlers: [console, file, error_file]

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/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):