QuizGenerator 0.9.0__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(

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 = []
@@ -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/premade_questions/cst463/gradient_descent/loss_calculations.py

@@ -198,7 +198,8 @@ class LossQuestion_Linear(LossQuestion):
   @classmethod
   def _generate_data(cls, context):
     """Generate regression data with continuous target values."""
-    context.data = []
+    context.data = {}
+    context["data"] = []
 
     for _ in range(context.num_samples):
       sample = {}
@@ -227,7 +228,7 @@ class LossQuestion_Linear(LossQuestion):
           for _ in range(context.num_output_vars)
         ]
 
-      context.data.append(sample)
+      context["data"].append(sample)
 
   @classmethod
   def _calculate_losses(cls, context):
@@ -235,7 +236,7 @@ class LossQuestion_Linear(LossQuestion):
     context.individual_losses = []
     total_loss = 0.0
 
-    for sample in context.data:
+    for sample in context["data"]:
       if context.num_output_vars == 1:
         # Single output MSE: (y - p)^2
         loss = (sample['true_values'] - sample['predictions']) ** 2
@@ -282,7 +283,7 @@ class LossQuestion_Linear(LossQuestion):
       headers.append("loss")
 
     rows = []
-    for i, sample in enumerate(context.data):
+    for i, sample in enumerate(context["data"]):
       row = {}
 
       # Input features as vector
@@ -315,7 +316,7 @@ class LossQuestion_Linear(LossQuestion):
     """Show step-by-step MSE calculations."""
     steps = ca.Section()
 
-    for i, sample in enumerate(context.data):
+    for i, sample in enumerate(context["data"]):
       steps.add_element(ca.Paragraph([f"Sample {i+1}:"]))
 
       if context.num_output_vars == 1:
@@ -364,7 +365,7 @@ class LossQuestion_Linear(LossQuestion):
       headers.append("loss")
 
     rows = []
-    for i, sample in enumerate(context.data):
+    for i, sample in enumerate(context["data"]):
       row = []
 
       # Input features
@@ -416,7 +417,8 @@ class LossQuestion_Logistic(LossQuestion):
   @classmethod
   def _generate_data(cls, context):
     """Generate binary classification data."""
-    context.data = []
+    context.data = {}
+    context["data"] = []
 
     for _ in range(context.num_samples):
       sample = {}
@@ -433,7 +435,7 @@ class LossQuestion_Logistic(LossQuestion):
       # Generate predicted probabilities (between 0 and 1, rounded to 3 decimal places)
       sample['predictions'] = round(context.rng.uniform(0.1, 0.9), 3)  # Avoid extreme values
 
-      context.data.append(sample)
+      context["data"].append(sample)
 
   @classmethod
   def _calculate_losses(cls, context):
@@ -441,7 +443,7 @@ class LossQuestion_Logistic(LossQuestion):
     context.individual_losses = []
     total_loss = 0.0
 
-    for sample in context.data:
+    for sample in context["data"]:
       y = sample['true_values']
       p = sample['predictions']
 
@@ -475,7 +477,7 @@ class LossQuestion_Logistic(LossQuestion):
     headers = ["x", "y", "p", "loss"]
 
     rows = []
-    for i, sample in enumerate(context.data):
+    for i, sample in enumerate(context["data"]):
       row = {}
 
       # Input features as vector
@@ -500,7 +502,7 @@ class LossQuestion_Logistic(LossQuestion):
     """Show step-by-step log-loss calculations."""
     steps = ca.Section()
 
-    for i, sample in enumerate(context.data):
+    for i, sample in enumerate(context["data"]):
       y = sample['true_values']
       p = sample['predictions']
       loss = context.individual_losses[i]
@@ -522,7 +524,7 @@ class LossQuestion_Logistic(LossQuestion):
     headers = ["x_0", "x_1", "y", "p", "loss"]
 
     rows = []
-    for i, sample in enumerate(context.data):
+    for i, sample in enumerate(context["data"]):
       row = []
 
       # Input features
@@ -585,7 +587,8 @@ class LossQuestion_MulticlassLogistic(LossQuestion):
   @classmethod
   def _generate_data(cls, context):
     """Generate multi-class classification data."""
-    context.data = []
+    context.data = {}
+    context["data"] = []
 
     for _ in range(context.num_samples):
       sample = {}
@@ -606,7 +609,7 @@ class LossQuestion_MulticlassLogistic(LossQuestion):
       prob_sum = sum(raw_probs)
       sample['predictions'] = [round(p / prob_sum, 3) for p in raw_probs]
 
-      context.data.append(sample)
+      context["data"].append(sample)
 
   @classmethod
   def _calculate_losses(cls, context):
@@ -614,7 +617,7 @@ class LossQuestion_MulticlassLogistic(LossQuestion):
     context.individual_losses = []
     total_loss = 0.0
 
-    for sample in context.data:
+    for sample in context["data"]:
       y_vec = sample['true_values']
       p_vec = sample['predictions']
 
@@ -645,7 +648,7 @@ class LossQuestion_MulticlassLogistic(LossQuestion):
     headers = ["x", "y", "p", "loss"]
 
     rows = []
