QuizGenerator 0.4.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

QuizGenerator/question.py

@@ -21,14 +21,21 @@ import yaml
 from typing import List, Dict, Any, Tuple, Optional
 import canvasapi.course, canvasapi.quiz
 
-from QuizGenerator.misc import Answer
-from QuizGenerator.contentast import ContentAST
+from QuizGenerator.contentast import ContentAST, AnswerTypes
 from QuizGenerator.performance import timer, PerformanceTracker
 
 import logging
 log = logging.getLogger(__name__)
 
 
+@dataclasses.dataclass
+class QuestionComponents:
+    """Bundle of question parts generated during construction."""
+    body: ContentAST.Element
+    answers: List[ContentAST.Answer]
+    explanation: ContentAST.Element
+
+
 # Spacing presets for questions
 SPACING_PRESETS = {
     "NONE": 0,
@@ -344,25 +351,31 @@ class Question(abc.ABC):
   ensures consistent rendering across PDF/LaTeX and Canvas/HTML formats.
 
   Required Methods:
-    - get_body(): Return ContentAST.Section with question content
-    - get_explanation(): Return ContentAST.Section with solution steps
+    - _get_body(): Return Tuple[ContentAST.Section, List[ContentAST.Answer]] with body and answers
+    - _get_explanation(): Return Tuple[ContentAST.Section, List[ContentAST.Answer]] with explanation
+
+  Note: get_body() and get_explanation() are provided for backward compatibility
+  and call the _get_* methods, returning just the first element of the tuple.
 
   Required Class Attributes:
     - VERSION (str): Question version number (e.g., "1.0")
       Increment when RNG logic changes to ensure reproducibility
 
   ContentAST Usage Examples:
-    def get_body(self):
+    def _get_body(self):
         body = ContentAST.Section()
+        answers = []
         body.add_element(ContentAST.Paragraph(["Calculate the matrix:"]))
 
         # Use ContentAST.Matrix for math, NOT manual LaTeX
         matrix_data = [[1, 2], [3, 4]]
         body.add_element(ContentAST.Matrix(data=matrix_data, bracket_type="b"))
 
-        # Use ContentAST.Answer for input fields
-        body.add_element(ContentAST.Answer(answer=self.answers["result"]))
-        return body
+        # Answer extends ContentAST.Leaf - add directly to body
+        ans = ContentAST.Answer.integer("result", 42, label="Result")
+        answers.append(ans)
+        body.add_element(ans)
+        return body, answers
 
   Common ContentAST Elements:
     - ContentAST.Paragraph: Text blocks
@@ -460,7 +473,7 @@ class Question(abc.ABC):
     self.points_value = points_value
     self.topic = topic
     self.spacing = parse_spacing(kwargs.get("spacing", 0))
-    self.answer_kind = Answer.AnswerKind.BLANK
+    self.answer_kind = ContentAST.Answer.CanvasAnswerKind.BLANK
 
     # Support for multi-part questions (defaults to 1 for normal questions)
     self.num_subquestions = kwargs.get("num_subquestions", 1)
@@ -472,6 +485,9 @@ class Question(abc.ABC):
 
     self.rng_seed_offset = kwargs.get("rng_seed_offset", 0)
 
+    # Component caching for unified Answer architecture
+    self._components: QuestionComponents = None
+
     # To be used throughout when generating random things
     self.rng = random.Random()
 
@@ -569,28 +585,105 @@ class Question(abc.ABC):
   
   def get_explanation(self, **kwargs) -> ContentAST.Section:
     """
-    Gets the body of the question during generation
+    Gets the body of the question during generation (backward compatible wrapper).
+    Calls _get_explanation() and returns just the explanation.
     :param kwargs:
     :return: (ContentAST.Section) Containing question explanation or None
     """
+    # Try new pattern first
+    if hasattr(self, '_get_explanation') and callable(getattr(self, '_get_explanation')):
+      explanation, _ = self._get_explanation()
+      return explanation
+    # Fallback: default explanation
     return ContentAST.Section(
       [ContentAST.Text("[Please reach out to your professor for clarification]")]
     )
-  
-  def get_answers(self, *args, **kwargs) -> Tuple[Answer.AnswerKind, List[Dict[str,Any]]]:
-    if self.can_be_numerical():
+
+  def _get_body(self) -> Tuple[ContentAST.Element, List[ContentAST.Answer]]:
+    """
+    Build question body and collect answers (new pattern).
+    Questions should override this to return (body, answers) tuple.
+
+    Returns:
+        Tuple of (body_ast, answers_list)
+    """
+    # Fallback: call old get_body() and return empty answers
+    body = self.get_body()
+    return body, []
+
+  def _get_explanation(self) -> Tuple[ContentAST.Element, List[ContentAST.Answer]]:
+    """
+    Build question explanation and collect answers (new pattern).
+    Questions can override this to include answers in explanations.
+
+    Returns:
+        Tuple of (explanation_ast, answers_list)
+    """
+    return ContentAST.Section(
+      [ContentAST.Text("[Please reach out to your professor for clarification]")]
+    ), []
+
+  def build_question_components(self, **kwargs) -> QuestionComponents:
+    """
+    Build question components (body, answers, explanation) in single pass.
+
+    Calls _get_body() and _get_explanation() which return tuples of
+    (content, answers).
+    """
+    # Build body with its answers
+    body, body_answers = self._get_body()
+
+    # Build explanation with its answers
+    explanation, explanation_answers = self._get_explanation()
+
+    # Combine all answers
+    all_answers = body_answers + explanation_answers
+
+    return QuestionComponents(
+      body=body,
+      answers=all_answers,
+      explanation=explanation
+    )
+
+  def get_answers(self, *args, **kwargs) -> Tuple[ContentAST.Answer.CanvasAnswerKind, List[Dict[str,Any]]]:
+    """
+    Return answers from cached components (new pattern) or self.answers dict (old pattern).
+    """
+    # Try component-based approach first (new pattern)
+    if self._components is None:
+      try:
+        self._components = self.build_question_components()
+      except Exception as e:
+        # If component building fails, fall back to dict
+        log.debug(f"Failed to build question components: {e}, falling back to dict")
+        pass
+
+    # Use components if available and non-empty
+    if self._components is not None and len(self._components.answers) > 0:
+      answers = self._components.answers
+      if self.can_be_numerical():
+        return (
+          ContentAST.Answer.CanvasAnswerKind.NUMERICAL_QUESTION,
+          list(itertools.chain(*[a.get_for_canvas(single_answer=True) for a in answers]))
+        )
       return (
-        Answer.AnswerKind.NUMERICAL_QUESTION,
-        list(itertools.chain(*[a.get_for_canvas(single_answer=True) for a in self.answers.values()]))
+        self.answer_kind,
+        list(itertools.chain(*[a.get_for_canvas() for a in answers]))
       )
-    elif len(self.answers.values()) > 0:
+
+    # Fall back to dict pattern (old pattern)
+    if len(self.answers.values()) > 0:
+      if self.can_be_numerical():
+        return (
+          ContentAST.Answer.CanvasAnswerKind.NUMERICAL_QUESTION,
+          list(itertools.chain(*[a.get_for_canvas(single_answer=True) for a in self.answers.values()]))
+        )
       return (
         self.answer_kind,
         list(itertools.chain(*[a.get_for_canvas() for a in self.answers.values()]))
       )
-    return (
-      Answer.AnswerKind.ESSAY, []
-    )
+
+    return (ContentAST.Answer.CanvasAnswerKind.ESSAY, [])
     
   def refresh(self, rng_seed=None, *args, **kwargs):
     """If it is necessary to regenerate aspects between usages, this is the time to do it.
@@ -601,6 +694,7 @@ class Question(abc.ABC):
     :return: bool - True if the generated question is interesting, False otherwise
     """
     self.answers = {}
+    self._components = None  # Clear component cache
     # Seed the RNG directly with the provided seed (no offset)
     self.rng.seed(rng_seed)
     # Note: We don't call is_interesting() here because child classes need to
@@ -656,7 +750,7 @@ class Question(abc.ABC):
   
   def can_be_numerical(self):
     if (len(self.answers.values()) == 1
-          and list(self.answers.values())[0].variable_kind in [Answer.VariableKind.FLOAT, Answer.VariableKind.AUTOFLOAT]
+          and isinstance(list(self.answers.values())[0], AnswerTypes.Float)
     ):
       return True
     return False

QuizGenerator/quiz.py

@@ -11,6 +11,7 @@ import subprocess
 import tempfile
 from datetime import datetime
 from typing import List, Dict, Optional
+import re
 
 import yaml
 
@@ -87,6 +88,11 @@ class Quiz:
 
       # Get general quiz information from the dictionary
       name = exam_dict.get("name", f"Unnamed Exam ({datetime.now().strftime('%a %b %d %I:%M %p')})")
+      if isinstance(name, str):
+        def replace_time(match: re.Match) -> str:
+          fmt = match.group(1) or "%b %d %I:%M%p"
+          return datetime.now().strftime(fmt)
+        name = re.sub(r"\$TIME(?:\{([^}]+)\})?", replace_time, name)
       practice = exam_dict.get("practice", False)
       description = exam_dict.get("description", None)
       sort_order = list(map(lambda t: Question.Topic.from_string(t), exam_dict.get("sort order", [])))
@@ -275,10 +281,29 @@ class Quiz:
 
     # For each point group, estimate heights and apply bin-packing optimization
     optimized_questions = []
-    is_first_page = True  # Track if we're packing the first page
+    is_first_bin_overall = True  # Track if we're packing the very first bin of the entire exam
 
     log.debug("Optimizing question order for PDF layout...")
 
+    def get_spacing_priority(question):
+      """
+      Get placement priority based on spacing. Lower values = higher priority.
+      Order: LONG (9), MEDIUM (6), SHORT (4), NONE (0), then PAGE (99), EXTRA_PAGE (199)
+      """
+      spacing = question.spacing
+      if spacing >= 199:  # EXTRA_PAGE
+        return 5
+      elif spacing >= 99:  # PAGE
+        return 4
+      elif spacing >= 9:  # LONG
+        return 0
+      elif spacing >= 6:  # MEDIUM
+        return 1
+      elif spacing >= 4:  # SHORT
+        return 2
+      else:  # NONE or custom small values
+        return 3
+
     for points in sorted(point_groups.keys(), reverse=True):
       group = point_groups[points]
 
@@ -288,27 +313,30 @@ class Quiz:
         group.sort(key=lambda q: self.question_sort_order.index(q.topic))
         optimized_questions.extend(group)
         log.debug(f"  {points}pt questions: {len(group)} questions (order preserved by config)")
-        # After adding preserved-order questions, we're likely past the first page
-        is_first_page = False
+        # After adding preserved-order questions, we're no longer on the first bin
+        is_first_bin_overall = False
         continue
 
       # If only 1-2 questions, no optimization needed
       if len(group) <= 2:
-        # Still sort by topic for consistency
-        group.sort(key=lambda q: self.question_sort_order.index(q.topic))
+        # Sort by spacing priority first, then topic
+        group.sort(key=lambda q: (get_spacing_priority(q), self.question_sort_order.index(q.topic)))
         optimized_questions.extend(group)
         log.debug(f"  {points}pt questions: {len(group)} questions (no optimization needed)")
-        is_first_page = False
+        is_first_bin_overall = False
         continue
 
-      # Estimate height for each question
-      question_heights = [(q, self._estimate_question_height(q, **kwargs)) for q in group]
+      # Estimate height for each question, preserving original index for stable sorting
+      question_heights = [(i, q, self._estimate_question_height(q, **kwargs)) for i, q in enumerate(group)]
 
-      # Sort by height descending to identify large and small questions
-      question_heights.sort(key=lambda x: x[1], reverse=True)
+      # Sort by:
+      # 1. Spacing priority (LONG, MEDIUM, SHORT, NONE, then PAGE, EXTRA_PAGE)
+      # 2. Height descending (within same spacing category)
+      # 3. Original index (for deterministic ordering)
+      question_heights.sort(key=lambda x: (get_spacing_priority(x[1]), -x[2], x[0]))
 
       log.debug(f"  Question heights for {points}pt questions:")
-      for q, h in question_heights:
+      for idx, q, h in question_heights:
         log.debug(f"    {q.name}: {h:.1f}cm (spacing={q.spacing}cm)")
 
       # Calculate page capacity in centimeters
@@ -317,7 +345,7 @@ class Quiz:
       base_page_capacity = 22.0  # cm
 
       # First page has header (title + name line) which takes ~3cm
-      first_page_capacity = base_page_capacity - 3.0 if is_first_page else base_page_capacity
+      first_page_capacity = base_page_capacity - 3.0  # cm
 
       # Better bin-packing strategy: interleave large and small questions
       # Strategy: Start each page with the largest unplaced question, then fill with smaller ones
@@ -326,21 +354,48 @@ class Quiz:
 
       while not all(placed):
         # Determine capacity for this page
-        page_capacity = first_page_capacity if len(bins) == 0 and is_first_page else base_page_capacity
+        # Use first_page_capacity only for the very first bin of the entire exam
+        page_capacity = first_page_capacity if (len(bins) == 0 and is_first_bin_overall) else base_page_capacity
 
         # Find the largest unplaced question to start a new page
         new_page = []
         page_height = 0
 
-        for i, (question, height) in enumerate(question_heights):
-          if not placed[i]:
-            new_page.append(question)
-            page_height = height
-            placed[i] = True
-            break
+        # Special handling for first bin of entire exam: avoid questions with PAGE spacing (99+cm)
+        # to prevent them from pushing content to page 2
+        if len(bins) == 0 and is_first_bin_overall:
+          # Try to find a question without PAGE/EXTRA_PAGE spacing for the first page
+          # PAGE=99cm, EXTRA_PAGE=199cm - these need full pages
+          found_non_page_question = False
+          for i, (idx, question, height) in enumerate(question_heights):
+            if not placed[i] and question.spacing < 99:
+              new_page.append(question)
+              page_height = height
+              placed[i] = True
+              found_non_page_question = True
+              log.debug(f"    First bin (page 1): Selected {question.name} with spacing={question.spacing}cm")
+              break
+
+          # If all questions have PAGE spacing, fall back to normal behavior (use largest question)
+          if not found_non_page_question:
+            for i, (idx, question, height) in enumerate(question_heights):
+              if not placed[i]:
+                new_page.append(question)
+                page_height = height
+                placed[i] = True
+                log.debug(f"    First bin (page 1): All questions have PAGE spacing, using {question.name} (spacing={question.spacing}cm)")
+                break
+        else:
+          # Normal behavior for non-first pages
+          for i, (idx, question, height) in enumerate(question_heights):
+            if not placed[i]:
+              new_page.append(question)
+              page_height = height
+              placed[i] = True
+              break
 
         # Now try to fill the remaining space with smaller questions
-        for i, (question, height) in enumerate(question_heights):
+        for i, (idx, question, height) in enumerate(question_heights):
           if not placed[i] and page_height + height <= page_capacity:
             new_page.append(question)
             page_height += height
@@ -348,6 +403,11 @@ class Quiz:
 
         bins.append((new_page, page_height))
 
+        # After creating the first bin, we're no longer on the first page
+        if len(bins) == 1 and is_first_bin_overall:
+          is_first_bin_overall = False
+          log.debug(f"    First bin created, subsequent bins will use normal page capacity")
+
       log.debug(f"  {points}pt questions: {len(group)} questions packed into {len(bins)} pages")
       for i, (page_questions, height) in enumerate(bins):
         log.debug(f"    Page {i+1}: {height:.1f}cm with {len(page_questions)} questions: {[q.name for q in page_questions]}")
@@ -356,9 +416,6 @@ class Quiz:
       for bin_contents, _ in bins:
         optimized_questions.extend(bin_contents)
 
-      # After packing questions, we're no longer on the first page
-      is_first_page = False
-
     return optimized_questions
 
   def get_quiz(self, **kwargs) -> ContentAST.Document:
@@ -464,4 +521,4 @@ def main():
 
 if __name__ == "__main__":
   main()
-  
+  

QuizGenerator/regenerate.py

@@ -13,6 +13,12 @@ CLI Usage:
     # Scan QR codes from a scanned exam page
     python grade_from_qr.py --image exam_page.jpg --all
 
+    # Decode an encrypted string directly
+    python -m QuizGenerator.regenerate --encrypted_str "EzE6JF86CDlf..."
+
+    # Decode with custom point value
+    python -m QuizGenerator.regenerate --encrypted_str "EzE6JF86CDlf..." --points 5.0
+
 API Usage (recommended for web UIs):
     from grade_from_qr import regenerate_from_encrypted
 
@@ -36,9 +42,22 @@ import argparse
 import json
 import sys
 import logging
+import os
 from pathlib import Path
 from typing import Dict, Any, Optional, List
 
+# Load environment variables from .env file
+try:
+  from dotenv import load_dotenv
+  # Try loading from current directory first, then home directory
+  if os.path.exists('.env'):
+    load_dotenv('.env')
+  else:
+    load_dotenv(os.path.join(os.path.expanduser("~"), ".env"))
+except ImportError:
+  # dotenv not available, will use system environment variables only
+  pass
+
 # Quiz generator imports (always available)
 from QuizGenerator.qrcode_generator import QuestionQRCode
 from QuizGenerator.question import QuestionRegistry
@@ -400,6 +419,17 @@ def main():
     type=str,
     help='Path to image file containing QR code(s)'
   )
