ygrader 2.1.0__tar.gz → 2.2.0__tar.gz

{ygrader-2.1.0/ygrader.egg-info → ygrader-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ygrader
-Version: 2.1.0
+Version: 2.2.0
 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.1.0 → ygrader-2.2.0}/setup.py

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

{ygrader-2.1.0 → ygrader-2.2.0}/ygrader/deductions.py

@@ -44,7 +44,7 @@ class StudentDeductions:
 
     def __init__(self, yaml_path: Optional[pathlib.Path] = None):
         self.deductions_by_students = {}
-        self.days_late_by_students = {}
+        self.submit_time_by_students = {}  # ISO format timestamp strings
         self.deduction_types = {}
         self.yaml_path = yaml_path
 
@@ -102,9 +102,9 @@ class StudentDeductions:
 
                 self.deductions_by_students[student_key] = deduction_items
 
-                # Load days_late if present
-                if "days_late" in entry:
-                    self.days_late_by_students[student_key] = entry["days_late"]
+                # Load submit_time if present
+                if "submit_time" in entry:
+                    self.submit_time_by_students[student_key] = entry["submit_time"]
 
     def _write_yaml(self):
         """Write deduction types and student deductions to the YAML file.
@@ -134,9 +134,9 @@ class StudentDeductions:
                 )
             data["deduction_types"] = deduction_list
 
-        # Write student deductions (include students with deductions OR days_late)
+        # Write student deductions (include students with deductions OR submit_time)
         all_student_keys = set(self.deductions_by_students.keys()) | set(
-            self.days_late_by_students.keys()
+            self.submit_time_by_students.keys()
         )
         # Sort student keys for consistent output ordering
         sorted_student_keys = sorted(all_student_keys)
@@ -158,8 +158,8 @@ class StudentDeductions:
                         "net_ids": FlowList(student_key),
                         "deductions": FlowList(deduction_ids),
                         **(
-                            {"days_late": self.days_late_by_students[student_key]}
-                            if student_key in self.days_late_by_students
+                            {"submit_time": self.submit_time_by_students[student_key]}
+                            if student_key in self.submit_time_by_students
                             else {}
                         ),
                     }
@@ -375,8 +375,8 @@ class StudentDeductions:
         student_key = tuple(net_ids) if not isinstance(net_ids, tuple) else net_ids
         if student_key in self.deductions_by_students:
             del self.deductions_by_students[student_key]
-        if student_key in self.days_late_by_students:
-            del self.days_late_by_students[student_key]
+        if student_key in self.submit_time_by_students:
+            del self.submit_time_by_students[student_key]
         self._save()
 
     def ensure_student_in_file(self, net_ids: tuple):
@@ -405,31 +405,31 @@ class StudentDeductions:
         student_key = tuple(net_ids) if not isinstance(net_ids, tuple) else net_ids
         return student_key in self.deductions_by_students
 
-    def set_days_late(self, net_ids: tuple, days_late: int):
-        """Set the number of days late for a student.
+    def set_submit_time(self, net_ids: tuple, submit_time: Optional[str]):
+        """Set the submission time for a student.
 
         Args:
             net_ids: Tuple of net_ids for the student.
-            days_late: Number of business days late (0 or None to remove).
+            submit_time: ISO format timestamp string, or None to remove.
         """
         student_key = tuple(net_ids) if not isinstance(net_ids, tuple) else net_ids
-        if days_late and days_late > 0:
-            self.days_late_by_students[student_key] = days_late
-        elif student_key in self.days_late_by_students:
-            del self.days_late_by_students[student_key]
+        if submit_time:
+            self.submit_time_by_students[student_key] = submit_time
+        elif student_key in self.submit_time_by_students:
+            del self.submit_time_by_students[student_key]
         self._save()
 
-    def get_days_late(self, net_ids: tuple) -> Optional[int]:
-        """Get the number of days late for a student.
+    def get_submit_time(self, net_ids: tuple) -> Optional[str]:
+        """Get the submission time for a student.
 
         Args:
             net_ids: Tuple of net_ids for the student.
 
         Returns:
-            Number of business days late, or None if not set/on time.
+            ISO format timestamp string, or None if not set.
         """
         student_key = tuple(net_ids) if not isinstance(net_ids, tuple) else net_ids
-        return self.days_late_by_students.get(student_key)
+        return self.submit_time_by_students.get(student_key)
 
     def total_deductions(self, net_ids: Optional[tuple] = None) -> float:
         """Calculate the total deductions for a student or all students.

{ygrader-2.1.0 → ygrader-2.2.0}/ygrader/feedback.py

@@ -1,29 +1,65 @@
 """Module for generating student feedback files and grades CSV."""
 
