QuizGenerator 0.3.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

QuizGenerator/misc.py

@@ -564,9 +564,9 @@ class MatrixAnswer(Answer):
             value=self.value[i,j]
           )
         )
-        for i in range(self.value.shape[0])
+        for j in range(self.value.shape[1])
       ]
-      for j in range(self.value.shape[1])
+      for i in range(self.value.shape[0])
     ]
     table = ContentAST.Table(data)
     

QuizGenerator/premade_questions/cst334/languages.py

@@ -60,11 +60,9 @@ class BNF:
         
     def get_grammar_string(self):
       lines = []
-      lines.append('```')
       for symbol in self.symbols:
         lines.append(f"{symbol.get_full_str()}")
-      
-      lines.append('```')
+
       return '\n'.join(lines)
       
   class Symbol:
@@ -342,25 +340,23 @@ class ValidStringsInLanguageQuestion(LanguageQuestion):
   def get_body(self, *args, **kwargs) -> ContentAST.Section:
     body = ContentAST.Section()
     
-    body.add_element(
+    body.add_elements([
       ContentAST.Paragraph([
-        ContentAST.OnlyHtml(
+        ContentAST.OnlyHtml([
           ContentAST.Text("Given the following grammar, which of the below strings are part of the language?")
-        ),
-        ContentAST.OnlyLatex(
+        ]),
+        ContentAST.OnlyLatex([
           ContentAST.Text(
             "Given the following grammar "
             "please circle any provided strings that are part of the language (or indicate clearly if there are none), "
             "and on each blank line provide generate a new, unique string that is part of the language."
           )
-        )
+        ])
       ])
-    )
+    ])
     
     body.add_element(
-      ContentAST.Paragraph([
-        self.grammar_good.get_grammar_string()
-      ])
+      ContentAST.Code(self.grammar_good.get_grammar_string())
     )
     
     # Add in some answers as latex-only options to be circled
@@ -374,7 +370,7 @@ class ValidStringsInLanguageQuestion(LanguageQuestion):
     # For Latex-only, ask students to generate some more.
     body.add_element(
       ContentAST.OnlyLatex([
-        ContentAST.AnswerBlock([ContentAST.Answer() for _ in range(self.num_answer_blanks)])
+        ContentAST.AnswerBlock([ContentAST.Answer(Answer.string(f"blank_line_{i}", f"blank_line_{i}"), label=f"blank_line_{i}") for i in range(self.num_answer_blanks)])
       ])
     )
     

QuizGenerator/premade_questions/cst334/persistence_questions.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import abc
+import difflib
 import logging
 
 from QuizGenerator.question import Question, Answer, QuestionRegistry
@@ -365,31 +366,85 @@ class VSFS_states(IOQuestion):
   def get_explanation(self) -> ContentAST.Section:
     explanation = ContentAST.Section()
     
