QuizGenerator 0.5.0__tar.gz → 0.5.1__tar.gz

{quizgenerator-0.5.0 → quizgenerator-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuizGenerator
-Version: 0.5.0
+Version: 0.5.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.5.0 → quizgenerator-0.5.1}/QuizGenerator/contentast.py

@@ -17,6 +17,9 @@ from QuizGenerator.qrcode_generator import QuestionQRCode
 import re
 
 import logging
+import os
+import uuid
+
 log = logging.getLogger(__name__)
 
 class ContentAST:
@@ -1389,8 +1392,6 @@ class ContentAST:
     def _ensure_image_saved(self):
       """Save image data to file if not already saved."""
       if self.path is None:
-        import os
-        import uuid
 
         # Create imgs directory if it doesn't exist (use absolute path)
         img_dir = os.path.abspath("imgs")

{quizgenerator-0.5.0 → quizgenerator-0.5.1}/QuizGenerator/generate.py

@@ -42,8 +42,7 @@ def parse_args():
   
   # PDF Flags
   parser.add_argument("--num_pdfs", default=0, type=int, help="How many PDF quizzes to create")
-  parser.add_argument("--typst", action="store_true",
-                     help="Use Typst instead of LaTeX for PDF generation")
+  parser.add_argument("--latex", action="store_false", dest="typst", help="Use Typst instead of LaTeX for PDF generation")
 
   subparsers = parser.add_subparsers(dest='command')
   test_parser = subparsers.add_parser("TEST")

{quizgenerator-0.5.0 → quizgenerator-0.5.1}/QuizGenerator/premade_questions/cst334/process.py

@@ -7,9 +7,7 @@ import dataclasses
 import enum
 import io
 import logging
-import math
 import os
-import queue
 import uuid
 from typing import List
 
@@ -65,6 +63,8 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
   TIME_QUANTUM = None
   
   ROUNDING_DIGITS = 2
+  IMAGE_DPI = 140
+  IMAGE_FIGSIZE = (9.5, 5.5)
   
   @dataclasses.dataclass
   class Job:
@@ -552,7 +552,7 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
   
   def make_image(self):
     
-    fig, ax = plt.subplots(1, 1)
+    fig, ax = plt.subplots(1, 1, figsize=self.IMAGE_FIGSIZE, dpi=self.IMAGE_DPI)
     
     for x_loc in set([t for job_id in self.job_stats.keys() for t in self.job_stats[job_id]["state_changes"] ]):
       ax.axvline(x_loc, zorder=0)
@@ -610,7 +610,8 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
     
     # Save to BytesIO object instead of a file
     buffer = io.BytesIO()
-    plt.savefig(buffer, format='png')
+    plt.tight_layout()
+    plt.savefig(buffer, format='png', dpi=self.IMAGE_DPI, bbox_inches='tight', pad_inches=0.2)
     plt.close(fig)
     
     # Reset buffer position to the beginning
@@ -630,50 +631,508 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
     return image_path
     
 
-class MLFQ_Question(ProcessQuestion):
-  
-  MIN_DURATION = 10
-  MAX_DURATION = 100
+@QuestionRegistry.register()
+class MLFQQuestion(ProcessQuestion, TableQuestionMixin, BodyTemplatesMixin):
+  MIN_DURATION = 4
+  MAX_DURATION = 12
   MIN_ARRIVAL = 0
-  MAX_ARRIVAL = 100
-  
+  MAX_ARRIVAL = 10
+  DEFAULT_NUM_JOBS = 3
+  DEFAULT_NUM_QUEUES = 3
+  ROUNDING_DIGITS = 2
+  IMAGE_DPI = 140
+  IMAGE_FIGSIZE = (9.5, 6.5)
+
   @dataclasses.dataclass
