QuizGenerator 0.4.0__tar.gz → 0.4.2__tar.gz

{quizgenerator-0.4.0 → quizgenerator-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuizGenerator
-Version: 0.4.0
+Version: 0.4.2
 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.4.0 → quizgenerator-0.4.2}/QuizGenerator/contentast.py

@@ -850,7 +850,7 @@ class ContentAST:
       if self.inline:
         return f"${self.latex}$"
       else:
-        return r"$$ \displaystyle " + f"{self.latex}" + r" \; $$"
+        return r"$\displaystyle " + f"{self.latex}" + r"$"
 
     def render_html(self, **kwargs):
       if self.inline:
@@ -1048,7 +1048,7 @@ class ContentAST:
       if self.inline and self.bracket_type == "p":
         return f"$\\big(\\begin{{{matrix_env}}} {matrix_content} \\end{{{matrix_env}}}\\big)$"
       else:
-        return f"$$\\begin{{{matrix_env}}} {matrix_content} \\end{{{matrix_env}}}$$"
+        return f"$\\begin{{{matrix_env}}} {matrix_content} \\end{{{matrix_env}}}$"
 
     def render_html(self, **kwargs):
       matrix_env = "smallmatrix" if self.inline else f"{self.bracket_type}matrix"

{quizgenerator-0.4.0 → quizgenerator-0.4.2}/QuizGenerator/premade_questions/cst463/neural-network-basics/neural_network_questions.py

@@ -49,6 +49,7 @@ class SimpleNeuralNetworkBase(MatrixQuestion, abc.ABC):
     # Configuration
     self.activation_function = None
     self.use_bias = kwargs.get("use_bias", True)
+    self.param_digits = kwargs.get("param_digits", 1)  # Precision for weights/biases
 
     # Network parameters (weights and biases)
     self.W1 = None  # Input to hidden weights (num_hidden x num_inputs)
@@ -75,16 +76,19 @@ class SimpleNeuralNetworkBase(MatrixQuestion, abc.ABC):
   def _generate_network(self, weight_range=(-2, 2), input_range=(-3, 3)):
     """Generate random network parameters and input."""
     # Generate weights using MatrixQuestion's rounded matrix method
+    # Use param_digits to match display precision in tables and explanations
     self.W1 = self.get_rounded_matrix(
       (self.num_hidden, self.num_inputs),
       low=weight_range[0],
-      high=weight_range[1]
+      high=weight_range[1],
+      digits_to_round=self.param_digits
     )
 
     self.W2 = self.get_rounded_matrix(
       (self.num_outputs, self.num_hidden),
       low=weight_range[0],
-      high=weight_range[1]
+      high=weight_range[1],
+      digits_to_round=self.param_digits
     )
 
     # Generate biases
@@ -92,12 +96,14 @@ class SimpleNeuralNetworkBase(MatrixQuestion, abc.ABC):
       self.b1 = self.get_rounded_matrix(
         (self.num_hidden,),
         low=weight_range[0],
-        high=weight_range[1]
+        high=weight_range[1],
+        digits_to_round=self.param_digits
       )
       self.b2 = self.get_rounded_matrix(
         (self.num_outputs,),
         low=weight_range[0],
-        high=weight_range[1]
+        high=weight_range[1],
+        digits_to_round=self.param_digits
       )
     else:
       self.b1 = np.zeros(self.num_hidden)
@@ -256,7 +262,7 @@ class SimpleNeuralNetworkBase(MatrixQuestion, abc.ABC):
     for i in range(self.num_inputs):
       left_data.append([
         ContentAST.Equation(f"x_{i+1}", inline=True),
-        f"{self.X[i]:.1f}"
+        f"{self.X[i]:.1f}"  # Inputs are always integers or 1 decimal
       ])
 
     # Weights from input to hidden
@@ -264,14 +270,14 @@ class SimpleNeuralNetworkBase(MatrixQuestion, abc.ABC):
       for i in range(self.num_inputs):
         left_data.append([
           ContentAST.Equation(f"w_{{{j+1}{i+1}}}", inline=True),
-          f"{self.W1[j, i]:.1f}"
+          f"{self.W1[j, i]:.{self.param_digits}f}"
         ])
 
     # Weights from hidden to output
     for i in range(self.num_hidden):
       left_data.append([
         ContentAST.Equation(f"w_{i+3}", inline=True),
-        f"{self.W2[0, i]:.1f}"
+        f"{self.W2[0, i]:.{self.param_digits}f}"
       ])
 
     # Right table: Biases, Activations, Training context
@@ -283,14 +289,14 @@ class SimpleNeuralNetworkBase(MatrixQuestion, abc.ABC):
       for j in range(self.num_hidden):
         right_data.append([
           ContentAST.Equation(f"b_{j+1}", inline=True),
-          f"{self.b1[j]:.1f}"
+          f"{self.b1[j]:.{self.param_digits}f}"
         ])
 
     # Output bias
     if self.use_bias:
       right_data.append([
         ContentAST.Equation(r"b_{out}", inline=True),
-        f"{self.b2[0]:.1f}"
+        f"{self.b2[0]:.{self.param_digits}f}"
       ])
 
     # Hidden layer activations (if computed and requested)