-    for i, sample in enumerate(context.data):
+    for i, sample in enumerate(context["data"]):
       row = {}
 
       # Input features as vector
@@ -672,7 +675,7 @@ class LossQuestion_MulticlassLogistic(LossQuestion):
     """Show step-by-step cross-entropy calculations."""
     steps = ca.Section()
 
-    for i, sample in enumerate(context.data):
+    for i, sample in enumerate(context["data"]):
       y_vec = sample['true_values']
       p_vec = sample['predictions']
       loss = context.individual_losses[i]
@@ -710,7 +713,7 @@ class LossQuestion_MulticlassLogistic(LossQuestion):
     headers = ["x_0", "x_1", "y", "p", "loss"]
 
     rows = []
-    for i, sample in enumerate(context.data):
+    for i, sample in enumerate(context["data"]):
       row = []
 
       # Input features

QuizGenerator/premade_questions/cst463/models/attention.py

@@ -1,7 +1,6 @@
 import abc
 import logging
 import math
-import keras
 import numpy as np
 from typing import List, Tuple
 

QuizGenerator/premade_questions/cst463/models/cnns.py

@@ -1,7 +1,6 @@
 import abc
 import logging
 import math
-import keras
 import numpy as np
 from typing import List, Tuple
 

QuizGenerator/premade_questions/cst463/models/rnns.py

@@ -1,7 +1,6 @@
 import abc
 import logging
 import math
-import keras
 import numpy as np
 from typing import List, Tuple
 

QuizGenerator/premade_questions/cst463/models/text.py

@@ -1,7 +1,6 @@
 import abc
 import logging
 import math
-import keras
 import numpy as np
 from typing import List, Tuple
 

QuizGenerator/premade_questions/cst463/models/weight_counting.py

@@ -1,8 +1,16 @@
+from __future__ import annotations
+
 import abc
 import logging
 import math
 import random
-import keras
+try:
+  import keras
+except ImportError as exc:
+  keras = None
+  _KERAS_IMPORT_ERROR = exc
+else:
+  _KERAS_IMPORT_ERROR = None
 import numpy as np
 from typing import List, Tuple
 
@@ -14,6 +22,14 @@ log = logging.getLogger(__name__)
 
 
 class WeightCounting(Question, abc.ABC):
+  @staticmethod
+  def _ensure_keras():
+    if keras is None:
+      raise ImportError(
+        "Keras is required for CST463 model questions. "
+        "Install with: pip install 'QuizGenerator[cst463]'"
+      ) from _KERAS_IMPORT_ERROR
+
   @staticmethod
   @abc.abstractmethod
   def get_model(rng: random.Random) -> keras.Model:
@@ -21,6 +37,7 @@ class WeightCounting(Question, abc.ABC):
   
   @staticmethod
   def model_to_python(model: keras.Model, fields=None, include_input=True):
+    WeightCounting._ensure_keras()
     if fields is None:
       fields = []
     
@@ -177,6 +194,7 @@ class WeightCounting_CNN(WeightCounting):
   
   @staticmethod
   def get_model(rng: random.Random) -> tuple[keras.Model, list[str]]:
+    WeightCounting._ensure_keras()
     input_size = rng.choice(np.arange(28, 32))
     cnn_num_filters = rng.choice(2 ** np.arange(8))
     cnn_kernel_size = rng.choice(1 + np.arange(10))
@@ -211,6 +229,7 @@ class WeightCounting_CNN(WeightCounting):
 class WeightCounting_RNN(WeightCounting):
   @staticmethod
   def get_model(rng: random.Random) -> tuple[keras.Model, list[str]]:
+    WeightCounting._ensure_keras()
     timesteps = int(rng.choice(np.arange(20, 41)))
     feature_size = int(rng.choice(np.arange(8, 65)))
 

QuizGenerator/qrcode_generator.py