-  class Job():
-    arrival_time: float
-    duration: float
-    elapsed_time: float = 0.0
-    response_time: float = None
-    turnaround_time: float = None
-    
-    def run_for_slice(self, slice_duration):
-      self.elapsed_time += slice_duration
-    
-    def is_complete(self):
-      return math.isclose(self.duration, self.elapsed_time)
-  
+  class Job:
+    job_id: int
+    arrival_time: int
+    duration: int
+    remaining_time: int
+    queue_level: int = 0
+    time_in_queue: int = 0
+    response_time: float | None = None
+    turnaround_time: float | None = None
+    remaining_quantum: int | None = None
+    run_intervals: List[tuple] = dataclasses.field(default_factory=list)
+    max_queue_level: int = 0
+
+  def __init__(
+    self,
+    num_jobs: int = DEFAULT_NUM_JOBS,
+    num_queues: int = DEFAULT_NUM_QUEUES,
+    min_job_length: int = MIN_DURATION,
+    max_job_length: int = MAX_DURATION,
+    boost_interval: int | None = None,
+    boost_interval_range: List[int] | None = None,
+    *args,
+    **kwargs
+  ):
+    kwargs["num_jobs"] = num_jobs
+    kwargs["num_queues"] = num_queues
+    kwargs["min_job_length"] = min_job_length
+    kwargs["max_job_length"] = max_job_length
+    if boost_interval is not None:
+      kwargs["boost_interval"] = boost_interval
+    if boost_interval_range is not None:
+      kwargs["boost_interval_range"] = boost_interval_range
+    super().__init__(*args, **kwargs)
+    self.num_jobs = num_jobs
+    self.num_queues = num_queues
+    self.min_job_length = min_job_length
+    self.max_job_length = max_job_length
+    self.boost_interval = boost_interval
+    self.boost_interval_range = boost_interval_range
+
+  def get_workload(self, num_jobs: int) -> List[MLFQQuestion.Job]:
+    arrivals = [0]
+    if num_jobs > 1:
+      arrivals.extend(
+        self.rng.randint(self.MIN_ARRIVAL, self.MAX_ARRIVAL)
+        for _ in range(num_jobs - 1)
+      )
+      if max(arrivals) == 0:
+        arrivals[-1] = self.rng.randint(1, self.MAX_ARRIVAL)
+
+    durations = [
+      self.rng.randint(self.min_job_length, self.max_job_length)
+      for _ in range(num_jobs)
+    ]
+
+    jobs = []
+    for i in range(num_jobs):
+      jobs.append(
+        MLFQQuestion.Job(
+          job_id=i,
+          arrival_time=arrivals[i],
+          duration=durations[i],
+          remaining_time=durations[i],
+        )
+      )
+    return jobs
+
+  def _normalize_queue_params(self, values: List[int] | None, num_queues: int) -> List[int]:
+    if values is None:
+      return []
+    values = list(values)
+    while len(values) < num_queues:
+      values.append(values[-1])
+    return values[:num_queues]
+
+  def run_simulation(
+    self,
+    jobs: List[MLFQQuestion.Job],
+    queue_quantums: List[int],
+    queue_allotments: List[int | None],
+    boost_interval: int | None,
+  ) -> None:
+    self.timeline = collections.defaultdict(list)
+    self.boost_times = []
+    pending = sorted(jobs, key=lambda j: (j.arrival_time, j.job_id))
+    queues = [collections.deque() for _ in range(len(queue_quantums))]
+    completed = set()
+
+    curr_time = pending[0].arrival_time if pending else 0
+    self.timeline[curr_time].append("Simulation Start")
+    next_boost_time = None
+    if boost_interval is not None:
+      next_boost_time = boost_interval
+
+    def enqueue_arrivals(up_to_time: int) -> None:
+      nonlocal pending
+      while pending and pending[0].arrival_time <= up_to_time:
+        job = pending.pop(0)
+        job.queue_level = len(queues) - 1
+        job.time_in_queue = 0
+        job.remaining_quantum = None
+        queues[-1].append(job)
+        self.timeline[job.arrival_time].append(
+          f"Job{job.job_id} arrived (dur = {job.duration})"
+        )
+
+    def apply_boost(curr_time: int, running_job: MLFQQuestion.Job | None = None) -> None:
+      jobs_to_boost = []
+      for q in queues:
+        while q:
+          jobs_to_boost.append(q.popleft())
+      if running_job is not None and running_job.remaining_time > 0:
+        jobs_to_boost.append(running_job)
+      if not jobs_to_boost:
+        self.boost_times.append(curr_time)
+        return
+      for job in sorted(jobs_to_boost, key=lambda j: j.job_id):
+        job.queue_level = len(queues) - 1
+        job.time_in_queue = 0
+        job.remaining_quantum = None
+        queues[-1].append(job)
+      self.timeline[curr_time].append(
+        f"Boosted all jobs to Q{len(queues) - 1}"
+      )
+      self.boost_times.append(curr_time)
+
+    enqueue_arrivals(curr_time)
+
+    while len(completed) < len(jobs):
+      q_idx = next(
+        (i for i in range(len(queues) - 1, -1, -1) if queues[i]),
+        None
+      )
+      if q_idx is None:
+        next_times = []
+        if pending:
+          next_times.append(pending[0].arrival_time)
+        if next_boost_time is not None:
+          next_times.append(next_boost_time)
+        if next_times:
+          next_time = min(next_times)
+          if next_time > curr_time:
+            self.timeline[curr_time].append("CPU idle")
+          curr_time = next_time
+          enqueue_arrivals(curr_time)
+          while next_boost_time is not None and curr_time >= next_boost_time:
+            apply_boost(curr_time)
+            next_boost_time += boost_interval
+          continue
+        break
+
+      job = queues[q_idx].popleft()
+      quantum = queue_quantums[q_idx]
+      if job.remaining_quantum is None or job.remaining_quantum <= 0:
+        job.remaining_quantum = quantum
+
+      slice_duration = min(job.remaining_quantum, job.remaining_time)
+      preempted = False
+      if q_idx < len(queues) - 1 and pending:
+        next_arrival = pending[0].arrival_time
+        if next_arrival < curr_time + slice_duration:
+          slice_duration = next_arrival - curr_time
+          preempted = True
+      if next_boost_time is not None and next_boost_time < curr_time + slice_duration:
+        slice_duration = next_boost_time - curr_time
+        preempted = True
+
+      if job.response_time is None:
+        job.response_time = curr_time - job.arrival_time
+
+      if slice_duration > 0:
+        self.timeline[curr_time].append(
+          f"Running Job{job.job_id} in Q{q_idx} for {slice_duration}"
+        )
+        job.run_intervals.append((curr_time, curr_time + slice_duration, q_idx))
+        curr_time += slice_duration
+        job.remaining_time -= slice_duration
+        job.time_in_queue += slice_duration
+        job.remaining_quantum -= slice_duration
+
+      enqueue_arrivals(curr_time)
+      boosted_current_job = False
+      while next_boost_time is not None and curr_time >= next_boost_time:
+        apply_boost(curr_time, running_job=job if not boosted_current_job else None)
+        boosted_current_job = True
+        next_boost_time += boost_interval
+
+      if job.remaining_time <= 0:
+        job.turnaround_time = curr_time - job.arrival_time
+        job.remaining_quantum = None
+        completed.add(job.job_id)
+        self.timeline[curr_time].append(
+          f"Completed Job{job.job_id} (TAT = {job.turnaround_time})"
+        )
+        continue
+      if boosted_current_job:
+        continue
+
+      allotment = queue_allotments[q_idx]
+      if (
+        allotment is not None
+        and job.time_in_queue >= allotment
+        and q_idx > 0
+      ):
+        job.queue_level = q_idx - 1
+        job.max_queue_level = max(job.max_queue_level, job.queue_level)
+        job.time_in_queue = 0
+        job.remaining_quantum = None
+        queues[q_idx - 1].append(job)
+        self.timeline[curr_time].append(
+          f"Demoted Job{job.job_id} to Q{q_idx - 1}"
+        )
+        continue
+
+      if preempted and job.remaining_quantum > 0:
+        queues[q_idx].appendleft(job)
+      else:
+        if job.remaining_quantum <= 0:
+          job.remaining_quantum = None
+        queues[q_idx].append(job)
+
   def refresh(self, *args, **kwargs):
     super().refresh(*args, **kwargs)
