ygrader 2.4.0__tar.gz → 2.5.1__tar.gz

{ygrader-2.4.0/ygrader.egg-info → ygrader-2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ygrader
-Version: 2.4.0
+Version: 2.5.1
 Summary: Grading scripts used in BYU's Electrical and Computer Engineering Department
 Home-page: https://github.com/byu-cpe/ygrader
 Author: Jeff Goeders

{ygrader-2.4.0 → ygrader-2.5.1}/setup.py

@@ -4,7 +4,7 @@ setup(
     name="ygrader",
     packages=["ygrader"],
     package_data={"ygrader": ["*.ahk"]},
-    version="2.4.0",
+    version="2.5.1",
     description="Grading scripts used in BYU's Electrical and Computer Engineering Department",
     author="Jeff Goeders",
     author_email="jeff.goeders@gmail.com",

{ygrader-2.4.0 → ygrader-2.5.1}/ygrader/feedback.py

@@ -5,7 +5,6 @@ import pathlib
 import zipfile
 from typing import Callable, Dict, Optional, Tuple
 
-import numpy as np
 import pandas
 import yaml
 
@@ -14,8 +13,12 @@ from .grading_item_config import LearningSuiteColumn
 from .utils import warning, print_color, TermColors
 
 
-# Type alias for late penalty callback: (late_days, max_score, actual_score) -> new_score
-LatePenaltyCallback = Callable[[int, float, float], float]
+# Type alias for late penalty callback:
+# (due_datetime, submitted_datetime, max_score, actual_score) -> new_score
+# If submitted_datetime is None, the student submitted on time or no submit time was recorded.
+LatePenaltyCallback = Callable[
+    [datetime.datetime, Optional[datetime.datetime], float, float], float
+]
 
 
 def _load_due_date_exceptions(
@@ -48,43 +51,13 @@ def _load_due_date_exceptions(
     return exceptions
 
 
-def _calculate_late_days(
-    submit_time_str: Optional[str],
-    due_date: datetime.datetime,
-) -> int:
-    """Calculate the number of business days late from a submit time.
-
-    Args:
-        submit_time_str: ISO format timestamp string of submission.
-        due_date: The effective due date for the student.
-
-    Returns:
-        Number of business days late (0 if on time or no submit time).
-    """
-    if not submit_time_str:
-        return 0
-
-    try:
-        submit_time = datetime.datetime.fromisoformat(submit_time_str)
-    except ValueError:
-        return 0
-
-    if submit_time <= due_date:
-        return 0
-
-    days_late = np.busday_count(due_date.date(), submit_time.date())
-    if days_late == 0:
-        days_late = 1  # Same day but after deadline
-    return int(days_late)
-
-
-def _get_student_key_and_max_late_days(
+def _get_student_key_and_submit_info(
     net_id: str,
     item_deductions: Dict[str, StudentDeductions],
     due_date: Optional[datetime.datetime] = None,
     due_date_exceptions: Optional[Dict[str, datetime.datetime]] = None,
-) -> tuple:
-    """Find the student key and maximum late days across all items.
+) -> Tuple[Optional[tuple], Optional[datetime.datetime], Optional[datetime.datetime]]:
+    """Find the student key and submission timing info across all items.
 
     Args:
         net_id: The student's net ID.
@@ -93,10 +66,12 @@ def _get_student_key_and_max_late_days(
         due_date_exceptions: Mapping from net_id to exception due date.
 
     Returns:
-        Tuple of (student_key or None, max_late_days).
+        Tuple of (student_key or None, effective_due_date or None, latest_submit_time or None).
+        latest_submit_time is None if on time or no submit time recorded.
     """
-    max_late_days = 0
     found_student_key = None
+    latest_submit_time: Optional[datetime.datetime] = None
+    effective_due_date: Optional[datetime.datetime] = due_date
 
     if due_date_exceptions is None:
         due_date_exceptions = {}
@@ -123,26 +98,35 @@ def _get_student_key_and_max_late_days(
         if student_key:
             found_student_key = student_key
 
-            # Calculate late days from submit_time if we have a due date
+            # Calculate effective due date (using most generous exception for group)
             if due_date is not None:
-                submit_time_str = deductions_obj.submit_time_by_students.get(
-                    student_key
-                )
-                if submit_time_str:
-                    # Calculate effective due date (using most generous exception for group)
-                    effective_due_date = due_date
-                    for member_net_id in student_key:
-                        if member_net_id in due_date_exceptions:
-                            effective_due_date = max(
-                                effective_due_date, due_date_exceptions[member_net_id]
-                            )
-
-                    days_late = _calculate_late_days(
-                        submit_time_str, effective_due_date
-                    )
-                    max_late_days = max(max_late_days, days_late)
-
-    return found_student_key, max_late_days
+                effective_due_date = due_date
+                for member_net_id in student_key:
+                    if member_net_id in due_date_exceptions:
+                        effective_due_date = max(
+                            effective_due_date, due_date_exceptions[member_net_id]
+                        )
+
+            # Get submit time
+            submit_time_str = deductions_obj.submit_time_by_students.get(student_key)
+            if submit_time_str:
+                try:
+                    submit_time = datetime.datetime.fromisoformat(submit_time_str)
+                    # Track latest submit time across all items
+                    if latest_submit_time is None or submit_time > latest_submit_time:
+                        latest_submit_time = submit_time
+                except ValueError:
+                    pass
+
+    # Return None for submit_time if on time
+    if (
+        latest_submit_time is not None
+        and effective_due_date is not None
+        and latest_submit_time <= effective_due_date
+    ):
+        latest_submit_time = None
+
+    return found_student_key, effective_due_date, latest_submit_time
 
 
 def _calculate_student_score(
@@ -154,7 +138,7 @@ def _calculate_student_score(
     warn_on_missing_callback: bool = True,
     due_date: Optional[datetime.datetime] = None,
     due_date_exceptions: Optional[Dict[str, datetime.datetime]] = None,
-) -> Tuple[float, float, int]:
+) -> Tuple[float, float, Optional[datetime.datetime]]:
     """Calculate a student's final score.
 
     Args:
@@ -162,18 +146,21 @@ def _calculate_student_score(
         ls_column: The LearningSuiteColumn configuration.
         item_deductions: Mapping from item name to StudentDeductions.
         late_penalty_callback: Optional callback for late penalty.
-        warn_on_missing_callback: Whether to warn if late days found but no callback.
+        warn_on_missing_callback: Whether to warn if late but no callback.
         due_date: The default due date for the assignment.
         due_date_exceptions: Mapping from net_id to exception due date.
 
     Returns:
-        Tuple of (final_score, total_possible, max_late_days).
+        Tuple of (final_score, total_possible, submitted_datetime or None if on time).
     """
     total_possible = sum(item.points for item in ls_column.items)
-    total_deductions = 0.0
+    total_score = 0.0
 
     for item in ls_column.items:
         deductions_obj = item_deductions.get(item.name)
+        student_graded = False
+        item_deduction_total = 0.0
+
         if deductions_obj:
             # Find the student's deductions
             student_key = None
@@ -186,28 +173,39 @@ def _calculate_student_score(
                         break
 
             if student_key:
+                student_graded = True
                 deductions = deductions_obj.deductions_by_students[student_key]
                 for deduction in deductions:
-                    total_deductions += deduction.points
+                    item_deduction_total += deduction.points
 
-    # Calculate score before late penalty
-    score = max(0, total_possible - total_deductions)
+        # Only award points if the student was graded for this item
+        if student_graded:
+            total_score += max(0, item.points - item_deduction_total)
+        # else: student gets 0 for this item (not graded)
 
-    # Get max late days
-    _, max_late_days = _get_student_key_and_max_late_days(
+    # Score is already calculated
+    score = total_score
+
+    # Get submit info
+    _, effective_due_date, submitted_datetime = _get_student_key_and_submit_info(
         net_id, item_deductions, due_date, due_date_exceptions
     )
 
-    # Apply late penalty if applicable
-    if max_late_days > 0:
-        if late_penalty_callback:
-            score = max(0, late_penalty_callback(max_late_days, total_possible, score))
+    # Apply late penalty if applicable (submitted_datetime is None if on time)
+    if submitted_datetime is not None:
+        if late_penalty_callback and effective_due_date is not None:
+            score = max(
+                0,
+                late_penalty_callback(
+                    effective_due_date, submitted_datetime, total_possible, score
+                ),
+            )
         elif warn_on_missing_callback:
             warning(
-                f"Student {net_id} has {max_late_days} late day(s) but no late penalty callback provided"
+                f"Student {net_id} submitted late but no late penalty callback provided"
             )
 
-    return score, total_possible, max_late_days
+    return score, total_possible, submitted_datetime
 
 
 def assemble_grades(
@@ -230,7 +228,8 @@ def assemble_grades(
         output_zip_path: Path for the output zip file. If None, no zip is generated.
         output_csv_path: Path for the output CSV file. If None, no CSV is generated.
         late_penalty_callback: Optional callback function that takes
-            (late_days, max_score, actual_score) and returns the adjusted score.
+            (due_datetime, submitted_datetime, max_score, actual_score) and returns the adjusted score.
+            submitted_datetime will be None if on time.
         due_date: The default due date for the assignment. Required for late penalty.
         due_date_exceptions_path: Path to YAML file with due date exceptions (net_id: "YYYY-MM-DD HH:MM:SS").
 
@@ -299,8 +298,15 @@ def assemble_grades(
                     f"but NOT [{', '.join(items_not_graded)}]",
                 )
 
+            # Get submit info for this student
+            _, effective_due_date, submitted_datetime = (
+                _get_student_key_and_submit_info(
+                    net_id, subitem_deductions, due_date, due_date_exceptions
+                )
+            )
+
             # Calculate score before late penalty
-            score_before_late, total_possible, max_late_days = _calculate_student_score(
+            score_before_late, total_possible, _ = _calculate_student_score(
                 net_id=net_id,
                 ls_column=ls_column,
                 item_deductions=subitem_deductions,
@@ -310,18 +316,25 @@ def assemble_grades(
                 due_date_exceptions=due_date_exceptions,
             )
 
-            # Apply late penalty if applicable
+            # Apply late penalty if applicable (submitted_datetime is None if on time)
             final_score = score_before_late
-            if max_late_days > 0 and late_penalty_callback:
+            if (
+                submitted_datetime is not None
+                and late_penalty_callback
+                and effective_due_date is not None
+            ):
                 final_score = max(
                     0,
                     late_penalty_callback(
-                        max_late_days, total_possible, score_before_late
+                        effective_due_date,
+                        submitted_datetime,
+                        total_possible,
+                        score_before_late,
                     ),
                 )
                 print_color(
                     TermColors.YELLOW,
-                    f"Late: {net_id} ({max_late_days} day{'s' if max_late_days != 1 else ''}): "
+                    f"Late: {net_id} (submitted {submitted_datetime}): "
                     f"{score_before_late:.1f} -> {final_score:.1f}",
                 )
 
@@ -419,7 +432,8 @@ def _generate_student_feedback(
         total_points_possible += subitem_points_possible
 
         subitem_points_deducted = 0
-        item_deductions = []
+        item_deduction_list = []
+        student_graded = False
 
         # Get deductions for this student in this item
         student_deductions_obj = subitem_deductions.get(item.name)
@@ -436,13 +450,19 @@ def _generate_student_feedback(
                         break
 
             if student_key:
+                student_graded = True
                 deductions = student_deductions_obj.deductions_by_students[student_key]
                 for deduction in deductions:
-                    item_deductions.append((deduction.message, deduction.points))
+                    item_deduction_list.append((deduction.message, deduction.points))
                     subitem_points_deducted += deduction.points
 
-        # Calculate item score
-        subitem_score = max(0, subitem_points_possible - subitem_points_deducted)
+        # Calculate item score (0 if not graded)
+        if student_graded:
+            subitem_score = max(0, subitem_points_possible - subitem_points_deducted)
+        else:
+            subitem_score = 0
+            item_deduction_list.append(("Not graded", subitem_points_possible))
+            subitem_points_deducted = subitem_points_possible
         score_str = f"{subitem_score:.1f} / {subitem_points_possible:.1f}"
 
         # Item line with score
@@ -452,7 +472,7 @@ def _generate_student_feedback(
         )
 
         # Deduction lines (indented)
-        for msg, pts in item_deductions:
+        for msg, pts in item_deduction_list:
             # Wrap long messages
             wrapped = _wrap_text(msg, deduction_msg_width)
             for i, line_text in enumerate(wrapped):
@@ -469,23 +489,30 @@ def _generate_student_feedback(
     # Calculate score before late penalty (clamped to 0)
     score_before_late = max(0, total_points_possible - total_points_deducted)
 
-    # Get max late days for this student
-    _, max_late_days = _get_student_key_and_max_late_days(
+    # Get submit info for this student
+    _, effective_due_date, submitted_datetime = _get_student_key_and_submit_info(
         net_id, subitem_deductions, due_date, due_date_exceptions
     )
 
     # Late penalty section
     lines.append("")
     lines.append("=" * 60)
-    if max_late_days > 0 and late_penalty_callback:
+    if (
+        submitted_datetime is not None
+        and late_penalty_callback
+        and effective_due_date is not None
+    ):
         final_score = late_penalty_callback(
-            max_late_days, total_points_possible, score_before_late
+            effective_due_date,
+            submitted_datetime,
+            total_points_possible,
+            score_before_late,
         )
         # Ensure final score is not negative
         final_score = max(0, final_score)
         late_penalty_points = score_before_late - final_score
         late_label = (
-            f"Late Penalty ({max_late_days} day{'s' if max_late_days != 1 else ''}):"
+            f"Late Penalty (submitted {submitted_datetime.strftime('%Y-%m-%d %H:%M')}):"
         )
         lines.append(
             f"{late_label:<{item_col_width}} {-late_penalty_points:>{score_col_width}.1f}"

{ygrader-2.4.0 → ygrader-2.5.1}/ygrader/grading_item.py

@@ -37,12 +37,15 @@ class GradeItem:
         self.fcn_args_dict = fcn_args_dict if fcn_args_dict is not None else {}
         self.student_deductions = StudentDeductions(deductions_yaml_path)
         self.last_graded_net_ids = None  # Track last graded student for undo
-        self.names_by_netid = self._build_names_lookup()  # net_id -> (first_name, last_name)
+        self.names_by_netid = (
+            self._build_names_lookup()
+        )  # net_id -> (first_name, last_name)
 
     def _build_names_lookup(self):
         """Build a lookup dictionary from net_id to (first_name, last_name) from the class list CSV."""
         # Import pandas here to avoid circular import and since it's already imported in grader.py
         import pandas  # pylint: disable=import-outside-toplevel
+
         names_by_netid = {}
         try:
             df = pandas.read_csv(self.grader.class_list_csv_path)
@@ -51,7 +54,11 @@ class GradeItem:
                     net_id = row["Net ID"]
                     first_name = row["First Name"]
                     last_name = row["Last Name"]
-                    if pandas.notna(net_id) and pandas.notna(first_name) and pandas.notna(last_name):
+                    if (
+                        pandas.notna(net_id)
+                        and pandas.notna(first_name)
+                        and pandas.notna(last_name)
+                    ):
                         names_by_netid[net_id] = (first_name, last_name)
         except (FileNotFoundError, pandas.errors.EmptyDataError, KeyError):
             pass  # If we can't read the CSV, just use an empty dict
@@ -259,6 +266,9 @@ class GradeItem:
                 # run again, but don't build
                 build = False
                 continue
+            if score == ScoreResult.EXIT:
+                print_color(TermColors.BLUE, "Exiting grader")
+                sys.exit(0)
             if score == ScoreResult.UNDO_LAST:
                 # Undo the last graded student and signal to go back
                 if self.last_graded_net_ids is not None:
@@ -276,7 +286,9 @@ class GradeItem:
             # Record score - save submit_time and ensure the student is in the deductions file
             # (even if they have no deductions, to indicate they were graded)
             if pending_submit_time is not None:
-                self.student_deductions.set_submit_time(tuple(net_ids), pending_submit_time)
+                self.student_deductions.set_submit_time(
+                    tuple(net_ids), pending_submit_time
+                )
             self.student_deductions.ensure_student_in_file(tuple(net_ids))
             # Track this student as last graded for undo functionality
             self.last_graded_net_ids = tuple(net_ids)

{ygrader-2.4.0 → ygrader-2.5.1}/ygrader/score_input.py

@@ -13,6 +13,7 @@ class ScoreResult(Enum):
     RERUN = auto()
     CREATE_DEDUCTION = auto()
     UNDO_LAST = auto()
+    EXIT = auto()
 
 
 def get_score(
@@ -55,8 +56,7 @@ def get_score(
         # Show current deductions for this student
         current_deductions = student_deductions.get_student_deductions(tuple(net_ids))
         print(
-            fpad2
-            + f"Current score: {TermColors.GREEN}{computed_score}{TermColors.END}"
+            fpad2 + f"Current score: {TermColors.GREEN}{computed_score}{TermColors.END}"
         )
         print(fpad2 + "Current deductions:")
         if current_deductions:
@@ -99,11 +99,15 @@ def get_score(
         left_items.append(("[g]", "Manage grades"))
         allowed_cmds["g"] = "manage"
 
-        # Add undo option last if there's a last graded student
+        # Add undo option if there's a last graded student
         if last_graded_net_ids is not None:
             left_items.append(("[u]", f"Undo last ({last_graded_net_ids[0]})"))
             allowed_cmds["u"] = ScoreResult.UNDO_LAST
 
+        # Add exit option at bottom of left column
+        left_items.append(("[e]", "Exit grader"))
+        allowed_cmds["e"] = ScoreResult.EXIT
+
         # Format menu items in two columns
         col_width = 38  # Each column width (2 columns * 38 = 76 < 80)
         input_txt = (
@@ -269,7 +273,10 @@ def _manage_grades_interactive(student_deductions, names_by_netid=None):
                 # Check if search matches first/last name
                 if names_by_netid and net_id in names_by_netid:
                     first_name, last_name = names_by_netid[net_id]
-                    if not list_all and (search_lower in first_name.lower() or search_lower in last_name.lower()):
+                    if not list_all and (
+                        search_lower in first_name.lower()
+                        or search_lower in last_name.lower()
+                    ):
                         match_found = True
                     display_parts.append(f"{first_name} {last_name} ({net_id})")
                 else:
@@ -309,9 +316,11 @@ def _manage_grades_interactive(student_deductions, names_by_netid=None):
             if 0 <= idx < len(matches):
                 student_key, display = matches[idx]
                 # Confirm deletion
-                confirm = input(
-                    f"Delete grade for {display}? This cannot be undone. [y/N]: "
-                ).strip().lower()
+                confirm = (
+                    input(f"Delete grade for {display}? This cannot be undone. [y/N]: ")
+                    .strip()
+                    .lower()
+                )
 
                 if confirm == "y":
                     student_deductions.clear_student_deductions(student_key)

{ygrader-2.4.0 → ygrader-2.5.1/ygrader.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ygrader
-Version: 2.4.0
+Version: 2.5.1
 Summary: Grading scripts used in BYU's Electrical and Computer Engineering Department
 Home-page: https://github.com/byu-cpe/ygrader
 Author: Jeff Goeders