-    explanation.add_element(
+    log.debug(f"self.start_state: {self.start_state}")
+    log.debug(f"self.end_state: {self.end_state}")
+    
+    explanation.add_elements([
       ContentAST.Paragraph([
-        "These questions are based on the VSFS simulator that our book mentions.  "
-        "We will be discussing the interpretation of this in class, but you can also find information "
-        "<a href=\"https://github.com/chyyuu/os_tutorial_lab/blob/master/ostep/ostep13-vsfs.md\">here</a>, "
-        "as well as simulator code.  Please note that the code uses python 2.",
-        "",
-        "In general, I recommend looking for differences between the two outputs.  Recommended steps would be:",
-        "<ol>"
-        
-        "<li> Check to see if there are differences between the bitmaps "
-        "that could indicate a file/directroy were created or removed.</li>",
-        
-        "<li>Check the listed inodes to see if any entries have changed.  "
-        "This might be a new entry entirely or a reference count changing.  "
-        "If the references increased then this was likely a link or creation, "
-        "and if it decreased then it is likely an unlink.</li>",
-        
-        "<li>Look at the data blocks to see if a new entry has "
-        "been added to a directory or a new block has been mapped.</li>",
-        
-        "</ol>",
-        "These steps can usually help you quickly identify "
-        "what has occured in the simulation and key you in to the right answer."
+        "The key thing to pay attention to when solving these problems is where there are differences between the start state and the end state.",
+        "In this particular problem, we can see that these lines are different:"
       ])
+    ])
+    
+    chunk_to_add = []
+    lines_that_changed = []
+    for start_line, end_line in zip(self.start_state.split('\n'), self.end_state.split('\n')):
+      if start_line == end_line:
+        continue
+      lines_that_changed.append((start_line, end_line))
+      chunk_to_add.append(
+        f" - `{start_line}` -> `{end_line}`"
+      )
+    
+    explanation.add_element(
+      ContentAST.Paragraph(chunk_to_add)
+    )
+    
+    chunk_to_add = [
+      "A great place to start is to check to see if the bitmaps have changed as this can quickly tell us a lot of information"
+    ]
+    
+    inode_bitmap_lines = list(filter(lambda s: "inode bitmap" in s[0], lines_that_changed))
+    data_bitmap_lines = list(filter(lambda s: "data bitmap" in s[0], lines_that_changed))
+    
+    def get_bitmap(line: str) -> str:
+      log.debug(f"line: {line}")
+      return line.split()[-1]
+    
+    def highlight_changes(a: str, b: str) -> str:
+      matcher = difflib.SequenceMatcher(None, a, b)
+      result = []
+      
+      for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == "equal":
+          result.append(b[j1:j2])
+        elif tag in ("insert", "replace"):
+          result.append(f"***{b[j1:j2]}***")
+        # for "delete", do nothing since text is removed
+      
+      return "".join(result)
+    
+    if len(inode_bitmap_lines) > 0:
+      inode_bitmap_lines = inode_bitmap_lines[0]
+      chunk_to_add.append(f"The inode bitmap lines have changed from {get_bitmap(inode_bitmap_lines[0])} to {get_bitmap(inode_bitmap_lines[1])}.")
+      if get_bitmap(inode_bitmap_lines[0]).count('1') < get_bitmap(inode_bitmap_lines[1]).count('1'):
+        chunk_to_add.append("We can see that we have added an inode, so we have either called `creat` or `mkdir`.")
+      else:
+        chunk_to_add.append("We can see that we have removed an inode, so we have called `unlink`.")
+    
+    if len(data_bitmap_lines) > 0:
+      data_bitmap_lines = data_bitmap_lines[0]
+      chunk_to_add.append(f"The inode bitmap lines have changed from {get_bitmap(data_bitmap_lines[0])} to {get_bitmap(data_bitmap_lines[1])}.")
+      if get_bitmap(data_bitmap_lines[0]).count('1') < get_bitmap(data_bitmap_lines[1]).count('1'):
+        chunk_to_add.append("We can see that we have added a data block, so we have either called `mkdir` or `write`.")
+      else:
+        chunk_to_add.append("We can see that we have removed a data block, so we have `unlink`ed a file.")
+    
+    if len(data_bitmap_lines) == 0 and len(inode_bitmap_lines) == 0:
+      chunk_to_add.append("If they have not changed, then we know we must have eithered called `link` or `unlink` and must check the references.")
+      
+    explanation.add_element(
+      ContentAST.Paragraph(chunk_to_add)
+    )
+    
+    explanation.add_elements([
+      ContentAST.Paragraph(["The overall changes are highlighted with `*` symbols below"])
+    ])
+    
+    explanation.add_element(
+      ContentAST.Code(
+        highlight_changes(self.start_state, self.end_state)
+      )
     )
     
     return explanation

QuizGenerator/premade_questions/cst463/models/cnns.py

@@ -28,7 +28,7 @@ class ConvolutionCalculation(MatrixQuestion):
     
     # Add padding
     if padding > 0:
-      image = np.pad(image, ((padding, padding), (padding, padding), (0, 0)), mode='constant')
+      image = np.pad(image, ((padding, padding), (padding, padding)), mode='constant')
       H, W = H + 2 * padding, W + 2 * padding
     
     # Output dimensions

QuizGenerator/premade_questions/cst463/models/text.py

@@ -60,7 +60,9 @@ class word2vec__skipgram(MatrixQuestion, TableQuestionMixin):
     ## Answers:
     # center_word, center_emb, context_words, context_embs, logits, probs
     self.answers["logits"] = Answer.vector_value(key="logits", value=self.logits)
-    self.answers["center_word"] = Answer.string(key="center_word", value=self.center_word)
+    most_likely_idx = np.argmax(self.probs)
+    most_likely_word = self.context_words[most_likely_idx]
+    self.answers["center_word"] = Answer.string(key="center_word", value=most_likely_word)
     
     
     return True
@@ -81,7 +83,7 @@ class word2vec__skipgram(MatrixQuestion, TableQuestionMixin):
       ContentAST.LineBreak(),
       self.answers["logits"].get_ast_element("Logits"),
       ContentAST.LineBreak(),
-      self.answers["center_word"].get_ast_element("Center word")
+      self.answers["center_word"].get_ast_element("Most likely context word")
     ])
     
     

