QuizGenerator 0.4.2__py3-none-any.whl

QuizGenerator/canvas/classes.py

@@ -0,0 +1,235 @@
+#!env python
+from __future__ import annotations
+
+import enum
+import logging
+import dataclasses
+import functools
+import io
+import os
+import urllib.request
+from typing import Optional, List, Dict
+
+import canvasapi.canvas
+
+log = logging.getLogger(__name__)
+
+
+
+class LMSWrapper():
+  def __init__(self, _inner):
+    self._inner = _inner
+  
+  def __getattr__(self, name):
+    try:
+      # Try to get the attribute from the inner instance
+      return getattr(self._inner, name)
+    except AttributeError:
+      # Handle the case where the inner instance also doesn't have the attribute
+      print(f"Warning: '{name}' not found in either wrapper or inner class")
+      # You can raise the error again, return None, or handle it however you want
+      return lambda *args, **kwargs: None  # Returns a no-op function for method calls
+
+
+@dataclasses.dataclass
+class Student(LMSWrapper):
+  name : str
+  user_id : int
+  _inner : canvasapi.canvas.User
+  
+
+class Submission:
+
+  class Status(enum.Enum):
+    MISSING = "unsubmitted"
+    UNGRADED = ("submitted", "pending_review")
+    GRADED = "graded"
+
+    @classmethod
+    def from_string(cls, status_string, current_score):
+      for status in cls:
+        if status is not cls.MISSING and current_score is None:
+          return cls.UNGRADED
+        if isinstance(status.value, tuple):
+          if status_string in status.value:
+            return status
+        elif status_string == status.value:
+          return status
+      return cls.MISSING  # Default
+
+
+  def __init__(
+      self,
+      *,
+      student : Student = None,
+      status : Submission.Status = Status.UNGRADED,
+      **kwargs
+  ):
+    self._student: Optional[Student] = student
+    self.status = status
+    self.input_files = None
+    self.feedback : Optional[Feedback] = None
+    self.extra_info = {}
+
+  @property
+  def student(self):
+    return self._student
+
+  @student.setter
+  def student(self, student):
+    self._student = student
+
+  def __str__(self):
+    try:
+      return f"Submission({self.student.name} : {self.feedback})"
+    except AttributeError:
+      return f"Submission({self.student} : {self.feedback})"
+
+  def set_extra(self, extras_dict: Dict):
+    self.extra_info.update(extras_dict)
+
+
+class FileSubmission(Submission):
+  """Base class for submissions that contain files (e.g., programming assignments)"""
+  def __init__(self, *args, **kwargs):
+    super().__init__(*args, **kwargs)
+    self._files = None
+
+  @property
+  def files(self):
+    return self._files
+
+  @files.setter
+  def files(self, files):
+    self._files = files
+
+
+class FileSubmission__Canvas(FileSubmission):
+  """Canvas-specific file submission with attachment downloading"""
+  def __init__(self, *args, attachments : Optional[List], **kwargs):
+    super().__init__(*args, **kwargs)
+    self._attachments = attachments
+    self.submission_index = kwargs.get("submission_index", None)
+
+  @property
+  def files(self):
+    # Check if we have already downloaded the files locally and return if we have
+    if self._files is not None:
+      return self._files
+
+    # If we haven't downloaded the files yet, check if we have attachments and can download them
+    if self._attachments is not None:
+      self._files = []
+      for attachment in self._attachments:
+
+        # Generate a local file name with a number of options
+        # local_file_name = f"{self.student.name.replace(' ', '-')}_{self.student.user_id}_{attachment['filename']}"
+        local_file_name = f"{attachment['filename']}"
+        with urllib.request.urlopen(attachment['url']) as response:
+          buffer = io.BytesIO(response.read())
+          buffer.name = local_file_name
+          self._files.append(buffer)
+
+    return self._files
+
+
+class TextSubmission(Submission):
+  """Submission containing text content (e.g., journal entries, essays)"""
+  def __init__(self, *args, submission_text=None, **kwargs):
+    super().__init__(*args, **kwargs)
+    self.submission_text = submission_text or ""
+
+  def get_text(self):
+    """Get the submission text content"""
+    return self.submission_text
+
+  def get_word_count(self):
+    """Get word count of the submission"""
+    return len(self.submission_text.split()) if self.submission_text else 0
+
+  def get_character_count(self, include_spaces=True):
+    """Get character count of the submission"""
+    if not self.submission_text:
+      return 0
+    return len(self.submission_text) if include_spaces else len(self.submission_text.replace(' ', ''))
+
+  def get_paragraph_count(self):
+    """Get paragraph count (separated by double newlines)"""
+    if not self.submission_text:
+      return 0
+    paragraphs = [p.strip() for p in self.submission_text.split('\n\n') if p.strip()]
+    return len(paragraphs)
+
+  def __str__(self):
+    try:
+      word_count = self.get_word_count()
+      return f"TextSubmission({self.student.name} : {word_count} words : {self.feedback})"
+    except AttributeError:
+      return f"TextSubmission({self.student} : {self.get_word_count()} words : {self.feedback})"
+
+
+class TextSubmission__Canvas(TextSubmission):
+  """Canvas-specific text submission"""
+  def __init__(self, *args, canvas_submission_data=None, **kwargs):
+    submission_text = ""
+    if canvas_submission_data and hasattr(canvas_submission_data, 'body') and canvas_submission_data.body:
+      submission_text = canvas_submission_data.body
+
+    super().__init__(*args, submission_text=submission_text, **kwargs)
+    self.canvas_submission_data = canvas_submission_data
+    self.submission_index = kwargs.get("submission_index", None)
+
+
+class QuizSubmission(Submission):
+  """Submission containing quiz responses and question metadata"""
+  def __init__(self, *args, quiz_submission_data=None, student_responses=None, quiz_questions=None, **kwargs):
+    super().__init__(*args, **kwargs)
+    self.quiz_submission_data = quiz_submission_data
+    self.responses = student_responses or {}  # Dict mapping question_id -> response
+    self.questions = quiz_questions or {}     # Dict mapping question_id -> question metadata
+
+  def get_response(self, question_id: int):
+    """Get student's response to a specific question"""
+    return self.responses.get(question_id)
+
+  def get_question(self, question_id: int):
+    """Get question metadata for a specific question"""
+    return self.questions.get(question_id)
+
+  def __str__(self):
+    try:
+      response_count = len(self.responses)
+      return f"QuizSubmission({self.student.name} : {response_count} responses : {self.feedback})"
+    except AttributeError:
+      return f"QuizSubmission({self.student} : {len(self.responses)} responses : {self.feedback})"
+
+
+# Maintain backward compatibility
+Submission__Canvas = FileSubmission__Canvas
+
+
+@functools.total_ordering
+@dataclasses.dataclass
+class Feedback:
+  percentage_score: Optional[float] = None
+  comments: str = ""
+  attachments: List[io.BytesIO] = dataclasses.field(default_factory=list)
+  
+  def __str__(self):
+    short_comment = self.comments[:10].replace('\n', '\\n')
+    ellipsis = '...' if len(self.comments) > 10 else ''
+    return f"Feedback({self.percentage_score:.4g}%, {short_comment}{ellipsis})"
+
+  def __eq__(self, other):
+    if not isinstance(other, Feedback):
+      return NotImplemented
+    return self.percentage_score == other.percentage_score
+  
+  def __lt__(self, other):
+    if not isinstance(other, Feedback):
+      return NotImplemented
+    if self.percentage_score is None:
+      return False  # None is treated as greater than any other value
+    if other.percentage_score is None:
+      return True
+    return self.percentage_score < other.percentage_score