-    
-    # Set up defaults
-    # todo: allow for per-queue specification of durations, likely through dicts
-    num_queues = kwargs.get("num_queues", 2)
-    num_jobs = kwargs.get("num_jobs", 2)
-    
-    # Set up queues that we will be using
-    mlfq_queues = {
-      priority : queue.Queue()
-      for priority in range(num_queues)
+
+    self.num_jobs = kwargs.get("num_jobs", self.num_jobs)
+    self.num_queues = kwargs.get("num_queues", self.num_queues)
+    self.min_job_length = kwargs.get("min_job_length", self.min_job_length)
+    self.max_job_length = kwargs.get("max_job_length", self.max_job_length)
+    self.boost_interval = kwargs.get("boost_interval", self.boost_interval)
+    self.boost_interval_range = kwargs.get(
+      "boost_interval_range",
+      self.boost_interval_range
+    )
+    if self.boost_interval is None and self.boost_interval_range:
+      low, high = self.boost_interval_range
+      self.boost_interval = self.rng.randint(low, high)
+
+    jobs = self.get_workload(self.num_jobs)
+
+    queue_quantums = [2**(self.num_queues - 1 - i) for i in range(self.num_queues)]
+    queue_quantums = self._normalize_queue_params(queue_quantums, self.num_queues)
+    queue_quantums = [int(q) for q in queue_quantums]
+
+    queue_allotments = [None] + [
+      queue_quantums[i] * 2 for i in range(1, self.num_queues)
+    ]
+    queue_allotments = self._normalize_queue_params(queue_allotments, self.num_queues)
+    queue_allotments = [
+      int(allotment) if allotment is not None else None
+      for allotment in queue_allotments
+    ]
+    queue_allotments[0] = None
+
+    self.queue_quantums = queue_quantums
+    self.queue_allotments = queue_allotments
+
+    self.run_simulation(jobs, queue_quantums, queue_allotments, self.boost_interval)
+
+    self.job_stats = {
+      job.job_id: {
+        "arrival_time": job.arrival_time,
+        "duration": job.duration,
+        "Response": job.response_time,
+        "TAT": job.turnaround_time,
+        "run_intervals": list(job.run_intervals),
+      }
+      for job in jobs
     }
-    
-    # Set up jobs that we'll be using
-    jobs = [
-      MLFQ_Question.Job(
-        arrival_time=self.rng.randint(self.MIN_ARRIVAL, self.MAX_ARRIVAL),
-        duration=self.rng.randint(self.MIN_DURATION, self.MAX_DURATION),
-        
+
+    for job_id in sorted(self.job_stats.keys()):
+      self.answers.update({
+        f"answer__turnaround_time_job{job_id}": Answer.auto_float(
+          f"answer__turnaround_time_job{job_id}",
+          self.job_stats[job_id]["TAT"]
+        )
+      })
+
+    return self.is_interesting()
+
+  def _get_body(self, *args, **kwargs):
+    answers: List[Answer] = []
+
+    queue_rows = []
+    for i in reversed(range(self.num_queues)):
+      allotment = self.queue_allotments[i]
+      queue_rows.append([
+        f"Q{i}",
+        self.queue_quantums[i],
+        "infinite" if allotment is None else allotment
+      ])
+    queue_table = ContentAST.Table(
+      headers=["Queue", "Quantum", "Allotment"],
+      data=queue_rows
+    )
+
+    table_rows = []
+    for job_id in sorted(self.job_stats.keys()):
+      table_rows.append({
+        "Job ID": f"Job{job_id}",
+        "Arrival": self.job_stats[job_id]["arrival_time"],
+        "Duration": self.job_stats[job_id]["duration"],
+        "TAT": f"answer__turnaround_time_job{job_id}",
+      })
+      answers.append(self.answers[f"answer__turnaround_time_job{job_id}"])
+
+    scheduling_table = self.create_answer_table(
+      headers=["Job ID", "Arrival", "Duration", "TAT"],
+      data_rows=table_rows,
+      answer_columns=["TAT"]
+    )
+
+    intro_text = (
+      "Assume an MLFQ scheduler with round-robin inside each queue. "
+      f"New jobs enter the highest-priority queue (Q{self.num_queues - 1}) "
+      "and a job is demoted after using its total allotment for that queue. "
+      "If a higher-priority job arrives, it preempts any lower-priority job."
+    )
+
+    instructions = (
+      f"Compute the turnaround time (TAT) for each job. "
+      f"Round to at most {Answer.DEFAULT_ROUNDING_DIGITS} digits after the decimal."
+    )
+
+    body = ContentAST.Section()
+    body.add_element(ContentAST.Paragraph([intro_text]))
+    body.add_element(queue_table)
+    if self.boost_interval is not None:
+      body.add_element(ContentAST.Paragraph([
+        f"Every {self.boost_interval} time units, all jobs are boosted to "
+        f"Q{self.num_queues - 1}. After a boost, scheduling restarts with the "
+        "lowest job number in that queue."
+      ]))
+    body.add_element(ContentAST.Paragraph([instructions]))
+    body.add_element(scheduling_table)
+    return body, answers
+
+  def get_body(self, *args, **kwargs) -> ContentAST.Section:
+    body, _ = self._get_body(*args, **kwargs)
+    return body
+
+  def _get_explanation(self, **kwargs):
+    explanation = ContentAST.Section()
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "Turnaround time (TAT) is the completion time minus the arrival time.",
+        "We calculate it for each job after simulating the schedule."
+      ])
+    )
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "For each job:"
+      ] + [
+        f"Job{job_id}_TAT = "
+        f"{self.job_stats[job_id]['arrival_time'] + self.job_stats[job_id]['TAT']:0.{self.ROUNDING_DIGITS}f} "
+        f"- {self.job_stats[job_id]['arrival_time']:0.{self.ROUNDING_DIGITS}f} "
+        f"= {self.job_stats[job_id]['TAT']:0.{self.ROUNDING_DIGITS}f}"
+        for job_id in sorted(self.job_stats.keys())
+      ])
+    )
+
+    explanation.add_element(
+      ContentAST.Table(
+        headers=["Time", "Events"],
+        data=[
+          [f"{t:0.{self.ROUNDING_DIGITS}f}s"] + ['\n'.join(events)]
+          for t in sorted(self.timeline.keys())
+          if (events := [
+            event for event in self.timeline[t]
+            if (
+              "arrived" in event
+              or "Demoted" in event
+              or "Boosted" in event
+              or "Completed" in event
+              or "Simulation Start" in event
+              or "CPU idle" in event
+            )
+          ])
+        ]
+      )
+    )
+
+    explanation.add_element(
+      ContentAST.Picture(
+        img_data=self.make_image(),
+        caption="MLFQ Scheduling Overview"
+      )
+    )
+
+    return explanation, []
+
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    explanation, _ = self._get_explanation(**kwargs)
+    return explanation
+
+  def make_image(self):
+    fig, ax = plt.subplots(1, 1, figsize=self.IMAGE_FIGSIZE, dpi=self.IMAGE_DPI)
+
+    num_jobs = len(self.job_stats)
+    if num_jobs == 0:
+      buffer = io.BytesIO()
+      plt.tight_layout()
+      plt.savefig(buffer, format='png', dpi=self.IMAGE_DPI, bbox_inches='tight')
+      plt.close(fig)
+      buffer.seek(0)
+      return buffer
+
+    job_colors = {
+      job_id: str(0.15 + 0.7 * (idx / max(1, num_jobs - 1)))
+      for idx, job_id in enumerate(sorted(self.job_stats.keys()))
+    }
+    job_lane = {
+      job_id: idx
+      for idx, job_id in enumerate(sorted(self.job_stats.keys(), reverse=True))
+    }
+    lanes_per_queue = num_jobs
+
+    for job_id in sorted(self.job_stats.keys()):
+      for start, stop, queue_level in self.job_stats[job_id]["run_intervals"]:
+        y_loc = queue_level * lanes_per_queue + job_lane[job_id]
+        ax.barh(
+          y=[y_loc],
+          left=[start],
+          width=[stop - start],
+          edgecolor='black',
+          linewidth=1.5,
+          color=job_colors[job_id]
+        )
+
+    for queue_idx in range(self.num_queues):
+      if queue_idx % 2 == 1:
+        ax.axhspan(
+          queue_idx * lanes_per_queue - 0.5,
+          (queue_idx + 1) * lanes_per_queue - 0.5,
+          facecolor='0.97',
+          edgecolor='none',
+          zorder=-1
+        )
+
+    arrival_times = sorted({
+      self.job_stats[job_id]["arrival_time"]
+      for job_id in self.job_stats.keys()
+    })
+    bottom_label_y = -0.1
+    for arrival_time in arrival_times:
+      ax.axvline(arrival_time, color='0.2', linestyle=':', linewidth=1.2, zorder=0)
+      ax.text(
+        arrival_time + 0.2,
+        bottom_label_y,
+        f"{arrival_time:0.{self.ROUNDING_DIGITS}f}s",
+        color='0.2',
+        rotation=90,
+        ha='left',
+        va='bottom'
       )
