QuizGenerator 0.9.0__py3-none-any.whl → 0.10.1__py3-none-any.whl

QuizGenerator/premade_questions/cst463/math_and_data/vector_questions.py

@@ -3,7 +3,6 @@ import abc
 import logging
 import math
 import random
-from typing import List
 
 from QuizGenerator.question import Question, QuestionRegistry
 import QuizGenerator.contentast as ca

QuizGenerator/premade_questions/cst463/models/attention.py

@@ -1,13 +1,9 @@
-import abc
 import logging
-import math
-import keras
 import numpy as np
 from typing import List, Tuple
 
-from QuizGenerator.question import Question, QuestionRegistry
+from QuizGenerator.question import QuestionRegistry
 import QuizGenerator.contentast as ca
-from QuizGenerator.constants import MathRanges
 from QuizGenerator.mixins import TableQuestionMixin
 
 from .matrices import MatrixQuestion

QuizGenerator/premade_questions/cst463/models/cnns.py

@@ -1,13 +1,9 @@
-import abc
 import logging
-import math
-import keras
 import numpy as np
 from typing import List, Tuple
 
-from QuizGenerator.question import Question, QuestionRegistry
+from QuizGenerator.question import QuestionRegistry
 import QuizGenerator.contentast as ca
-from QuizGenerator.constants import MathRanges
 from .matrices import MatrixQuestion
 
 log = logging.getLogger(__name__)

QuizGenerator/premade_questions/cst463/models/rnns.py

@@ -1,14 +1,10 @@
-import abc
 import logging
-import math
-import keras
 import numpy as np
 from typing import List, Tuple
 
 from .matrices import MatrixQuestion
-from QuizGenerator.question import Question, QuestionRegistry
+from QuizGenerator.question import QuestionRegistry
 import QuizGenerator.contentast as ca
-from QuizGenerator.constants import MathRanges
 from QuizGenerator.mixins import TableQuestionMixin
 
 log = logging.getLogger(__name__)

QuizGenerator/premade_questions/cst463/models/text.py

@@ -1,14 +1,10 @@
-import abc
 import logging
-import math
-import keras
 import numpy as np
 from typing import List, Tuple
 
 from QuizGenerator.premade_questions.cst463.models.matrices import MatrixQuestion
-from QuizGenerator.question import Question, QuestionRegistry
+from QuizGenerator.question import QuestionRegistry
 import QuizGenerator.contentast as ca
-from QuizGenerator.constants import MathRanges
 from QuizGenerator.mixins import TableQuestionMixin
 
 log = logging.getLogger(__name__)

QuizGenerator/premade_questions/cst463/models/weight_counting.py

@@ -1,19 +1,33 @@
+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
 
 from QuizGenerator.question import Question, QuestionRegistry
 import QuizGenerator.contentast as ca
-from QuizGenerator.constants import MathRanges
 
 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 +35,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 +192,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 +227,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/premade_questions/cst463/neural-network-basics/__init__.py

@@ -4,3 +4,10 @@ from .neural_network_questions import (
   EnsembleAveragingQuestion,
   EndToEndTrainingQuestion
 )
+
+__all__ = [
+  "ForwardPassQuestion",
+  "BackpropGradientQuestion",
+  "EnsembleAveragingQuestion",
+  "EndToEndTrainingQuestion",
+]

QuizGenerator/premade_questions/cst463/neural-network-basics/neural_network_questions.py

@@ -3,18 +3,13 @@ from __future__ import annotations
 import abc
 import io
 import logging
-import math
 import numpy as np
-import uuid
-import os
 from typing import List, Tuple
 
 import matplotlib.pyplot as plt
-import matplotlib.patches as mpatches
 
 import QuizGenerator.contentast as ca
 from QuizGenerator.question import Question, QuestionRegistry
-from QuizGenerator.mixins import TableQuestionMixin, BodyTemplatesMixin
 from ..models.matrices import MatrixQuestion
 
 log = logging.getLogger(__name__)
@@ -843,8 +838,7 @@ class BackpropGradientQuestion(SimpleNeuralNetworkBase):
       # Compute intermediate values
       dz2_da1 = self.W2[0, 0]
       da1_dz1 = self._activation_derivative(self.z1[0])
-      dL_dz1 = self.dL_dz2 * dz2_da1 * da1_dz1
-
+      
       grad = self._compute_gradient_W1(0, j)
 
       if self.activation_function == self.ACTIVATION_SIGMOID:
@@ -1131,7 +1125,6 @@ class EndToEndTrainingQuestion(SimpleNeuralNetworkBase):
     ]))
 
     # Hidden layer
-    z1_0 = self.W1[0, 0] * self.X[0] + self.W1[0, 1] * self.X[1] + self.b1[0]
     explanation.add_element(ca.Equation(
       f"z_1 = w_{{11}} x_1 + w_{{12}} x_2 + b_1 = {self.W1[0,0]:.{self.param_digits}f} \\cdot {self.X[0]:.1f} + {self.W1[0,1]:.{self.param_digits}f} \\cdot {self.X[1]:.1f} + {self.b1[0]:.{self.param_digits}f} = {self.z1[0]:.4f}",
       inline=False
@@ -1149,7 +1142,6 @@ class EndToEndTrainingQuestion(SimpleNeuralNetworkBase):
     ))
 
     # Output (pre-activation)
-    z2 = self.W2[0, 0] * self.a1[0] + self.W2[0, 1] * self.a1[1] + self.b2[0]
     explanation.add_element(ca.Equation(
       f"z_{{out}} = w_3 h_1 + w_4 h_2 + b_2 = {self.W2[0,0]:.{self.param_digits}f} \\cdot {self.a1[0]:.4f} + {self.W2[0,1]:.{self.param_digits}f} \\cdot {self.a1[1]:.4f} + {self.b2[0]:.{self.param_digits}f} = {self.z2[0]:.4f}",
       inline=False

QuizGenerator/premade_questions/cst463/tensorflow-intro/__init__.py

@@ -4,3 +4,10 @@ from .tensorflow_questions import (
   RegularizationCalculationQuestion,
   MomentumOptimizerQuestion
 )
+
+__all__ = [
+  "ParameterCountingQuestion",
+  "ActivationFunctionComputationQuestion",
+  "RegularizationCalculationQuestion",
+  "MomentumOptimizerQuestion",
+]

QuizGenerator/premade_questions/cst463/tensorflow-intro/tensorflow_questions.py

@@ -1,9 +1,6 @@
 from __future__ import annotations
 
-import abc
-import io
 import logging
-import re
 import numpy as np
 import sympy as sp
 from typing import List, Tuple
@@ -900,7 +897,6 @@ class MomentumOptimizerQuestion(Question, TableQuestionMixin, BodyTemplatesMixin
     # Show calculation for each component
     digits = ca.Answer.DEFAULT_ROUNDING_DIGITS
     for i in range(context.num_variables):
-      var_name = f"x_{i}"
       # Round all intermediate values to avoid floating point precision issues
       beta_times_v = round(context.momentum_beta * context.prev_velocity[i], digits)
       one_minus_beta = round(1 - context.momentum_beta, digits)

QuizGenerator/qrcode_generator.py

@@ -9,17 +9,20 @@ 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
-from io import BytesIO
+import tempfile
+import zlib
+from datetime import datetime
 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 +41,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 +80,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 +189,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 +214,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 +273,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

@@ -11,16 +11,12 @@ import itertools
 import os
 import pathlib
 import pkgutil
-import pprint
 import random
-import re
 import uuid
 import types
 import inspect
 from types import MappingProxyType
 
-import pypandoc
-import yaml
 from typing import List, Dict, Any, Tuple, Optional, Mapping, MutableMapping
 import canvasapi.course, canvasapi.quiz
 
@@ -45,6 +41,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 +91,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 +260,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():
@@ -614,12 +618,6 @@ class Question(abc.ABC):
     }
     self.config_params = {k: v for k, v in kwargs.items() if k not in framework_params}
   
-  @classmethod
-  def from_yaml(cls, path_to_yaml):
-    with open(path_to_yaml) as fid:
-      question_dicts = yaml.safe_load_all(fid)
-  
-
   def instantiate(self, **kwargs) -> QuestionInstance:
     """
     Instantiate a question once, returning content, answers, and regeneration metadata.
@@ -688,6 +686,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 +713,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 +945,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 +1028,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/quiz.py

@@ -2,15 +2,10 @@
 from __future__ import annotations
 
 import collections
-import itertools
 import logging
-import os.path
 import random
-import shutil
-import subprocess
-import tempfile
 from datetime import datetime
-from typing import List, Dict, Optional
+from typing import List
 import re
 
 import yaml