+import datetime
 import pathlib
 import zipfile
 from typing import Callable, Dict, Optional, Tuple
 
+import numpy as np
 import pandas
 
 from .deductions import StudentDeductions
 from .grading_item_config import LearningSuiteColumn
-from .utils import warning
+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]
 
 
+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(
     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.
 
     Args:
         net_id: The student's net ID.
         item_deductions: Mapping from item name to StudentDeductions.
+        due_date: The default due date for the assignment.
+        due_date_exceptions: Mapping from net_id to exception due date.
 
     Returns:
         Tuple of (student_key or None, max_late_days).
@@ -31,6 +67,9 @@ def _get_student_key_and_max_late_days(
     max_late_days = 0
     found_student_key = None
 
+    if due_date_exceptions is None:
+        due_date_exceptions = {}
+
     for deductions_obj in item_deductions.values():
         if not deductions_obj:
             continue
@@ -39,12 +78,12 @@ def _get_student_key_and_max_late_days(
         student_key = None
         if (net_id,) in deductions_obj.deductions_by_students:
             student_key = (net_id,)
-        elif (net_id,) in deductions_obj.days_late_by_students:
+        elif (net_id,) in deductions_obj.submit_time_by_students:
             student_key = (net_id,)
         else:
             # Check for multi-student keys containing this net_id
             for key in set(deductions_obj.deductions_by_students.keys()) | set(
-                deductions_obj.days_late_by_students.keys()
+                deductions_obj.submit_time_by_students.keys()
             ):
                 if net_id in key:
                     student_key = key
@@ -52,8 +91,25 @@ def _get_student_key_and_max_late_days(
 
         if student_key:
             found_student_key = student_key
-            days_late = deductions_obj.days_late_by_students.get(student_key, 0)
-            max_late_days = max(max_late_days, days_late)
+
+            # Calculate late days from submit_time if we have a due date
+            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
 
@@ -62,8 +118,11 @@ def _calculate_student_score(
     net_id: str,
     ls_column: LearningSuiteColumn,
     item_deductions: Dict[str, StudentDeductions],
+    *,
     late_penalty_callback: Optional[LatePenaltyCallback] = None,
     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]:
     """Calculate a student's final score.
 
@@ -73,6 +132,8 @@ def _calculate_student_score(
         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.
+        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).
@@ -102,7 +163,9 @@ def _calculate_student_score(
     score = max(0, total_possible - total_deductions)
 
     # Get max late days
-    _, max_late_days = _get_student_key_and_max_late_days(net_id, item_deductions)
+    _, max_late_days = _get_student_key_and_max_late_days(
+        net_id, item_deductions, due_date, due_date_exceptions
+    )
 
     # Apply late penalty if applicable
     if max_late_days > 0:
@@ -124,6 +187,8 @@ def assemble_grades(
     output_zip_path: Optional[pathlib.Path] = None,
     output_csv_path: Optional[pathlib.Path] = None,
     late_penalty_callback: Optional[LatePenaltyCallback] = None,
+    due_date: Optional[datetime.datetime] = None,
+    due_date_exceptions: Optional[Dict[str, datetime.datetime]] = None,
 ) -> Tuple[Optional[pathlib.Path], Optional[pathlib.Path]]:
     """Generate feedback zip and/or grades CSV from deductions.
 
@@ -135,6 +200,8 @@ def assemble_grades(
         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_date: The default due date for the assignment. Required for late penalty.
+        due_date_exceptions: Mapping from net_id to exception due date.
 
     Returns:
         Tuple of (feedback_zip_path or None, grades_csv_path or None).
@@ -170,15 +237,32 @@ def assemble_grades(
             last_name = str(student_row["Last Name"]).strip()
             net_id = str(student_row["Net ID"]).strip()
 
-            # Calculate final score (only warn once, when generating CSV)
-            final_score, _, _ = _calculate_student_score(
+            # Calculate score before late penalty
+            score_before_late, total_possible, max_late_days = _calculate_student_score(
                 net_id=net_id,
                 ls_column=ls_column,
                 item_deductions=subitem_deductions,
-                late_penalty_callback=late_penalty_callback,
-                warn_on_missing_callback=(output_csv_path is not None),
+                late_penalty_callback=None,  # Don't apply late penalty yet
+                warn_on_missing_callback=False,
+                due_date=due_date,
+                due_date_exceptions=due_date_exceptions,
             )
 
+            # Apply late penalty if applicable
+            final_score = score_before_late
+            if max_late_days > 0 and late_penalty_callback:
+                final_score = max(
+                    0,
+                    late_penalty_callback(
+                        max_late_days, 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"{score_before_late:.1f} -> {final_score:.1f}",
+                )
+
             # Add to grades data
             if output_csv_path:
                 grades_data.append(
@@ -192,6 +276,8 @@ def assemble_grades(
                     ls_column=ls_column,
                     subitem_deductions=subitem_deductions,
                     late_penalty_callback=late_penalty_callback,
+                    due_date=due_date,
+                    due_date_exceptions=due_date_exceptions,
                 )
 
                 filename = (
@@ -226,7 +312,10 @@ def _generate_student_feedback(
     student_row: pandas.Series,
     ls_column: LearningSuiteColumn,
     subitem_deductions: Dict[str, StudentDeductions],
+    *,
     late_penalty_callback: Optional[LatePenaltyCallback] = None,
+    due_date: Optional[datetime.datetime] = None,
+    due_date_exceptions: Optional[Dict[str, datetime.datetime]] = None,
 ) -> str:
     """Generate the feedback text content for a single student.
 
@@ -235,6 +324,8 @@ def _generate_student_feedback(
         ls_column: The LearningSuiteColumn object.
         subitem_deductions: Mapping from subitem name to StudentDeductions.
         late_penalty_callback: Optional callback for calculating late penalty.
+        due_date: The default due date for the assignment.
+        due_date_exceptions: Mapping from net_id to exception due date.
 
     Returns:
         The formatted feedback text.
@@ -317,7 +408,9 @@ def _generate_student_feedback(
     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(net_id, subitem_deductions)
+    _, max_late_days = _get_student_key_and_max_late_days(
+        net_id, subitem_deductions, due_date, due_date_exceptions
+    )
 
     # Late penalty section
     lines.append("")

{ygrader-2.1.0 → ygrader-2.2.0}/ygrader/grader.py

@@ -1,6 +1,5 @@
 """Main ygrader module"""
 
-import datetime as dt
 import enum
 import inspect
 import os
@@ -13,7 +12,6 @@ from collections import defaultdict
 from typing import Callable
 
 import pandas
-import yaml
 
 from . import grades_csv, student_repos, utils
 from .grading_item import GradeItem
@@ -101,7 +99,6 @@ class Grader:
         self.github_https = None
         self.groups_csv_path = None
         self.groups_csv_col_name = None
-        self.due_date_exceptions = {}
         self.set_other_options()
 
     def add_item_to_grade(
@@ -335,8 +332,6 @@ class Grader:
         dry_run_first=False,
         dry_run_all=False,
         workflow_hash=None,
-        due_date=None,
-        due_date_exceptions_path=None,
     ):
         """
         This can be used to set other options for the grader.
@@ -376,15 +371,6 @@ class Grader:
             (Optional) Expected hash of the GitHub workflow file. If provided, the workflow file will be verified
             before grading each student. If the hash doesn't match, a warning will be displayed indicating
             the student may have modified the workflow system.
-        due_date: datetime.datetime
-            (Optional) Due date for the assignment. If provided, the submission date will be compared to this
-            and late days will be calculated and displayed.
-        due_date_exceptions_path: str
-            (Optional) Path to a YAML file containing per-student due date exceptions. The file should be
-            a simple dictionary mapping net_ids to deadline strings in "YYYY-MM-DD HH:MM:SS" format.
-            Example:
-                "student1": "2025-01-15 23:59:59"
-                "student2": "2025-01-17 23:59:59"
         """
         self.format_code = format_code
         self.build_only = build_only
@@ -392,9 +378,6 @@ class Grader:
         self.allow_rebuild = allow_rebuild
         self.allow_rerun = allow_rerun
         self.workflow_hash = workflow_hash
-        self.due_date = due_date
-        self.due_date_exceptions = {}
-        self.due_date_exceptions_path = due_date_exceptions_path
         if prep_fcn and not isinstance(prep_fcn, Callable):
             error("The 'prep_fcn' argument must provide a callable function pointer")
         self.prep_fcn = prep_fcn
@@ -424,36 +407,6 @@ class Grader:
                 + "set_submission_system_learning_suite() or set_submission_system_github()."
             )
 
-    def _load_due_date_exceptions(self):
-        """Load due date exceptions from YAML file (simple net_id: deadline format)"""
-
-        self.due_date_exceptions = {}
-        if not self.due_date_exceptions_path:
-            return
-
-        try:
-            with open(self.due_date_exceptions_path, "r", encoding="utf-8") as f:
-                exceptions_raw = yaml.safe_load(f)
-        except (IOError, yaml.YAMLError) as e:
-            print_color(
-                TermColors.YELLOW, f"Warning: Could not load exceptions file: {e}"
-            )
-            return
-
-        if not exceptions_raw or not isinstance(exceptions_raw, dict):
-            return
-
-        for net_id, deadline_str in exceptions_raw.items():
-            try:
-                self.due_date_exceptions[net_id] = dt.datetime.strptime(
-                    deadline_str, "%Y-%m-%d %H:%M:%S"
-                )
-            except ValueError as e:
-                print_color(
-                    TermColors.YELLOW,
-                    f"Warning: Could not parse deadline for {net_id}: {e}",
-                )
-
     def _get_all_csv_cols_to_grade(self):
         """Collect all columns that will be graded into a single list.
 
@@ -465,7 +418,6 @@ class Grader:
         """Call this to start (or resume) the grading process"""
 
         self._validate_config()
-        self._load_due_date_exceptions()
 
         # Print starting message
         print_color(TermColors.BLUE, "Running grader for", self.lab_name)

{ygrader-2.1.0 → ygrader-2.2.0}/ygrader/grading_item.py

@@ -3,8 +3,6 @@
 import datetime
 import sys
 
-import numpy as np
-
 from .utils import (
     CallbackFailed,
     TermColors,
@@ -149,10 +147,10 @@ class GradeItem:
                         print_color(TermColors.RED, "=" * 70)
                         print("")
 
-            # Display submission date if available
+            # Display submission date if available and store for later late calculation
             student_code_path = callback_args.get("student_code_path")
-            # Calculate days_late but don't save yet - will be saved only after successful grading
-            pending_days_late = None
+            # Store submission time but don't save yet - will be saved only after successful grading
+            pending_submit_time = None
             if student_code_path:
                 submission_date_path = student_code_path / ".commitdate"
                 if submission_date_path.is_file():
@@ -166,43 +164,8 @@ class GradeItem:
                             TermColors.BLUE,
                             f"Submitted: {submission_time.strftime('%Y-%m-%d %H:%M:%S')}",
                         )
-
-                        # Calculate late days if due_date is configured
-                        if self.grader.due_date is not None:
-                            # Check for student-specific due date exception
-                            # Use the latest (most generous) exception if multiple group members have them
-                            effective_due_date = self.grader.due_date
-                            for net_id in net_ids:
-                                if net_id in self.grader.due_date_exceptions:
-                                    exception_date = self.grader.due_date_exceptions[
-                                        net_id
-                                    ]
-                                    effective_due_date = max(
-                                        effective_due_date, exception_date
-                                    )
-
-                            has_exception = effective_due_date != self.grader.due_date
-                            if has_exception:
-                                print_color(
-                                    TermColors.YELLOW,
-                                    f"Exception due date: {effective_due_date.strftime('%Y-%m-%d %H:%M:%S')}",
-                                )
-
-                            if submission_time <= effective_due_date:
-                                print_color(TermColors.GREEN, "Status: ON TIME")
-                                pending_days_late = 0
-                            else:
-                                days_late = np.busday_count(
-                                    effective_due_date.date(),
-                                    submission_time.date(),
-                                )
-                                if days_late == 0:
-                                    days_late = 1  # Same day but after deadline
-                                print_color(
-                                    TermColors.RED,
-                                    f"Status: LATE ({days_late} business day(s))",
-                                )
-                                pending_days_late = int(days_late)
+                        # Store as ISO format for later late calculation
+                        pending_submit_time = submission_time.isoformat()
                     except (ValueError, IOError) as e:
                         print_color(
                             TermColors.YELLOW,
@@ -230,10 +193,10 @@ class GradeItem:
                             TermColors.BLUE,
                             f"Applied deduction: {deduction_desc} (-{deduction_points})",
                         )
-                    # Save days_late now that grading succeeded
-                    if pending_days_late is not None:
-                        self.student_deductions.set_days_late(
-                            tuple(net_ids), pending_days_late
+                    # Save submit_time now that grading succeeded
+                    if pending_submit_time is not None:
+                        self.student_deductions.set_submit_time(
+                            tuple(net_ids), pending_submit_time
                         )
                     # Ensure student is in the deductions file
                     self.student_deductions.ensure_student_in_file(tuple(net_ids))
@@ -270,10 +233,10 @@ class GradeItem:
                 build = False
                 continue
 
-            # Record score - save days_late and ensure the student is in the deductions file
+            # 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_days_late is not None:
-                self.student_deductions.set_days_late(tuple(net_ids), pending_days_late)
+            if pending_submit_time is not None:
+                self.student_deductions.set_submit_time(tuple(net_ids), pending_submit_time)
             self.student_deductions.ensure_student_in_file(tuple(net_ids))
             break
 

{ygrader-2.1.0 → ygrader-2.2.0/ygrader.egg-info}/PKG-INFO

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