+
+    completion_times = sorted({
+      self.job_stats[job_id]["arrival_time"] + self.job_stats[job_id]["TAT"]
+      for job_id in self.job_stats.keys()
+    })
+    for completion_time in completion_times:
+      ax.axvline(completion_time, color='red', linewidth=1.5, zorder=0)
+      ax.text(
+        completion_time - 0.6,
+        self.num_queues * lanes_per_queue - 0.5,
+        f"{completion_time:0.{self.ROUNDING_DIGITS}f}s",
+        color='red',
+        rotation=90,
+        ha='center',
+        va='top'
+      )
+
+    for boost_time in sorted(set(self.boost_times)):
+      ax.axvline(boost_time, color='tab:blue', linestyle='--', linewidth=1.2, zorder=0)
+
+    tick_positions = [
+      q * lanes_per_queue + (lanes_per_queue - 1) / 2
+      for q in range(self.num_queues)
     ]
-    
-    curr_time = -1.0
-    while True:
-      pass
+    ax.set_yticks(tick_positions)
+    ax.set_yticklabels([f"Q{i}" for i in range(self.num_queues)])
+    ax.set_ylim(-0.5, self.num_queues * lanes_per_queue - 0.5)
+    ax.set_xlim(xmin=0)
+    ax.set_xlabel("Time")
+
+    buffer = io.BytesIO()
+    plt.tight_layout()
+    plt.savefig(buffer, format='png', dpi=self.IMAGE_DPI, bbox_inches='tight')
+    plt.close(fig)
+    buffer.seek(0)
+    return buffer

