ygrader 2.1.0__tar.gz → 2.3.0__tar.gz

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

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

@@ -4,7 +4,7 @@ setup(
     name="ygrader",
     packages=["ygrader"],
     package_data={"ygrader": ["*.ahk"]},
-    version="2.1.0",
+    version="2.3.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.3.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.
@@ -448,3 +448,27 @@ class StudentDeductions:
         deduction_items = self.deductions_by_students.get(student_key, [])
 
         return sum(item.points for item in deduction_items)
+
+    def get_graded_students(self) -> List[tuple]:
+        """Get a list of all graded students.
+
+        Returns:
+            List of net_id tuples for all students who have been graded.
+        """
+        return list(self.deductions_by_students.keys())
+
+    def find_student_by_netid(self, netid: str) -> Optional[tuple]:
+        """Find a student's full net_ids tuple by a single net_id.
+
+        This is useful for finding group members when you only know one net_id.
+
+        Args:
+            netid: A single net_id to search for.
+
+        Returns:
+            The full net_ids tuple if found, None otherwise.
+        """
+        for student_key in self.deductions_by_students:
+            if netid in student_key:
+                return student_key
+        return None

{ygrader-2.1.0 → ygrader-2.3.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,58 @@ 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(
+            # Check for partial grades (graded for some items but not others)
+            items_graded = []
+            items_not_graded = []
+            for item in ls_column.items:
+                deductions_obj = subitem_deductions.get(item.name)
+                if deductions_obj and deductions_obj.is_student_graded((net_id,)):
+                    items_graded.append(item.name)
+                else:
+                    # Also check for multi-student keys containing this net_id
+                    found = False
+                    if deductions_obj:
+                        for key in deductions_obj.deductions_by_students.keys():
+                            if net_id in key:
+                                items_graded.append(item.name)
+                                found = True
+                                break
+                    if not found:
+                        items_not_graded.append(item.name)
+
+            if items_graded and items_not_graded:
+                print_color(
+                    TermColors.YELLOW,
+                    f"Partial grade: {net_id} graded for [{', '.join(items_graded)}] "
+                    f"but NOT [{', '.join(items_not_graded)}]",
+                )
+
+            # 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 +302,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 +338,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 +350,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 +434,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.3.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)
@@ -507,8 +459,20 @@ class Grader:
         self._run_grading(student_grades_df, grouped_df)
 
     def _run_grading(self, student_grades_df, grouped_df):
+        # Sort by last name for consistent grading order
+        # After groupby().agg(list), "Last Name" is a list, so we sort by the first element
+        sorted_df = grouped_df.sort_values(
+            by="Last Name", key=lambda x: x.apply(lambda names: names[0].lower())
+        )
+
+        # Convert to list for index-based iteration (needed for going back)
+        rows_list = list(sorted_df.iterrows())
+        idx = 0
+        prev_idx = None  # Track previous student index for undo
+
         # Loop through all of the students/groups and perform grading
-        for _, row in grouped_df.iterrows():
+        while idx < len(rows_list):
+            _, row = rows_list[idx]
             first_names = grades_csv.get_first_names(row)
             last_names = grades_csv.get_last_names(row)
             net_ids = grades_csv.get_net_ids(row)
@@ -521,6 +485,7 @@ class Grader:
 
             if sum(num_group_members_need_grade_per_item) == 0:
                 # This student/group is already fully graded
+                idx += 1
                 continue
 
             # Print name(s) of who we are grading
@@ -539,6 +504,7 @@ class Grader:
             # Code from zip will return modified time (epoch, float). Code from github will return True.
             success = self._get_student_code(row, student_work_path)
             if not success:
+                idx += 1
                 continue
 
             # Format student code
@@ -566,13 +532,23 @@ class Grader:
                     )
                 except CallbackFailed as e:
                     print_color(TermColors.RED, repr(e))
+                    idx += 1
                     continue
                 except KeyboardInterrupt:
                     pass
 
             # Loop through all items that are to be graded
+            go_back = False
             for item in self.items:
-                item.run_grading(student_grades_df, row, callback_args)
+                go_back = item.run_grading(student_grades_df, row, callback_args)
+                if go_back:
+                    break  # Stop grading items for this student if going back
+
+            if go_back and prev_idx is not None:
+                # Go back to previous student
+                idx = prev_idx
+                prev_idx = None  # Clear so we can't go back twice in a row
+                continue
 
             if self.dry_run_first:
                 print_color(
@@ -581,6 +557,10 @@ class Grader:
                 )
                 break
 
+            # Move to next student and remember this one for potential undo
+            prev_idx = idx
+            idx += 1
+
     def _unzip_submissions(self):
         with zipfile.ZipFile(self.learning_suite_submissions_zip_path, "r") as f:
             for zip_info in f.infolist():