+  parser.add_argument(
+    '--encrypted_str',
+    type=str,
+    help='Encrypted string from QR code to decode directly'
+  )
+  parser.add_argument(
+    '--points',
+    type=float,
+    default=1.0,
+    help='Point value for the question (default: 1.0, only used with --encrypted_str)'
+  )
   parser.add_argument(
     '--all',
     action='store_true',
@@ -415,44 +445,83 @@ def main():
     action='store_true',
     help='Enable verbose debug logging'
   )
-  
+
   args = parser.parse_args()
-  
+
   if args.verbose:
     logging.getLogger().setLevel(logging.DEBUG)
-  
-  if not args.image:
+
+  # Check for required arguments
+  if not args.image and not args.encrypted_str:
     parser.print_help()
-    print("\nERROR: --image is required")
+    print("\nERROR: Either --image or --encrypted_str 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")
+
+  if args.image and args.encrypted_str:
+    print("ERROR: Cannot use both --image and --encrypted_str at the same time")
     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:
+
+  # Handle direct encrypted string input
+  if args.encrypted_str:
+    try:
+      log.info(f"Decoding encrypted string (points={args.points})")
+      result = regenerate_from_encrypted(args.encrypted_str, args.points)
+
+      # Format result similar to regenerate_question_answer output
+      question_data = {
+        "question_number": "N/A",
+        "points": args.points,
+        "question_type": result["question_type"],
+        "seed": result["seed"],
+        "version": result["version"],
+        "answers": result["answers"],
+        "answer_objects": result["answer_objects"],
+        "answer_key_html": result["answer_key_html"],
+        "explanation_markdown": result.get("explanation_markdown")
+      }
+
+      if "kwargs" in result:
+        question_data["config"] = result["kwargs"]
+
       results.append(question_data)
       display_answer_summary(question_data)