QuizGenerator/premade_questions/cst463/models/weight_counting.py

@@ -194,7 +194,7 @@ class WeightCounting_CNN(WeightCounting):
         )
       ]
     )
-    return model, ["filters", "kernel_size", "strides", "padding", "pool_size"]
+    return model, ["units", "filters", "kernel_size", "strides", "padding", "pool_size"]
 
 
 @QuestionRegistry.register("cst463.WeightCounting-RNN")

QuizGenerator/regenerate.py

@@ -0,0 +1,472 @@
+#!/usr/bin/env python
+"""
+QR Code-based Grading Utility
+
+This script scans QR codes from quiz PDFs to regenerate question answers
+for grading. It supports both scanning from image files and interactive
+scanning from webcam/scanner.
+
+CLI Usage:
+    # Scan a single QR code image
+    python grade_from_qr.py --image qr_code.png
+
+    # Scan QR codes from a scanned exam page
+    python grade_from_qr.py --image exam_page.jpg --all
+
+API Usage (recommended for web UIs):
+    from grade_from_qr import regenerate_from_encrypted
+
+    # Parse QR code JSON
+    qr_data = json.loads(qr_string)
+
+    # Regenerate answers from encrypted data (one function call!)
+    result = regenerate_from_encrypted(
+        encrypted_data=qr_data['s'],
+        points=qr_data['pts']
+    )
+
+    # Display HTML answer key to grader
+    print(result['answer_key_html'])
+
+The QR codes contain encrypted question metadata that allows regenerating
+the exact question and answer without needing the original exam file.
+"""
+
+import argparse
+import json
+import sys
+import logging
+from pathlib import Path
+from typing import Dict, Any, Optional, List
+
+# Quiz generator imports (always available)
+from QuizGenerator.qrcode_generator import QuestionQRCode
+from QuizGenerator.question import QuestionRegistry
+
+# QR code reading (optional - only needed for CLI usage with --image)
+# Your web UI should use its own QR decoding library
+try:
+  from pyzbar import pyzbar
+  from PIL import Image
+  
+  HAS_IMAGE_SUPPORT = True
+except ImportError:
+  HAS_IMAGE_SUPPORT = False
+  # Don't fail immediately - only fail if user tries to use --image flag
+
+logging.basicConfig(
+  level=logging.INFO,
+  format='%(levelname)s: %(message)s'
+)
+log = logging.getLogger(__name__)
+
+
+def scan_qr_from_image(image_path: str) -> List[str]:
+  """
+  Scan all QR codes from an image file.
+
+  Args:
+      image_path: Path to image file containing QR code(s)
+
+  Returns:
+      List of decoded QR code data strings
+
+  Raises:
+      ImportError: If pyzbar/PIL are not installed
+  """
+  if not HAS_IMAGE_SUPPORT:
+    raise ImportError(
+      "Image support not available. Install with: pip install pyzbar pillow"
+    )
+  
+  try:
+    img = Image.open(image_path)
+    decoded_objects = pyzbar.decode(img)
+    
+    if not decoded_objects:
+      log.warning(f"No QR codes found in {image_path}")
+      return []
+    
+    qr_data = [obj.data.decode('utf-8') for obj in decoded_objects]
+    log.info(f"Found {len(qr_data)} QR code(s) in {image_path}")
+    
+    return qr_data
+  
+  except Exception as e:
+    log.error(f"Failed to read image {image_path}: {e}")
+    return []
+
+
+def parse_qr_data(qr_string: str) -> Dict[str, Any]:
+  """
+  Parse QR code JSON data.
+
+  Args:
+      qr_string: JSON string from QR code
+
+  Returns:
+      Dictionary with question metadata
+      {
+          "q": question_number,
+          "pts": points_value,
+          "s": encrypted_seed_data (optional)
+      }
+  """
+  try:
+    data = json.loads(qr_string)
+    log.debug(f"Parsed QR data: {data}")
+    return data
+  except json.JSONDecodeError as e:
+    log.error(f"Failed to parse QR code JSON: {e}")
+    return {}
+
+
+def regenerate_question_answer(qr_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+  """
+  Regenerate question and extract answer using QR code metadata.
+
+  Args:
+      qr_data: Parsed QR code data dictionary
+
+  Returns:
+      Dictionary with question info and answers, or None if regeneration fails
+      {
+          "question_number": int,
+          "points": float,
+          "question_type": str,
+          "seed": int,
+          "version": str,
+          "answers": dict,
+          "explanation_markdown": str | None  # Markdown explanation (None if not available)
+      }
+  """
+  question_num = qr_data.get('q')
+  points = qr_data.get('pts')
+  
+  if question_num is None or points is None:
+    log.error("QR code missing required fields 'q' or 'pts'")
+    return None
+  
+  result = {
+    "question_number": question_num,
+    "points": points
+  }
+  
+  # Check if encrypted regeneration data is present
+  encrypted_data = qr_data.get('s')
+  if not encrypted_data:
+    log.warning(f"Question {question_num}: No regeneration data in QR code")
+    log.warning("  This question cannot be automatically regenerated.")
+    log.warning("  (QR codes generated before encryption feature was added)")
+    return result
+  
+  try:
+    # Decrypt the regeneration data
+    regen_data = QuestionQRCode.decrypt_question_data(encrypted_data)
+    
+    question_type = regen_data['question_type']
+    seed = regen_data['seed']
+    version = regen_data['version']
+    config = regen_data.get('config', {})
+    
+    result['question_type'] = question_type
+    result['seed'] = seed
+    result['version'] = version
+    if config:
+      result['config'] = config
+    
+    log.info(f"Question {question_num}: {question_type} (seed={seed}, version={version})")
+    if config:
+      log.debug(f"  Config params: {config}")
+    
+    # Regenerate the question using the registry, passing through config params
+    question = QuestionRegistry.create(
+      question_type,
+      name=f"Q{question_num}",
+      points_value=points,
+      **config
+    )
+    
+    # Generate question with the specific seed
+    question_ast = question.get_question(rng_seed=seed)
+    
+    # Extract answers
+    answer_kind, canvas_answers = question.get_answers()
+    
+    result['answers'] = {
+      'kind': answer_kind.value,
+      'data': canvas_answers
+    }
+    
+    # Also store the raw answer objects for easier access
+    result['answer_objects'] = question.answers
+    
+    # Generate HTML answer key for grading
+    question_html = question_ast.body.render("html", show_answers=True)
+    result['answer_key_html'] = question_html
+
+    # Generate markdown explanation for students
+    explanation_markdown = question_ast.explanation.render("markdown")
+    # Return None if explanation is empty or contains the default placeholder
+    if not explanation_markdown or "[Please reach out to your professor for clarification]" in explanation_markdown:
+      result['explanation_markdown'] = None
+    else:
+      result['explanation_markdown'] = explanation_markdown
+
+    log.info(f"  Successfully regenerated question with {len(canvas_answers)} answer(s)")
+    
+    return result
+  
+  except Exception as e:
+    log.error(f"Failed to regenerate question {question_num}: {e}")
+    import traceback
+    log.debug(traceback.format_exc())
+    return result
+
+
+def regenerate_from_encrypted(encrypted_data: str, points: float = 1.0) -> Dict[str, Any]:
+  """
+  Regenerate question answers from encrypted QR code data (RECOMMENDED API).
+
+  This is the simplest function for web UI integration - just pass the encrypted
+  string from the QR code and get back the complete answer key.
+
+  Args:
+      encrypted_data: The encrypted 's' field from the QR code JSON
+      points: Point value for the question (default: 1.0)
+
+  Returns:
+      Dictionary with regenerated answers:
+      {
+          "question_type": str,
+          "seed": int,
+          "version": str,
+          "points": float,
+          "kwargs": dict,  # Question-specific config params (if any)
+          "answers": dict,  # Canvas-formatted answers
+          "answer_objects": dict,  # Raw Answer objects with values/tolerances
+          "answer_key_html": str,  # HTML rendering of question with answers shown
+          "explanation_markdown": str | None  # Markdown explanation (None if not available)
+      }
+
+  Raises:
+      ValueError: If decryption fails or question regeneration fails
+
+  Example:
+      >>> # Your web UI scans QR code and gets JSON: {"q": 1, "pts": 5, "s": "gAAAAAB..."}
+      >>> encrypted_string = qr_json['s']
+      >>> result = regenerate_from_encrypted(encrypted_string, points=qr_json['pts'])
+      >>> print(result['answer_key_html'])  # Display to grader!
+  """
+  # Decrypt the data
+  decrypted = QuestionQRCode.decrypt_question_data(encrypted_data)
+  
+  # Extract fields
+  question_type = decrypted['question_type']
+  seed = decrypted['seed']
+  version = decrypted['version']
+  kwargs = decrypted.get('config', {})
+  
+  # Use the existing regeneration logic
+  return regenerate_from_metadata(question_type, seed, version, points, kwargs)
+
+
+def regenerate_from_metadata(
+    question_type: str, seed: int, version: str,
+    points: float = 1.0, kwargs: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+  """
+  Regenerate question answers from explicit metadata fields.
+
+  This is a lower-level function. Most users should use regenerate_from_encrypted() instead.
+
+  Args:
+      question_type: Question class name (e.g., "VirtualAddressParts")
+      seed: Random seed used to generate the question
+      version: Question version string (e.g., "1.0")
+      points: Point value for the question (default: 1.0)
+      kwargs: Optional dictionary of question-specific configuration parameters
+              (e.g., {"num_bits_va": 32, "max_value": 100})
+
+  Returns:
+      Dictionary with regenerated answers (same format as regenerate_from_encrypted)
+
+  Raises:
+      ValueError: If question type is not registered or regeneration fails
+  """
+  if kwargs is None:
+    kwargs = {}
+  
+  try:
+    log.info(f"Regenerating: {question_type} (seed={seed}, version={version})")
+    if kwargs:
+      log.debug(f"  Config params: {kwargs}")
+    
+    # Create question instance from registry, passing through kwargs
+    question = QuestionRegistry.create(
+      question_type,
+      name=f"Q_{question_type}_{seed}",
+      points_value=points,
+      **kwargs
+    )
+    
+    # Generate question with the specific seed
+    question_ast = question.get_question(rng_seed=seed)
+    
+    # Extract answers
+    answer_kind, canvas_answers = question.get_answers()
+    
+    # Generate HTML answer key for grading
+    question_html = question_ast.body.render("html", show_answers=True)
+
+    # Generate markdown explanation for students
+    explanation_markdown = question_ast.explanation.render("markdown")
+    # Return None if explanation is empty or contains the default placeholder
+    if not explanation_markdown or "[Please reach out to your professor for clarification]" in explanation_markdown:
+      explanation_markdown = None
+
+    result = {
+      "question_type": question_type,
+      "seed": seed,
+      "version": version,
+      "points": points,
+      "answers": {
+        "kind": answer_kind.value,
+        "data": canvas_answers
+      },
+      "answer_objects": question.answers,
+      "answer_key_html": question_html,
+      "explanation_markdown": explanation_markdown
+    }
+    
+    # Include kwargs in result if provided
+    if kwargs:
+      result["kwargs"] = kwargs
+    
+    log.info(f"  Successfully regenerated with {len(canvas_answers)} answer(s)")
+    return result
+  
+  except Exception as e:
+    log.error(f"Failed to regenerate question: {e}")
+    import traceback
+    log.debug(traceback.format_exc())
+    raise ValueError(f"Failed to regenerate question {question_type}: {e}")
+
+
+def display_answer_summary(question_data: Dict[str, Any]) -> None:
+  """
+  Display a formatted summary of the question and its answer(s).
+
+  Args:
+      question_data: Question data dictionary from regenerate_question_answer
+  """
+  print("\n" + "=" * 60)
+  print(f"Question {question_data['question_number']}: {question_data.get('points', '?')} points")
+  
+  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 '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})")
+  elif 'answers' in question_data:
+    print("\nANSWERS (raw Canvas format):")
+    print(f"  Type: {question_data['answers']['kind']}")
+    for ans in question_data['answers']['data']:
+      print(f"  - {ans}")
+  else:
+    print("\n(No regeneration data available)")
+  
+  if 'answer_key_html' in question_data:
+    print("\nHTML answer key available in result['answer_key_html']")
+
+  if 'explanation_markdown' in question_data and question_data['explanation_markdown'] is not None:
+    print("Markdown explanation available in result['explanation_markdown']")
+
+  print("=" * 60)
+
+
+def main():
+  parser = argparse.ArgumentParser(
+    description="Scan QR codes from quiz PDFs to regenerate answers for grading"
+  )
+  parser.add_argument(
+    '--image',
+    type=str,
+    help='Path to image file containing QR code(s)'
+  )
+  parser.add_argument(
+    '--all',
+    action='store_true',
+    help='Process all QR codes found in the image (default: only first one)'
+  )
+  parser.add_argument(
+    '--output',
+    type=str,
+    help='Save results to JSON file'
+  )
+  parser.add_argument(
+    '--verbose', '-v',
+    action='store_true',
+    help='Enable verbose debug logging'
+  )
+  
+  args = parser.parse_args()
+  
+  if args.verbose:
+    logging.getLogger().setLevel(logging.DEBUG)
+  
+  if not args.image:
+    parser.print_help()
+    print("\nERROR: --image is required")
+    sys.exit(1)
+  
+  # Scan QR codes from image
+  qr_codes = scan_qr_from_image(args.image)
+  
+  if not qr_codes:
+    print("No QR codes found in image")
+    sys.exit(1)
+  
+  # Process QR codes
+  if not args.all:
+    qr_codes = qr_codes[:1]
+    log.info("Processing only the first QR code (use --all to process all)")
+  
+  results = []
+  
+  for qr_string in qr_codes:
+    # Parse QR data
+    qr_data = parse_qr_data(qr_string)
+    
+    if not qr_data:
+      continue
+    
+    # Regenerate question and answer
+    question_data = regenerate_question_answer(qr_data)
+    
+    if question_data:
+      results.append(question_data)
+      display_answer_summary(question_data)
+  
+  # Save to file if requested
+  if args.output:
+    output_path = Path(args.output)
+    with open(output_path, 'w') as f:
+      json.dump(results, f, indent=2, default=str)
+    log.info(f"Results saved to {output_path}")
+  
+  if not results:
+    print("\nNo questions could be regenerated from the QR codes.")
+    sys.exit(1)
+  
+  print(f"\nSuccessfully regenerated {len(results)} question(s)")
+
+
+if __name__ == '__main__':
+  main()

{quizgenerator-0.3.0.dist-info → quizgenerator-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuizGenerator
-Version: 0.3.0
+Version: 0.4.1
 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.3.0.dist-info → quizgenerator-0.4.1.dist-info}/RECORD

@@ -5,12 +5,13 @@ QuizGenerator/constants.py,sha256=AO-UWwsWPLb1k2JW6KP8rl9fxTcdT0rW-6XC6zfnDOs,43
 QuizGenerator/contentast.py,sha256=Em4cnA64Y8_07VruJk_MXwiWcJwqT4-YVf-Lw7uIvYY,68327
 QuizGenerator/generate.py,sha256=o2XezoSE0u-qjxYu1_Ofm9Lpkza7M2Tg47C-ClMcPsE,7197
 QuizGenerator/logging.yaml,sha256=VJCdh26D8e_PNUs4McvvP1ojz9EVjQNifJzfhEk1Mbo,1114
-QuizGenerator/misc.py,sha256=JYv-SUn3y33O6grpgvRWRBkJi4RhTuXcMgrhmBjRbZg,18710
+QuizGenerator/misc.py,sha256=2vEztj-Kt_0Q2OnynJKC4gL_w7l1MqWsBhhIDOuVD1s,18710
 QuizGenerator/mixins.py,sha256=zUKTkswq7aoDZ_nGPUdRuvnza8iH8ZCi6IH2Uw-kCvs,18492
 QuizGenerator/performance.py,sha256=CM3zLarJXN5Hfrl4-6JRBqD03j4BU1B2QW699HAr1Ds,7002
 QuizGenerator/qrcode_generator.py,sha256=S3mzZDk2UiHiw6ipSCpWPMhbKvSRR1P5ordZJUTo6ug,10776
 QuizGenerator/question.py,sha256=uxDYyrq17JFXQ11S03Px5cyRuPYn4qKT3z7TZn9XSjg,26093
 QuizGenerator/quiz.py,sha256=toPodXea2UYGgAf4jyor3Gz-gtXYN1YUJFJFQ5u70v4,18718
+QuizGenerator/regenerate.py,sha256=EvtFhDUXYaWEBCGJ4RW-zN65qj3cMxWa_Y_Rn44WU6c,14282
 QuizGenerator/typst_utils.py,sha256=XtMEO1e4_Tg0G1zR9D1fmrYKlUfHenBPdGoCKR0DhZg,3154
 QuizGenerator/canvas/__init__.py,sha256=TwFP_zgxPIlWtkvIqQ6mcvBNTL9swIH_rJl7DGKcvkQ,286
 QuizGenerator/canvas/canvas_interface.py,sha256=wsEWh2lonUMgmbtXF-Zj59CAM_0NInoaERqsujlYMfc,24501
@@ -18,11 +19,11 @@ QuizGenerator/canvas/classes.py,sha256=v_tQ8t_JJplU9sv2p4YctX45Fwed1nQ2HC1oC9BnD
 QuizGenerator/premade_questions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 QuizGenerator/premade_questions/basic.py,sha256=wAvVZED6a7VToIvSCdAx6SrExmR0xVRo5dL40kycdXI,3402
 QuizGenerator/premade_questions/cst334/__init__.py,sha256=BTz-Os1XbwIRKqAilf2UIva2NlY0DbA_XbSIggO2Tdk,36
-QuizGenerator/premade_questions/cst334/languages.py,sha256=N5vcmZi-AFM_BZypnvNogHD7s--28-j-8tykYg6CBzs,14388
+QuizGenerator/premade_questions/cst334/languages.py,sha256=MTqprY8VUWgNlP0zRRpZXOAP2dd6ocx_XWVqcNlxYg8,14390
 QuizGenerator/premade_questions/cst334/math_questions.py,sha256=za8lNqhM0RB8qefmPP-Ww0WB_SQn0iRcBKOrZgyHCQQ,9290
 QuizGenerator/premade_questions/cst334/memory_questions.py,sha256=B4hpnMliJY-x65hNbjwbf22m-jiTi3WEXmauKv_YA84,51598
 QuizGenerator/premade_questions/cst334/ostep13_vsfs.py,sha256=d9jjrynEw44vupAH_wKl57UoHooCNEJXaC5DoNYualk,16163
-QuizGenerator/premade_questions/cst334/persistence_questions.py,sha256=em-HzFRnaroDmHl5uA771HyFMI7dMvG-gxTgsB3ecaY,14458
+QuizGenerator/premade_questions/cst334/persistence_questions.py,sha256=hIOi-_K-0B_owWtV_YnXXW8Bb51uQF_lpVcXQkAlbXc,16520
 QuizGenerator/premade_questions/cst334/process.py,sha256=EB0iuT9Q8FfOnmlQoXL7gkfsPyVJP55cRFOe2mWfamc,23647
 QuizGenerator/premade_questions/cst463/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 QuizGenerator/premade_questions/cst463/gradient_descent/__init__.py,sha256=sH2CUV6zK9FT3jWTn453ys6_JTrUKRtZnU8hK6RmImU,240
@@ -35,17 +36,17 @@ QuizGenerator/premade_questions/cst463/math_and_data/matrix_questions.py,sha256=
 QuizGenerator/premade_questions/cst463/math_and_data/vector_questions.py,sha256=tNxfR6J1cZHsHG9GfwVyl6lxxN_TEnhKDmMq4aVLwow,20793
 QuizGenerator/premade_questions/cst463/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 QuizGenerator/premade_questions/cst463/models/attention.py,sha256=i8h6DihzJTc_QFrdm1eaYhnuhlXKRUv_vIDg3jk_LZ8,5502
-QuizGenerator/premade_questions/cst463/models/cnns.py,sha256=iNuQmHgd8kwAXaofTwidal6pZum31r21UP3XERspE0M,5774
+QuizGenerator/premade_questions/cst463/models/cnns.py,sha256=M0_9wlPhQICje1UdwIbDoBA4qzjmJtmP9VVVneYM5Mc,5766
 QuizGenerator/premade_questions/cst463/models/matrices.py,sha256=H61_8cF1DGCt4Z4Ssoi4SMClf6tD5wHkOqY5bMdsSt4,699
 QuizGenerator/premade_questions/cst463/models/rnns.py,sha256=-tXeGgqPkctBBUy4RvEPqhv2kfPqoyO2wk-lNJLNWmY,6697
-QuizGenerator/premade_questions/cst463/models/text.py,sha256=T1cmaoxNcWK1UbytFQmweL_Nmkm5ONq1m6F4AIJdmdc,6284
-QuizGenerator/premade_questions/cst463/models/weight_counting.py,sha256=A2ZVyodfibAWQg9-KraT1cCPTLXRWy5vNSqL0GWexXg,6784
+QuizGenerator/premade_questions/cst463/models/text.py,sha256=bUiDIzOBEzilUKQjm2yO9ufcvJGY6Gt3qfeNP9UZOrc,6400
+QuizGenerator/premade_questions/cst463/models/weight_counting.py,sha256=acygK-MobvdmwS4UYKVVL4Ey59M1qmq8dITWOT6V-aI,6793
 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=pyTSvibCaLuT0LnYAZfjUoZlzywaPWWAaSZ5VepH04E,44148
 QuizGenerator/premade_questions/cst463/tensorflow-intro/__init__.py,sha256=G1gEHtG4KakYgi8ZXSYYhX6bQRtnm2tZVGx36d63Nmo,173
 QuizGenerator/premade_questions/cst463/tensorflow-intro/tensorflow_questions.py,sha256=dPn8Sj0yk4m02np62esMKZ7CvcljhYq3Tq51nY9aJnA,29781
-quizgenerator-0.3.0.dist-info/METADATA,sha256=qLE6mR5zXwWdFv5HYskA4KLgnya7VVRh85a7AY8lDRg,7212
-quizgenerator-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-quizgenerator-0.3.0.dist-info/entry_points.txt,sha256=iViWMzswXGe88WKoue_Ib-ODUSiT_j_6f1us28w9pkc,56
-quizgenerator-0.3.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-quizgenerator-0.3.0.dist-info/RECORD,,
+quizgenerator-0.4.1.dist-info/METADATA,sha256=Yo9okMZOhafNPqYyPT9V-wovJs8YcSvxeTXCr3U7ILs,7212
+quizgenerator-0.4.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+quizgenerator-0.4.1.dist-info/entry_points.txt,sha256=aOIdRdw26xY8HkxOoKHBnUPe2mwGv5Ti3U1zojb6zxQ,98
+quizgenerator-0.4.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+quizgenerator-0.4.1.dist-info/RECORD,,

{quizgenerator-0.3.0.dist-info → quizgenerator-0.4.1.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 quizgen = QuizGenerator.generate:main
+quizregen = QuizGenerator.regenerate:main