@@ -628,11 +634,11 @@ class ForwardPassQuestion(SimpleNeuralNetworkBase):
       # Build equation for z_i
       terms = []
       for j in range(self.num_inputs):
-        terms.append(f"({self.W1[i,j]:.1f})({self.X[j]:.1f})")
+        terms.append(f"({self.W1[i,j]:.{self.param_digits}f})({self.X[j]:.1f})")
 
       z_calc = " + ".join(terms)
       if self.use_bias:
-        z_calc += f" + {self.b1[i]:.1f}"
+        z_calc += f" + {self.b1[i]:.{self.param_digits}f}"
 
       explanation.add_element(ContentAST.Equation(
         f"z_{i+1} = {z_calc} = {self.z1[i]:.4f}",
@@ -668,11 +674,11 @@ class ForwardPassQuestion(SimpleNeuralNetworkBase):
 
     terms = []
     for j in range(self.num_hidden):
-      terms.append(f"({self.W2[0,j]:.1f})({self.a1[j]:.4f})")
+      terms.append(f"({self.W2[0,j]:.{self.param_digits}f})({self.a1[j]:.4f})")
 
     z_out_calc = " + ".join(terms)
     if self.use_bias:
-      z_out_calc += f" + {self.b2[0]:.1f}"
+      z_out_calc += f" + {self.b2[0]:.{self.param_digits}f}"
 
     explanation.add_element(ContentAST.Equation(
       f"z_{{out}} = {z_out_calc} = {self.z2[0]:.4f}",
@@ -1197,7 +1203,7 @@ 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(ContentAST.Equation(
-      f"z_1 = w_{{11}} x_1 + w_{{12}} x_2 + b_1 = {self.W1[0,0]:.1f} \\cdot {self.X[0]:.1f} + {self.W1[0,1]:.1f} \\cdot {self.X[1]:.1f} + {self.b1[0]:.1f} = {self.z1[0]:.4f}",
+      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
     ))
 
@@ -1215,7 +1221,7 @@ 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(ContentAST.Equation(
-      f"z_{{out}} = w_3 h_1 + w_4 h_2 + b_2 = {self.W2[0,0]:.1f} \\cdot {self.a1[0]:.4f} + {self.W2[0,1]:.1f} \\cdot {self.a1[1]:.4f} + {self.b2[0]:.1f} = {self.z2[0]:.4f}",
+      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
     ))
 
@@ -1291,13 +1297,13 @@ class EndToEndTrainingQuestion(SimpleNeuralNetworkBase):
 
     new_w3 = self.new_W2[0, 0]
     explanation.add_element(ContentAST.Equation(
-      f"w_3^{{new}} = w_3 - \\alpha \\frac{{\\partial L}}{{\\partial w_3}} = {self.W2[0,0]:.1f} - {self.learning_rate} \\cdot {grad_w3:.4f} = {new_w3:.4f}",
+      f"w_3^{{new}} = w_3 - \\alpha \\frac{{\\partial L}}{{\\partial w_3}} = {self.W2[0,0]:.{self.param_digits}f} - {self.learning_rate} \\cdot {grad_w3:.4f} = {new_w3:.4f}",
       inline=False
     ))
 
     new_w11 = self.new_W1[0, 0]
     explanation.add_element(ContentAST.Equation(
-      f"w_{{11}}^{{new}} = w_{{11}} - \\alpha \\frac{{\\partial L}}{{\\partial w_{{11}}}} = {self.W1[0,0]:.1f} - {self.learning_rate} \\cdot {grad_w11:.4f} = {new_w11:.4f}",
+      f"w_{{11}}^{{new}} = w_{{11}} - \\alpha \\frac{{\\partial L}}{{\\partial w_{{11}}}} = {self.W1[0,0]:.{self.param_digits}f} - {self.learning_rate} \\cdot {grad_w11:.4f} = {new_w11:.4f}",
       inline=False
     ))
 

{quizgenerator-0.4.0 → quizgenerator-0.4.2}/QuizGenerator/question.py

@@ -76,14 +76,21 @@ def parse_spacing(spacing_value) -> float:
 
 class QuestionRegistry:
   _registry = {}
+  _class_name_to_registered_name = {}  # Reverse mapping: ClassName -> registered_name
   _scanned = False
-  
+
   @classmethod
   def register(cls, question_type=None):
     def decorator(subclass):
       # Use the provided name or fall back to the class name
       name = question_type.lower() if question_type else subclass.__name__.lower()
       cls._registry[name] = subclass
+
+      # Build reverse mapping from class name to registered name
+      # This allows looking up by class name when QR codes store the class name
+      class_name = subclass.__name__.lower()
+      cls._class_name_to_registered_name[class_name] = name
+
       return subclass
     return decorator
     
@@ -97,29 +104,40 @@ class QuestionRegistry:
     # Check to see if it's in the registry
     question_key = question_type.lower()
     if question_key not in cls._registry:
-      # Try stripping common course prefixes and module paths for backward compatibility
-      for prefix in ['cst334.', 'cst463.']:
-        if question_key.startswith(prefix):
-          stripped_name = question_key[len(prefix):]
-          if stripped_name in cls._registry:
-            question_key = stripped_name
-            break
-          # Also try extracting just the final class name after dots
-          if '.' in stripped_name:
-            final_name = stripped_name.split('.')[-1]
+      # Try the reverse mapping from class name to registered name
+      # This handles cases where QR codes store class name (e.g., "RNNForwardPass")
+      # but the question is registered with a custom name (e.g., "cst463.rnn.forward-pass")
+      if question_key in cls._class_name_to_registered_name:
+        question_key = cls._class_name_to_registered_name[question_key]
+        log.debug(f"Resolved class name '{question_type}' to registered name '{question_key}'")
+      else:
+        # Try stripping common course prefixes and module paths for backward compatibility
+        for prefix in ['cst334.', 'cst463.']:
+          if question_key.startswith(prefix):
+            stripped_name = question_key[len(prefix):]
+            if stripped_name in cls._registry:
+              question_key = stripped_name
+              break
+            # Also try extracting just the final class name after dots
+            if '.' in stripped_name:
+              final_name = stripped_name.split('.')[-1]
+              if final_name in cls._registry:
+                question_key = final_name
+                break
+        else:
+          # As a final fallback, try just the last part after dots
+          if '.' in question_key:
+            final_name = question_key.split('.')[-1]
             if final_name in cls._registry:
               question_key = final_name
-              break
-      else:
-        # As a final fallback, try just the last part after dots
-        if '.' in question_key:
-          final_name = question_key.split('.')[-1]
-          if final_name in cls._registry:
-            question_key = final_name
+            elif final_name in cls._class_name_to_registered_name:
+              # Try the class name reverse mapping on the final part
+              question_key = cls._class_name_to_registered_name[final_name]
+              log.debug(f"Resolved class name '{final_name}' to registered name '{question_key}'")
+            else:
+              raise ValueError(f"Unknown question type: {question_type}")
           else:
             raise ValueError(f"Unknown question type: {question_type}")
-        else:
-          raise ValueError(f"Unknown question type: {question_type}")
 
     new_question : Question = cls._registry[question_key](**kwargs)
     # Note: Don't call refresh() here - it will be called by get_question()
@@ -530,7 +548,8 @@ class Question(abc.ABC):
     )
 
     # Attach regeneration metadata to the question AST
-    question_ast.question_class_name = self.__class__.__name__
+    # Use the registered name instead of class name for better QR code regeneration
+    question_ast.question_class_name = self._get_registered_name()
     question_ast.generation_seed = actual_seed
     question_ast.question_version = self.VERSION
     # Make a copy of config_params so each question AST has its own
@@ -642,6 +661,26 @@ class Question(abc.ABC):
       return True
     return False
 
+  def _get_registered_name(self) -> str:
+    """
+    Get the registered name for this question class.
+
+    Returns the name used when registering the question with @QuestionRegistry.register(),
+    which may be different from the class name (e.g., "cst463.rnn.forward-pass" vs "RNNForwardPass").
+
+    This is used for QR code generation to ensure regeneration works correctly.
+    Falls back to class name if not found in registry (shouldn't happen in practice).
+    """
+    class_name_lower = self.__class__.__name__.lower()
+    registered_name = QuestionRegistry._class_name_to_registered_name.get(class_name_lower)
+
+    if registered_name is None:
+      # Fallback to class name if not found (shouldn't happen but be defensive)
+      log.warning(f"Question {self.__class__.__name__} not found in registry reverse mapping, using class name")
+      return self.__class__.__name__
+
+    return registered_name
+
 class QuestionGroup():
   
   def __init__(self, questions_in_group: List[Question], pick_once : bool):

{quizgenerator-0.4.0 → quizgenerator-0.4.2}/pyproject.toml

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

{quizgenerator-0.4.0 → quizgenerator-0.4.2}/pyproject_prev.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "QuizGenerator"
-version = "0.3.1"
+version = "0.4.1"
 description = "Generate randomized quiz questions for Canvas LMS and PDF exams"
 readme = "README.md"
 license = {text = "GPL-3.0-or-later"}
@@ -51,6 +51,7 @@ Repository = "https://github.com/OtterDen-Lab/QuizGenerator"
 
 [project.scripts]
 quizgen = "QuizGenerator.generate:main"
+quizregen = "QuizGenerator.regenerate:main"
 
 [project.optional-dependencies]
 grading = [

{quizgenerator-0.4.0 → quizgenerator-0.4.2}/uv.lock

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