{quizgenerator-0.5.0 → quizgenerator-0.5.1}/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", [])))
@@ -515,4 +521,4 @@ def main():
 
 if __name__ == "__main__":
   main()
-  
+  

quizgenerator-0.5.1/pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "QuizGenerator"
+version = "0.5.1"
+description = "Generate randomized quiz questions for Canvas LMS and PDF exams"
+readme = "README.md"
+license = {text = "GPL-3.0-or-later"}
+authors = [
+    {name = "Sam Ogden", email = "samuel.s.ogden@gmail.com"},
+]
+requires-python = ">=3.12"
+
+keywords = ["education", "quiz", "canvas", "lms", "assessment", "teaching", "exam", "testing"]
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Education",
+    "Topic :: Education :: Testing",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+    "Jinja2==3.1.3",
+    "python-dotenv==1.0.1",
+    "PyYAML==6.0.1",
+    "requests==2.32.2",
+    "pypandoc~=1.6.3",
+    "pytablewriter~=1.2.0",
+    "pylatex>=1.4.2",
+    "matplotlib",
+    "sympy>=1.14.0",
+    "markdown>=3.9",
+    "segno>=1.6.0",
+    "cryptography>=41.0.0",
+    "graphviz>=0.21",
+    "canvasapi==3.2.0",
+    "keras>=3.12.0",
+    "tensorflow>=2.20.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/OtterDen-Lab/QuizGenerator"
+Documentation = "https://github.com/OtterDen-Lab/QuizGenerator/tree/main/documentation"
+Repository = "https://github.com/OtterDen-Lab/QuizGenerator"
+"Bug Tracker" = "https://github.com/OtterDen-Lab/QuizGenerator/issues"
+
+[project.scripts]
+quizgen = "QuizGenerator.generate:main"
+quizregen = "QuizGenerator.regenerate:main"
+
+[project.optional-dependencies]
+grading = [
+    "pyzbar>=0.1.9",
+    "pillow>=10.0.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["QuizGenerator"]
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+# Entry point group for custom question types (for plugin developers)
+# Users can register custom question types in their own packages using:
+# [project.entry-points."quizgenerator.questions"]
+# my_custom_question = "my_package.module:MyQuestionClass"
+#
+# Example:
+# [project.entry-points."quizgenerator.questions"]
+# advanced_scheduling = "university_questions.os:AdvancedSchedulingQuestion"
+# memory_hierarchy = "university_questions.os:MemoryHierarchyQuestion"

{quizgenerator-0.5.0 → quizgenerator-0.5.1}/uv.lock

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