@@ -9,17 +9,21 @@ The QR codes include encrypted data that allows regenerating question answers
 without storing separate files, enabling efficient grading of randomized exams.
 """
 
+import base64
+import hashlib
 import json
-import tempfile
 import logging
 import os
-import base64
+import tempfile
+import zlib
+from datetime import datetime
 from io import BytesIO
 from pathlib import Path
 from typing import Optional, Dict, Any
 
 import segno
 from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 
 log = logging.getLogger(__name__)
 
@@ -38,6 +42,22 @@ class QuestionQRCode:
 
     # Error correction level: M = 15% recovery (balanced for compact encoded data)
     ERROR_CORRECTION = 'M'
+    _generated_key: Optional[bytes] = None
+    V2_PREFIX = "v2."
+
+    @classmethod
+    def _persist_generated_key(cls, key: bytes) -> None:
+        try:
+            os.makedirs("out/keys", exist_ok=True)
+            timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+            path = os.path.join("out", "keys", f"quiz_encryption_key-{timestamp}.log")
+            with open(path, "w", encoding="utf-8") as handle:
+                handle.write("QUIZ_ENCRYPTION_KEY=")
+                handle.write(key.decode("ascii"))
+                handle.write("\n")
+            log.warning(f"Wrote generated QUIZ_ENCRYPTION_KEY to {path}")
+        except Exception as exc:
+            log.warning(f"Failed to persist generated QUIZ_ENCRYPTION_KEY: {exc}")
 
     @classmethod
     def get_encryption_key(cls) -> bytes:
@@ -61,67 +81,95 @@ class QuestionQRCode:
                 "QUIZ_ENCRYPTION_KEY not set! Generating temporary key. "
                 "Set this environment variable for production use!"
             )
-            # Generate temporary key for development
-            return Fernet.generate_key()
+            if cls._generated_key is None:
+                cls._generated_key = Fernet.generate_key()
+                os.environ["QUIZ_ENCRYPTION_KEY"] = cls._generated_key.decode("ascii")
+                cls._persist_generated_key(cls._generated_key)
+            return cls._generated_key
 
         # Key should be stored as base64 string in env
         return key_str.encode()
 
     @classmethod
-    def encrypt_question_data(cls, question_type: str, seed: int, version: str,
+    def _derive_aead_key(cls, key: bytes) -> bytes:
+        return hashlib.sha256(key).digest()
+
+    @classmethod
+    def _encrypt_v2(cls, payload: Dict[str, Any], *, key: Optional[bytes] = None) -> str:
+        if key is None:
+            key = cls.get_encryption_key()
+        aead_key = cls._derive_aead_key(key)
+        aesgcm = AESGCM(aead_key)
+        nonce = os.urandom(12)
+        json_bytes = json.dumps(payload, separators=(',', ':'), ensure_ascii=False).encode("utf-8")
+        compressed = zlib.compress(json_bytes)
+        ciphertext = aesgcm.encrypt(nonce, compressed, None)
+        token = base64.urlsafe_b64encode(nonce + ciphertext).decode("ascii")
+        return f"{cls.V2_PREFIX}{token}"
+
+    @classmethod
+    def _decrypt_v2(cls, encrypted_data: str, *, key: Optional[bytes] = None) -> Dict[str, Any]:
+        if not encrypted_data.startswith(cls.V2_PREFIX):
+            raise ValueError("Not a v2 payload")
+        if key is None:
+            key = cls.get_encryption_key()
+        aead_key = cls._derive_aead_key(key)
+        token = encrypted_data[len(cls.V2_PREFIX):]
+        raw = base64.urlsafe_b64decode(token.encode("ascii"))
+        nonce, ciphertext = raw[:12], raw[12:]
+        aesgcm = AESGCM(aead_key)
+        compressed = aesgcm.decrypt(nonce, ciphertext, None)
+        json_bytes = zlib.decompress(compressed)
+        return json.loads(json_bytes.decode("utf-8"))
+
+    @classmethod
+    def encrypt_question_data(cls, question_type: str, seed: int, version: Optional[str] = None,
                               config: Optional[Dict[str, Any]] = None,
+                              context: Optional[Dict[str, Any]] = None,
+                              points_value: Optional[float] = None,
                               key: Optional[bytes] = None) -> str:
         """
-        Encode question regeneration data with optional simple obfuscation.
+        Encode question regeneration data for QR embedding.
 
         Args:
             question_type: Class name of the question (e.g., "VectorDotProduct")
             seed: Random seed used to generate this specific question
-            version: Question class version (e.g., "1.0")
+            version: Optional question version string
             config: Optional dictionary of configuration parameters
+            context: Optional dictionary of context extras
+            points_value: Optional points value (for redundancy)
             key: Encryption key (uses environment key if None)
 
         Returns:
-            str: Base64-encoded (optionally XOR-obfuscated) data
+            str: Base64-encoded encrypted payload with v2 prefix
 
         Example:
             >>> encrypted = QuestionQRCode.encrypt_question_data("VectorDot", 12345, "1.0")
             >>> print(encrypted)
             'VmVjdG9yRG90OjEyMzQ1OjEuMA=='
         """
-        # Create compact data string, including config if provided
+        payload: Dict[str, Any] = {
+            "t": question_type,
+            "s": seed,
+        }
+        if points_value is not None:
+            payload["p"] = points_value
         if config:
-            # Serialize config as JSON and append to data string
-            config_json = json.dumps(config, separators=(',', ':'))
-            data_str = f"{question_type}:{seed}:{version}:{config_json}"
-        else:
-            data_str = f"{question_type}:{seed}:{version}"
-        data_bytes = data_str.encode('utf-8')
-
-        # Simple XOR obfuscation if key is provided (optional, for basic protection)
-        if key is None:
-            key = cls.get_encryption_key()
-
-        if key:
-            # Use first 16 bytes of key for simple XOR obfuscation
-            key_bytes = key[:16] if isinstance(key, bytes) else key.encode()[:16]
-            # XOR each byte with repeating key pattern
-            obfuscated = bytes(b ^ key_bytes[i % len(key_bytes)] for i, b in enumerate(data_bytes))
-        else:
-            obfuscated = data_bytes
-
-        # Base64 encode for compact representation
-        encoded = base64.urlsafe_b64encode(obfuscated).decode('utf-8')
-
-        log.debug(f"Encoded question data: {question_type} seed={seed} version={version} ({len(encoded)} chars)")
-
+            payload["c"] = config
+        if context:
+            payload["x"] = context
+        if version:
+            payload["v"] = version
+
+        encoded = cls._encrypt_v2(payload, key=key)
+        log.debug(f"Encoded question data v2: {question_type} seed={seed} ({len(encoded)} chars)")
         return encoded
 
     @classmethod
     def decrypt_question_data(cls, encrypted_data: str,
                              key: Optional[bytes] = None) -> Dict[str, Any]:
         """