QuizGenerator/constants.py

@@ -0,0 +1,149 @@
+#!env python
+"""
+Common constants used across question types.
+Centralizing these values makes it easier to maintain consistency 
+and adjust ranges globally.
+"""
+
+# Bit-related constants
+class BitRanges:
+  DEFAULT_MIN_BITS = 3
+  DEFAULT_MAX_BITS = 16
+  
+  # Memory addressing specific (using standardized names)
+  DEFAULT_MIN_BITS_VA = 5
+  DEFAULT_MAX_BITS_VA = 10
+  DEFAULT_MIN_BITS_OFFSET = 3
+  DEFAULT_MAX_BITS_OFFSET = 8
+  DEFAULT_MIN_BITS_VPN = 3
+  DEFAULT_MAX_BITS_VPN = 8
+  DEFAULT_MIN_BITS_PFN = 3
+  DEFAULT_MAX_BITS_PFN = 16
+
+  # Backward compatibility - deprecated, use standardized names above
+  DEFAULT_MIN_VA_BITS = DEFAULT_MIN_BITS_VA
+  DEFAULT_MAX_VA_BITS = DEFAULT_MAX_BITS_VA
+  DEFAULT_MIN_OFFSET_BITS = DEFAULT_MIN_BITS_OFFSET
+  DEFAULT_MAX_OFFSET_BITS = DEFAULT_MAX_BITS_OFFSET
+  DEFAULT_MIN_VPN_BITS = DEFAULT_MIN_BITS_VPN
+  DEFAULT_MAX_VPN_BITS = DEFAULT_MAX_BITS_VPN
+  DEFAULT_MIN_PFN_BITS = DEFAULT_MIN_BITS_PFN
+  DEFAULT_MAX_PFN_BITS = DEFAULT_MAX_BITS_PFN
+  
+  # Base and bounds
+  DEFAULT_MAX_ADDRESS_BITS = 32
+  DEFAULT_MIN_BOUNDS_BITS = 5
+  DEFAULT_MAX_BOUNDS_BITS = 16
+
+# Job/Process constants
+class ProcessRanges:
+  DEFAULT_MIN_JOBS = 2
+  DEFAULT_MAX_JOBS = 5
+  DEFAULT_MIN_DURATION = 2
+  DEFAULT_MAX_DURATION = 10
+  DEFAULT_MIN_ARRIVAL_TIME = 0
+  DEFAULT_MAX_ARRIVAL_TIME = 20
+
+# Cache/Memory constants
+class CacheRanges:
+  DEFAULT_MIN_CACHE_SIZE = 2
+  DEFAULT_MAX_CACHE_SIZE = 8
+  DEFAULT_MIN_ELEMENTS = 3
+  DEFAULT_MAX_ELEMENTS = 10
+  DEFAULT_MIN_REQUESTS = 5
+  DEFAULT_MAX_REQUESTS = 20
+
+# Disk/IO constants
+class IOConstants:
+  DEFAULT_MIN_RPM = 3600
+  DEFAULT_MAX_RPM = 15000
+  DEFAULT_MIN_SEEK_DELAY = 3.0
+  DEFAULT_MAX_SEEK_DELAY = 20.0
+  DEFAULT_MIN_TRANSFER_RATE = 50
+  DEFAULT_MAX_TRANSFER_RATE = 300
+
+# Math question constants
+class MathRanges:
+  DEFAULT_MIN_MATH_BITS = 3
+  DEFAULT_MAX_MATH_BITS = 49
+
+
+# =============================================================================
+# Utility Functions
+# =============================================================================
+
+def get_bit_range(bit_type: str) -> tuple[int, int]:
+  """
+  Get the min/max range for a specific type of bit parameter.
+
+  Args:
+      bit_type: One of 'va', 'offset', 'vpn', 'pfn', 'general'
+
+  Returns:
+      Tuple of (min_bits, max_bits)
+
+  Raises:
+      ValueError: If bit_type is not recognized
+  """
+  ranges = {
+    'va': (BitRanges.DEFAULT_MIN_BITS_VA, BitRanges.DEFAULT_MAX_BITS_VA),
+    'offset': (BitRanges.DEFAULT_MIN_BITS_OFFSET, BitRanges.DEFAULT_MAX_BITS_OFFSET),
+    'vpn': (BitRanges.DEFAULT_MIN_BITS_VPN, BitRanges.DEFAULT_MAX_BITS_VPN),
+    'pfn': (BitRanges.DEFAULT_MIN_BITS_PFN, BitRanges.DEFAULT_MAX_BITS_PFN),
+    'general': (BitRanges.DEFAULT_MIN_BITS, BitRanges.DEFAULT_MAX_BITS),
+  }
+  
+  if bit_type not in ranges:
+    raise ValueError(f"Unknown bit_type '{bit_type}'. Valid types: {list(ranges.keys())}")
+  
+  return ranges[bit_type]
+
+
+def get_process_range(param_type: str) -> tuple[int, int]:
+  """
+  Get the min/max range for job/process parameters.
+
+  Args:
+      param_type: One of 'jobs', 'duration', 'arrival_time'
+
+  Returns:
+      Tuple of (min_value, max_value)
+
+  Raises:
+      ValueError: If param_type is not recognized
+  """
+  ranges = {
+    'jobs': (ProcessRanges.DEFAULT_MIN_JOBS, ProcessRanges.DEFAULT_MAX_JOBS),
+    'duration': (ProcessRanges.DEFAULT_MIN_DURATION, ProcessRanges.DEFAULT_MAX_DURATION),
+    'arrival_time': (ProcessRanges.DEFAULT_MIN_ARRIVAL_TIME, ProcessRanges.DEFAULT_MAX_ARRIVAL_TIME),
+  }
+  
+  if param_type not in ranges:
+    raise ValueError(f"Unknown param_type '{param_type}'. Valid types: {list(ranges.keys())}")
+  
+  return ranges[param_type]
+
+
+def get_cache_range(param_type: str) -> tuple[int, int]:
+  """
+  Get the min/max range for cache/memory parameters.
+
+  Args:
+      param_type: One of 'cache_size', 'elements', 'requests'
+
+  Returns:
+      Tuple of (min_value, max_value)
+
+  Raises:
+      ValueError: If param_type is not recognized
+  """
+  ranges = {
+    'cache_size': (CacheRanges.DEFAULT_MIN_CACHE_SIZE, CacheRanges.DEFAULT_MAX_CACHE_SIZE),
+    'elements': (CacheRanges.DEFAULT_MIN_ELEMENTS, CacheRanges.DEFAULT_MAX_ELEMENTS),
+    'requests': (CacheRanges.DEFAULT_MIN_REQUESTS, CacheRanges.DEFAULT_MAX_REQUESTS),
+  }
+  
+  if param_type not in ranges:
+    raise ValueError(f"Unknown param_type '{param_type}'. Valid types: {list(ranges.keys())}")
+  
+  return ranges[param_type]