+
+    except Exception as e:
+      log.error(f"Failed to decode encrypted string: {e}")
+      import traceback
+      if args.verbose:
+        log.debug(traceback.format_exc())
+      sys.exit(1)
+
+  # Handle image scanning
+  else:
+    # 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)")
+
+    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:

{quizgenerator-0.4.2.dist-info → quizgenerator-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuizGenerator
-Version: 0.4.2
+Version: 0.6.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

{quizgenerator-0.4.2.dist-info → quizgenerator-0.6.0.dist-info}/RECORD

@@ -1,52 +1,50 @@
-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=nx0-y3LTyInzX9QheweHhA90zNsdtXie7X-ckYu1_rM,68318
-QuizGenerator/generate.py,sha256=o2XezoSE0u-qjxYu1_Ofm9Lpkza7M2Tg47C-ClMcPsE,7197
-QuizGenerator/logging.yaml,sha256=VJCdh26D8e_PNUs4McvvP1ojz9EVjQNifJzfhEk1Mbo,1114
-QuizGenerator/misc.py,sha256=2vEztj-Kt_0Q2OnynJKC4gL_w7l1MqWsBhhIDOuVD1s,18710
-QuizGenerator/mixins.py,sha256=zUKTkswq7aoDZ_nGPUdRuvnza8iH8ZCi6IH2Uw-kCvs,18492
+QuizGenerator/contentast.py,sha256=lK92FlRfKnNU-9AhG8RJbCkpQixo5n7bmwvggyPazpM,93664
+QuizGenerator/generate.py,sha256=bOkR6JhGQE0r4zbRWhC_3Dsj5hOEk6-jzFLcjk-qwKg,14811
+QuizGenerator/misc.py,sha256=wtlrEpmEpoE6vNRmgjNUmuWnRdQKSCYfrqeoTagNaxg,464
+QuizGenerator/mixins.py,sha256=HEhdGdeghqGWoajADTAIdUjkzwDSYl1b65LAkUdV50U,19211
 QuizGenerator/performance.py,sha256=CM3zLarJXN5Hfrl4-6JRBqD03j4BU1B2QW699HAr1Ds,7002
 QuizGenerator/qrcode_generator.py,sha256=S3mzZDk2UiHiw6ipSCpWPMhbKvSRR1P5ordZJUTo6ug,10776
-QuizGenerator/question.py,sha256=pyDQJzqqyEwhnqCl0PqdTNvM7bTPy7m31qdzGfYC0j4,28269
-QuizGenerator/quiz.py,sha256=toPodXea2UYGgAf4jyor3Gz-gtXYN1YUJFJFQ5u70v4,18718
-QuizGenerator/regenerate.py,sha256=EvtFhDUXYaWEBCGJ4RW-zN65qj3cMxWa_Y_Rn44WU6c,14282
+QuizGenerator/question.py,sha256=FjiAJZn3LUBVr7nDazx5G0bASP0uXQTUP0rqphbvyLw,31714
+QuizGenerator/quiz.py,sha256=f2HLrawUlu3ULkNDzcihBWAt-e-49AIPz_l1edMAEQ0,21503
+QuizGenerator/regenerate.py,sha256=Uh4B9aKQvL3zD7PT-uH-GvrcSuUygV1BimvPVuErc-g,16525
 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
 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=wAvVZED6a7VToIvSCdAx6SrExmR0xVRo5dL40kycdXI,3402
+QuizGenerator/premade_questions/basic.py,sha256=vMyCIYU0IJBjQVE-XVzHr9axq_kZL2ka4K1MaqeQwXM,3428
 QuizGenerator/premade_questions/cst334/__init__.py,sha256=BTz-Os1XbwIRKqAilf2UIva2NlY0DbA_XbSIggO2Tdk,36
-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/languages.py,sha256=ENsgpup1uoGIVWEE_puDgLzWicguwdERsm-iiS-sh1E,15129
+QuizGenerator/premade_questions/cst334/math_questions.py,sha256=zwkm3OLOkDZ_fbPF1E12UhdF373aQv9QzjBfV1bfbyU,10242
+QuizGenerator/premade_questions/cst334/memory_questions.py,sha256=PUyXIoyrGImXhucx6KBgoAEYmQCzTSCz0DWUu_xo6Kc,54371
 QuizGenerator/premade_questions/cst334/ostep13_vsfs.py,sha256=d9jjrynEw44vupAH_wKl57UoHooCNEJXaC5DoNYualk,16163
-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/cst334/persistence_questions.py,sha256=pb63H47WlSsHi_nHRVhbwUHeybF2zbWL8vXbwOguAL0,17474
+QuizGenerator/premade_questions/cst334/process.py,sha256=ERAdardtXSwzh3SDrlkVQJr4oO0F9cZtCZZ8dkJRsfw,39865
 QuizGenerator/premade_questions/cst463/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 QuizGenerator/premade_questions/cst463/gradient_descent/__init__.py,sha256=sH2CUV6zK9FT3jWTn453ys6_JTrUKRtZnU8hK6RmImU,240
-QuizGenerator/premade_questions/cst463/gradient_descent/gradient_calculation.py,sha256=ssj6Xkpw6vDiL4qwVOiHUhly3TX50oX4KJtouj7qN6g,12809
-QuizGenerator/premade_questions/cst463/gradient_descent/gradient_descent_questions.py,sha256=VjmNDpV3YgeYKqyYp4wQXZIViZVvC1GcnjVUl7valhU,9724
-QuizGenerator/premade_questions/cst463/gradient_descent/loss_calculations.py,sha256=TnhcD9OBsYgVDdSY5qPrSovnYB6r90wiGcg934czIrY,21500
-QuizGenerator/premade_questions/cst463/gradient_descent/misc.py,sha256=iB3obG6-uXr_yrLVT7L_9j1H54f7oe5Rk9w45yW-lnw,2654
+QuizGenerator/premade_questions/cst463/gradient_descent/gradient_calculation.py,sha256=PdWAJjgsiwYQsxeLlQiVDd3m97RUjUY1KJTJxyrrdRI,13984
+QuizGenerator/premade_questions/cst463/gradient_descent/gradient_descent_questions.py,sha256=yc1wwqgsFh13peGDRJM74TaWmzQrFg-N7cyqIdf7G54,10874
+QuizGenerator/premade_questions/cst463/gradient_descent/loss_calculations.py,sha256=ftaNkwIPuh-wjAYeAj0YvklS3-xjOcQS7HvUkcNRRYY,22257
+QuizGenerator/premade_questions/cst463/gradient_descent/misc.py,sha256=sn70FLK_3LnhYhX7TVKB9oDwZMJybQIMtYLzxn5WZxg,2675
 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=sq27xv7X9aa0axFxomusZRwM-ICj9grbhD_Bv3n3gJg,28947
-QuizGenerator/premade_questions/cst463/math_and_data/vector_questions.py,sha256=tNxfR6J1cZHsHG9GfwVyl6lxxN_TEnhKDmMq4aVLwow,20793
+QuizGenerator/premade_questions/cst463/math_and_data/matrix_questions.py,sha256=oU8Z36-P92TQ9OhJ2XK6ARlyM8I_qvp1guZLYVvU_l8,29116
+QuizGenerator/premade_questions/cst463/math_and_data/vector_questions.py,sha256=3NCgxtU0OxGrnixBOyrGKObf2rOWwXuBv4TWfiC9jxQ,13226
 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=M0_9wlPhQICje1UdwIbDoBA4qzjmJtmP9VVVneYM5Mc,5766
+QuizGenerator/premade_questions/cst463/models/attention.py,sha256=e_iPxGJUAXQ89zk8BXG9r1sGFKOJhBr4UaWaDQV6I7g,6100
+QuizGenerator/premade_questions/cst463/models/cnns.py,sha256=8Z3vP6A-CxRP80C7pb9gWJ2SctDh4X5fy6V5Gzx31Pc,6337
 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=bUiDIzOBEzilUKQjm2yO9ufcvJGY6Gt3qfeNP9UZOrc,6400
-QuizGenerator/premade_questions/cst463/models/weight_counting.py,sha256=acygK-MobvdmwS4UYKVVL4Ey59M1qmq8dITWOT6V-aI,6793
+QuizGenerator/premade_questions/cst463/models/rnns.py,sha256=hHe-7npGmoUpYYVy1gIlyTTBk8ra3Muw0yHxa3FrbS8,7291
+QuizGenerator/premade_questions/cst463/models/text.py,sha256=bwEebpYnHn52yCrzJGCNz8ebWIU03fdedI9JQmQ9I4I,6978
+QuizGenerator/premade_questions/cst463/models/weight_counting.py,sha256=oXyDKQvfLdWE_-cd2CY9m6t3SI_s-SQGXP6zDSoGINI,7273
 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=gd5zI-6gmXUiK8GaCOCq0IlOwDg4YS0NlOdoN9v_flo,44810
+QuizGenerator/premade_questions/cst463/neural-network-basics/neural_network_questions.py,sha256=luWlTfj1UM1yQDQzs_tNzTV67qXhRUBwNt8QrV74XHs,46115
 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.4.2.dist-info/METADATA,sha256=DDpI82uz-oqvKRYLPgF8O6-Cuv6g39So65_I82DBxFk,7212
-quizgenerator-0.4.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-quizgenerator-0.4.2.dist-info/entry_points.txt,sha256=aOIdRdw26xY8HkxOoKHBnUPe2mwGv5Ti3U1zojb6zxQ,98
-quizgenerator-0.4.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-quizgenerator-0.4.2.dist-info/RECORD,,
+QuizGenerator/premade_questions/cst463/tensorflow-intro/tensorflow_questions.py,sha256=8Wo38kTd_n0Oau2ERpvcudB9uJiOVDYYQNeWu9v4Tyo,33516
+quizgenerator-0.6.0.dist-info/METADATA,sha256=F6pWRrq1r55-tR5-lLyLpegiV26GxCeP4X7Y1w_NK8k,7212
+quizgenerator-0.6.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+quizgenerator-0.6.0.dist-info/entry_points.txt,sha256=aOIdRdw26xY8HkxOoKHBnUPe2mwGv5Ti3U1zojb6zxQ,98
+quizgenerator-0.6.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+quizgenerator-0.6.0.dist-info/RECORD,,

QuizGenerator/README.md

@@ -1,5 +0,0 @@
-
-
-## 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)`