-        Decode question regeneration data from QR code.
+        Decode question regeneration data from QR code (v2 preferred, v1 fallback).
 
         Args:
             encrypted_data: Base64-encoded (optionally XOR-obfuscated) string from QR code
@@ -142,10 +190,24 @@ class QuestionQRCode:
             key = cls.get_encryption_key()
 
         try:
-            # Decode from base64
+            if encrypted_data.startswith(cls.V2_PREFIX):
+                payload = cls._decrypt_v2(encrypted_data, key=key)
+                result = {
+                    "question_type": payload.get("t"),
+                    "seed": int(payload.get("s")),
+                }
+                if "v" in payload:
+                    result["version"] = payload.get("v")
+                if "c" in payload:
+                    result["config"] = payload.get("c")
+                if "x" in payload:
+                    result["context"] = payload.get("x")
+                if "p" in payload:
+                    result["points"] = payload.get("p")
+                return result
+
+            # V1 fallback (XOR obfuscation)
             obfuscated = base64.urlsafe_b64decode(encrypted_data.encode())
-
-            # Reverse XOR obfuscation if key is provided
             if key:
                 key_bytes = key[:16] if isinstance(key, bytes) else key.encode()[:16]
                 data_bytes = bytes(b ^ key_bytes[i % len(key_bytes)] for i, b in enumerate(obfuscated))
@@ -153,29 +215,26 @@ class QuestionQRCode:
                 data_bytes = obfuscated
 
             data_str = data_bytes.decode('utf-8')
-
-            # Parse data string - can be 3 or 4 parts (4th is optional config)
-            parts = data_str.split(':', 3)  # Split into max 4 parts
-            if len(parts) < 3:
-                raise ValueError(f"Invalid encoded data format: expected at least 3 parts, got {len(parts)}")
+            parts = data_str.split(':', 3)
+            if len(parts) < 2:
+                raise ValueError(f"Invalid encoded data format: expected at least 2 parts, got {len(parts)}")
 
             question_type = parts[0]
             seed_str = parts[1]
-            version = parts[2]
+            version = parts[2] if len(parts) >= 3 else None
 
             result = {
                 "question_type": question_type,
                 "seed": int(seed_str),
-                "version": version
             }
+            if version:
+                result["version"] = version
 
-            # Parse config JSON if present
             if len(parts) == 4:
                 try:
                     result["config"] = json.loads(parts[3])
                 except json.JSONDecodeError as e:
                     log.warning(f"Failed to parse config JSON: {e}")
-                    # Continue without config rather than failing
 
             return result
 
@@ -215,24 +274,27 @@ class QuestionQRCode:
         """
         data = {
             "q": question_number,
-            "pts": points_value
+            "p": points_value
         }
 
         # If question regeneration data provided, encrypt it
-        if all(k in extra_data for k in ['question_type', 'seed', 'version']):
-            # Include config in encrypted data if present
+        if all(k in extra_data for k in ['question_type', 'seed']):
             config = extra_data.get('config', {})
+            context = extra_data.get('context', {})
             encrypted = cls.encrypt_question_data(
                 extra_data['question_type'],
                 extra_data['seed'],
-                extra_data['version'],
-                config=config
+                extra_data.get('version'),
+                config=config,
+                context=context,
+                points_value=points_value
             )
             data['s'] = encrypted
 
-            # Remove the unencrypted data
-            extra_data = {k: v for k, v in extra_data.items()
-                         if k not in ['question_type', 'seed', 'version', 'config']}
+            extra_data = {
+                k: v for k, v in extra_data.items()
+                if k not in ['question_type', 'seed', 'version', 'config', 'context']
+            }
 
         # Add any remaining extra metadata
         data.update(extra_data)

QuizGenerator/question.py

@@ -45,6 +45,7 @@ class RegenerationFlags:
     generation_seed: Optional[int]
     question_version: str
     config_params: Dict[str, Any]
+    context_extras: Dict[str, Any] = dataclasses.field(default_factory=dict)
 
 
 @dataclasses.dataclass(frozen=True)
@@ -94,7 +95,9 @@ class QuestionContext:
       return self.rng_seed
     if key == "rng":
       return self.rng
-    return self.data.get(key, default)
+    if hasattr(self.data, "get"):
+      return self.data.get(key, default)
+    return default
 
   def __contains__(self, key: object) -> bool:
     if key in ("rng_seed", "rng"):
@@ -261,7 +264,12 @@ class QuestionRegistry:
       # Load modules from the current directory
       for _, module_name, _ in pkgutil.iter_modules([str(path)]):
         # Import the module
-        module = importlib.import_module(f"{package_prefix}.{module_name}")
+        try:
+          importlib.import_module(f"{package_prefix}.{module_name}")
+        except ImportError as e:
+          log.warning(
+            f"Skipping module '{package_prefix}.{module_name}' due to import error: {e}"
+          )
 
       # Recursively load modules from subdirectories
       for subdir in path.iterdir():
@@ -688,6 +696,20 @@ class Question(abc.ABC):
       if isinstance(ctx, dict) and ctx.get("_config_params"):
         config_params.update(ctx.get("_config_params"))
 
+      context_extras: Dict[str, Any] = {}
+      if isinstance(ctx, QuestionContext):
+        include_list = ctx.get("qr_include_list", None)
+        if isinstance(include_list, (list, tuple)):
+          for key in include_list:
+            if key in ctx:
+              context_extras[key] = ctx[key]
+      elif isinstance(ctx, dict):
+        include_list = ctx.get("qr_include_list", None)
+        if isinstance(include_list, (list, tuple)):
+          for key in include_list:
+            if key in ctx:
+              context_extras[key] = ctx[key]
+
       instance = QuestionInstance(
         body=components.body,
         explanation=components.explanation,
@@ -701,7 +723,8 @@ class Question(abc.ABC):
           question_class_name=self._get_registered_name(),
           generation_seed=actual_seed,
           question_version=self.VERSION,
-          config_params=config_params
+          config_params=config_params,
+          context_extras=context_extras
         )
       )
       return instance
@@ -932,6 +955,7 @@ class Question(abc.ABC):
     question_ast.generation_seed = instance.flags.generation_seed
     question_ast.question_version = instance.flags.question_version
     question_ast.config_params = dict(instance.flags.config_params)
+    question_ast.qr_context_extras = dict(instance.flags.context_extras)
 
     return question_ast
 
@@ -1014,11 +1038,11 @@ class QuestionGroup():
     
   def instantiate(self, *args, **kwargs):
     
-    # todo: Make work with rng_seed (or at least verify)
-    random.seed(kwargs.get("rng_seed", None))
+    # Use a local RNG to avoid global side effects.
+    rng = random.Random(kwargs.get("rng_seed", None))
     
     if not self.pick_once or self._current_question is None:
-      self._current_question = random.choice(self.questions)
+      self._current_question = rng.choice(self.questions)
     
   def __getattr__(self, name):
     if self._current_question is None or name == "generate":

QuizGenerator/regenerate.py

@@ -194,7 +194,9 @@ def regenerate_question_answer(
   }
   """
   question_num = qr_data.get('q')
-  points = qr_data.get('pts')
+  points = qr_data.get('p')
+  if points is None:
+    points = qr_data.get('pts')
   
   if question_num is None or points is None:
     log.error("QR code missing required fields 'q' or 'pts'")
@@ -219,8 +221,9 @@ def regenerate_question_answer(
     
     question_type = regen_data['question_type']
     seed = regen_data['seed']
-    version = regen_data['version']
+    version = regen_data.get('version')
     config = regen_data.get('config', {})
+    context_extras = regen_data.get('context', {})
     
     result['question_type'] = question_type
     result['seed'] = seed
@@ -228,7 +231,10 @@ def regenerate_question_answer(
     if config:
       result['config'] = config
     
-    log.info(f"Question {question_num}: {question_type} (seed={seed}, version={version})")
+    if version:
+      log.info(f"Question {question_num}: {question_type} (seed={seed}, version={version})")
+    else:
+      log.info(f"Question {question_num}: {question_type} (seed={seed})")
     if config:
       log.debug(f"  Config params: {config}")
     
@@ -241,7 +247,7 @@ def regenerate_question_answer(
     )
     
     # Generate question with the specific seed
-    instance = question.instantiate(rng_seed=seed)
+    instance = question.instantiate(rng_seed=seed, **context_extras)
     question_ast = question._build_question_ast(instance)
     
     # Extract answers
@@ -477,14 +483,22 @@ def display_answer_summary(question_data: Dict[str, Any]) -> None:
   if 'question_type' in question_data:
     print(f"Type: {question_data['question_type']}")
     print(f"Seed: {question_data['seed']}")
-    print(f"Version: {question_data['version']}")
+    if question_data.get('version') is not None:
+      print(f"Version: {question_data['version']}")
   
   if 'answer_objects' in question_data:
     print("\nANSWERS:")
-    for key, answer_obj in question_data['answer_objects'].items():
-      print(f"  {key}: {answer_obj.value}")
-      if hasattr(answer_obj, 'tolerance') and answer_obj.tolerance:
-        print(f"    (tolerance: ±{answer_obj.tolerance})")
+    answer_objects = question_data['answer_objects']
+    if isinstance(answer_objects, dict):
+      for key, answer_obj in answer_objects.items():
+        print(f"  {key}: {answer_obj.value}")
+        if hasattr(answer_obj, 'tolerance') and answer_obj.tolerance:
+          print(f"    (tolerance: ±{answer_obj.tolerance})")
+    else:
+      for i, answer_obj in enumerate(answer_objects, start=1):
+        print(f"  {i}: {answer_obj.value}")
+        if hasattr(answer_obj, 'tolerance') and answer_obj.tolerance:
+          print(f"    (tolerance: ±{answer_obj.tolerance})")
   elif 'answers' in question_data:
     print("\nANSWERS (raw Canvas format):")
     print(f"  Type: {question_data['answers']['kind']}")

{quizgenerator-0.9.0.dist-info → quizgenerator-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuizGenerator
-Version: 0.9.0
+Version: 0.10.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
@@ -19,9 +19,7 @@ Classifier: Topic :: Education :: Testing
 Requires-Python: >=3.12
 Requires-Dist: canvasapi==3.2.0
 Requires-Dist: cryptography>=41.0.0
-Requires-Dist: graphviz>=0.21
 Requires-Dist: jinja2==3.1.3
-Requires-Dist: keras>=3.12.0
 Requires-Dist: markdown>=3.9
 Requires-Dist: matplotlib
 Requires-Dist: pylatex>=1.4.2
@@ -32,7 +30,10 @@ Requires-Dist: pyyaml==6.0.1
 Requires-Dist: requests==2.32.2
 Requires-Dist: segno>=1.6.0
 Requires-Dist: sympy>=1.14.0
-Requires-Dist: tensorflow>=2.20.0
+Provides-Extra: cst463
+Requires-Dist: graphviz>=0.21; extra == 'cst463'
+Requires-Dist: keras>=3.12.0; extra == 'cst463'
+Requires-Dist: tensorflow>=2.20.0; extra == 'cst463'
 Provides-Extra: grading
 Requires-Dist: pillow>=10.0.0; extra == 'grading'
 Requires-Dist: pyzbar>=0.1.9; extra == 'grading'
@@ -60,18 +61,24 @@ pip install QuizGenerator
 ### System Requirements
 
 - Python 3.12+
-- LaTeX distribution with `latexmk` (for PDF generation)
-- Optional: [Typst](https://typst.app/) (alternative to LaTeX)
+- [Typst](https://typst.app/) (default PDF renderer)
+- Optional: LaTeX distribution with `latexmk` (if using `--latex`)
+- Recommended: [Pandoc](https://pandoc.org/) (for markdown conversion)
 
 ### Optional Dependencies
 
 ```bash
 # For QR code grading support
 pip install QuizGenerator[grading]
+
+# For CST463 machine learning questions
+pip install QuizGenerator[cst463]
 ```
 
 ## Quick Start
 
+Need a 2‑minute setup? See `documentation/quickstart.md`.
+
 ### 1. Create a quiz configuration (YAML)
 
 ```yaml
@@ -94,7 +101,7 @@ questions:
 ### 2. Generate PDFs
 
 ```bash
-python -m generate_quiz --quiz_yaml my_quiz.yaml --num_pdfs 3
+quizgen --yaml my_quiz.yaml --num_pdfs 3
 ```
 
 PDFs will be created in the `out/` directory.
@@ -106,8 +113,8 @@ PDFs will be created in the `out/` directory.
 # CANVAS_API_URL=https://canvas.instructure.com
 # CANVAS_API_KEY=your_api_key_here
 
-python -m generate_quiz \
-  --quiz_yaml my_quiz.yaml \
+quizgen \
+  --yaml my_quiz.yaml \
   --num_canvas 5 \
   --course_id 12345
 ```
@@ -194,10 +201,9 @@ Notes:
 
 ## Documentation
 
-- [Getting Started Guide](documentation/getting_started.md) (coming soon)
+- [Getting Started Guide](documentation/getting_started.md)
 - [Custom Questions Guide](documentation/custom_questions.md)
-- [YAML Configuration Reference](documentation/yaml_config_guide.md) (coming soon)
-- [PyPI Release Plan](documentation/pypi_release_plan.md)
+- [YAML Configuration Reference](documentation/yaml_config_guide.md)
 
 ## Canvas Setup
 
@@ -216,25 +222,28 @@ CANVAS_API_KEY_prod=your_prod_api_key
 2. Use `--prod` flag for production Canvas instance:
 
 ```bash
-python -m generate_quiz --prod --num_canvas 5 --course_id 12345
+quizgen --prod --num_canvas 5 --course_id 12345
 ```
 
 ## Advanced Features
 
 ### Typst Support
 
-Use Typst instead of LaTeX for faster compilation:
+Typst is the default for faster compilation. Use `--latex` to force LaTeX:
 
 ```bash
-python -m generate_quiz --typst --num_pdfs 3
+quizgen --latex --num_pdfs 3
 ```
 
+Experimental: `--typst_measurement` uses Typst to measure question height for tighter layout.
+It can change pagination and ordering, so use with care on finalized exams.
+
 ### Deterministic Generation
 
 Use seeds for reproducible quizzes:
 
 ```bash
-python -m generate_quiz --seed 42 --num_pdfs 3
+quizgen --seed 42 --num_pdfs 3
 ```
 
 ### QR Code Regeneration
@@ -258,7 +267,7 @@ QuizGenerator/
 │   └── canvas/           # Canvas LMS integration
 ├── example_files/        # Example quiz configurations
 ├── documentation/        # User guides
-└── generate_quiz.py     # CLI entry point
+└── quizgen             # CLI entry point
 ```
 
 ## Contributing

{quizgenerator-0.9.0.dist-info → quizgenerator-0.10.0.dist-info}/RECORD

@@ -1,18 +1,20 @@
+QuizGenerator/README.md,sha256=4n16gKyhIAKRBX4VKlpfcK0pyUYJ6Ht08MUsnwgxrZo,145
 QuizGenerator/__init__.py,sha256=8EV-k90A3PNC8Cm2-ZquwNyVyvnwW1gs6u-nGictyhs,840
 QuizGenerator/__main__.py,sha256=Dd9w4R0Unm3RiXztvR4Y_g9-lkWp6FHg-4VN50JbKxU,151
 QuizGenerator/constants.py,sha256=AO-UWwsWPLb1k2JW6KP8rl9fxTcdT0rW-6XC6zfnDOs,4386
-QuizGenerator/contentast.py,sha256=LEjr-J79ooge0sAlZMuJcyz5Xfj2wRHlAJ_7jAULhBY,87614
-QuizGenerator/generate.py,sha256=qXLJ3WfOo_poIWoAZvEK7epNlVNSWxpOomMVt2MDExA,15816
+QuizGenerator/contentast.py,sha256=NY6Y9gWbdinXaVGdgwN61UBF2nz_L2urqr-IPfR6tV0,88475
+QuizGenerator/generate.py,sha256=qKYT-7HLUS1WSViDDSuJOIb5RwsTT3BuoUUZkoqSSus,17363
+QuizGenerator/logging.yaml,sha256=VJCdh26D8e_PNUs4McvvP1ojz9EVjQNifJzfhEk1Mbo,1114
 QuizGenerator/misc.py,sha256=MXrguUhhdrWSV4Hqdl4G21ktowODu1AcKy6-5mvy3aI,454
 QuizGenerator/mixins.py,sha256=zXj2U94qNbIEusbwTnzRM1Z_zSybpvozWhveq-t5q2Q,15771
 QuizGenerator/performance.py,sha256=CM3zLarJXN5Hfrl4-6JRBqD03j4BU1B2QW699HAr1Ds,7002
-QuizGenerator/qrcode_generator.py,sha256=S3mzZDk2UiHiw6ipSCpWPMhbKvSRR1P5ordZJUTo6ug,10776
-QuizGenerator/question.py,sha256=PKpQ6ZsHkyNw3yJBXlU3akS9Dqhmprq0dLu7wjRzg9A,37240
+QuizGenerator/qrcode_generator.py,sha256=VMbAXFxJ_3KryqrgynCUPR5myeiu5CoroBfwwBsinCc,13386
+QuizGenerator/question.py,sha256=BSopEaosCkJZ76etMv3Ue1zjzJpho-WnqS_8cQlZeac,38199
 QuizGenerator/quiz.py,sha256=CEWy7FB7BZiK33s_wYs6MqGKDetc6htUaqvP3--2HzI,21621
-QuizGenerator/regenerate.py,sha256=ZAs1mtERmO8JXza2tBqJpd-uJs9V7gS1jJ9A9gSb8jo,19764
+QuizGenerator/regenerate.py,sha256=cDYZ9LwOSkX9P7W72O0c6RI8ORzS-DFnYhAdC5-7UrI,20375
 QuizGenerator/typst_utils.py,sha256=JGQn_u5bEHd8HAtjAHuZoVJwLkx-Rd4ZCBWffwFZa3o,3136
 QuizGenerator/canvas/__init__.py,sha256=TwFP_zgxPIlWtkvIqQ6mcvBNTL9swIH_rJl7DGKcvkQ,286
-QuizGenerator/canvas/canvas_interface.py,sha256=StMcdXgLvTA1EayQ44m_le2GXGQpDQnduYXVeUYsqW0,24618
+QuizGenerator/canvas/canvas_interface.py,sha256=5PS7sZeIwRuOGK9gXmfgP4eUYtgCqZ1JKD-S4mNvsbk,24798
 QuizGenerator/canvas/classes.py,sha256=v_tQ8t_JJplU9sv2p4YctX45Fwed1nQ2HC1oC9BnDNw,7594
 QuizGenerator/premade_questions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 QuizGenerator/premade_questions/basic.py,sha256=u6Viv__5HYWjLOknYt_jsBJTej5-cPd9FM1xsuwUQcQ,4613
@@ -27,24 +29,24 @@ QuizGenerator/premade_questions/cst463/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JC
 QuizGenerator/premade_questions/cst463/gradient_descent/__init__.py,sha256=sH2CUV6zK9FT3jWTn453ys6_JTrUKRtZnU8hK6RmImU,240
 QuizGenerator/premade_questions/cst463/gradient_descent/gradient_calculation.py,sha256=y_R26wUt7AIZVUoe3e_qpzkPdwMyo3mZjxLI504-YQw,13840
 QuizGenerator/premade_questions/cst463/gradient_descent/gradient_descent_questions.py,sha256=OssybIkHx4l8ryHGT9rqHUecta9qpItK4QYVHuuQLeo,11525
-QuizGenerator/premade_questions/cst463/gradient_descent/loss_calculations.py,sha256=slNXfEeLRRM8IDhn3TSQdUWjAimDIfbgUSEmb48zCuU,24156
+QuizGenerator/premade_questions/cst463/gradient_descent/loss_calculations.py,sha256=PMuEAUJmN12t4ffHF0FoSbQNCLDfW5BKozWNHvoC6GU,24276
 QuizGenerator/premade_questions/cst463/gradient_descent/misc.py,sha256=0R-nFeD3zsqJyde5CXWrF6Npjmpx6_HbzfCbThLi3os,2657
 QuizGenerator/premade_questions/cst463/math_and_data/__init__.py,sha256=EbIaUrx7_aK9j3Gd8Mk08h9GocTq_0OoNu2trfNwaU8,202
 QuizGenerator/premade_questions/cst463/math_and_data/matrix_questions.py,sha256=4DLdo_8XDS_xtPA8R-wH4K0cKnMn4r5727Vszz8keTc,15565
 QuizGenerator/premade_questions/cst463/math_and_data/vector_questions.py,sha256=VXQCLQEeNKxRDPn_fGW5nAPX-0betrZ8mURh0ElbNz0,12668
 QuizGenerator/premade_questions/cst463/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-QuizGenerator/premade_questions/cst463/models/attention.py,sha256=iECxOoR0LEJAH_d7ZE3MoLOkdYVbGOKo4Dwf8Pww0tM,5443
-QuizGenerator/premade_questions/cst463/models/cnns.py,sha256=_HSjgClNBBid5t52CDQfPUMdKOHFOXjy7VQ3sW-zW-Y,6030
+QuizGenerator/premade_questions/cst463/models/attention.py,sha256=hb0sLVddxSKr4-bsIpAUyxITfcNaAGT-FppwwXXu52I,5430
+QuizGenerator/premade_questions/cst463/models/cnns.py,sha256=p3hvQEsTsI2urPrZ-MZ63eIq0Dm6aarrLATVIiECc2A,6017
 QuizGenerator/premade_questions/cst463/models/matrices.py,sha256=21eNXUcIjFNZTGH18oH-x3MbCa4buNGQGer3a5yL85c,1938
-QuizGenerator/premade_questions/cst463/models/rnns.py,sha256=5fKQuWnpSAoznZVJuCY4nICQ5KzB04Cz17hpccYiiVc,6673
-QuizGenerator/premade_questions/cst463/models/text.py,sha256=BnW6qIB8pnQiFRyXxtX9cdsIfmjw99p6TI0WqI0AQzk,6605
-QuizGenerator/premade_questions/cst463/models/weight_counting.py,sha256=sFnEvSs7ZwR4RZPltiMEElKJgoxHTaY427_g8Abi2uk,6912
+QuizGenerator/premade_questions/cst463/models/rnns.py,sha256=9pPzkrNviKD479NVgVvkoMhXtaLX0m17IIGpYKXXAwk,6660
+QuizGenerator/premade_questions/cst463/models/text.py,sha256=j6ClSF4AztgFWyvuhjBCW5mKvQL1AdizfhpF3iCjtt4,6592
+QuizGenerator/premade_questions/cst463/models/weight_counting.py,sha256=NriO0cukIw3HKYkm62p4PPm1qdH9wmDepEfoBzrmxR4,7402
 QuizGenerator/premade_questions/cst463/neural-network-basics/__init__.py,sha256=pmyCezO-20AFEQC6MR7KnAsaU9TcgZYsGQOMVkRZ-U8,149
 QuizGenerator/premade_questions/cst463/neural-network-basics/neural_network_questions.py,sha256=j2f5LFmme-2rSgJzcb8nZJ1_hnZaL-S4lXSnIbpoH_E,43010
 QuizGenerator/premade_questions/cst463/tensorflow-intro/__init__.py,sha256=G1gEHtG4KakYgi8ZXSYYhX6bQRtnm2tZVGx36d63Nmo,173
 QuizGenerator/premade_questions/cst463/tensorflow-intro/tensorflow_questions.py,sha256=t0ghv6o8AsZaIwVHFu07Ozebwuv6Rf18D3g_-Jz4O74,31309
-quizgenerator-0.9.0.dist-info/METADATA,sha256=84oI93hpRcDQO03t5qMjloNUWcCQo9MgOZmkMe9YrbY,8177
-quizgenerator-0.9.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-quizgenerator-0.9.0.dist-info/entry_points.txt,sha256=aOIdRdw26xY8HkxOoKHBnUPe2mwGv5Ti3U1zojb6zxQ,98
-quizgenerator-0.9.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-quizgenerator-0.9.0.dist-info/RECORD,,
+quizgenerator-0.10.0.dist-info/METADATA,sha256=zxcZ0akBMSH9jjA-sdpO55tZUlN4pfeSpIqFs9m864M,8483
+quizgenerator-0.10.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+quizgenerator-0.10.0.dist-info/entry_points.txt,sha256=aOIdRdw26xY8HkxOoKHBnUPe2mwGv5Ti3U1zojb6zxQ,98
+quizgenerator-0.10.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+quizgenerator-0.10.0.dist-info/RECORD,,