ygrader 2.2.0__tar.gz → 2.4.0__tar.gz

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

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

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

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

@@ -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.2.0 → ygrader-2.4.0}/ygrader/feedback.py

@@ -7,6 +7,7 @@ from typing import Callable, Dict, Optional, Tuple
 
 import numpy as np
 import pandas
+import yaml
 
 from .deductions import StudentDeductions
 from .grading_item_config import LearningSuiteColumn
@@ -17,6 +18,36 @@ from .utils import warning, print_color, TermColors
 LatePenaltyCallback = Callable[[int, float, float], float]
 
 
+def _load_due_date_exceptions(
+    exceptions_path: pathlib.Path,
+) -> Dict[str, datetime.datetime]:
+    """Load due date exceptions from YAML file.
+
+    Args:
+        exceptions_path: Path to the deadline_exceptions.yaml file.
+            Expected format is: net_id: "YYYY-MM-DD HH:MM:SS"
+
+    Returns:
+        Mapping from net_id to exception datetime.
+    """
+    if not exceptions_path.exists():
+        return {}
+
+    with open(exceptions_path, "r", encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+
+    if not data:
+        return {}
+
+    exceptions = {}
+    for net_id, exception_date in data.items():
+        if net_id and exception_date:
+            exceptions[net_id] = datetime.datetime.strptime(
+                exception_date, "%Y-%m-%d %H:%M:%S"
+            )
+    return exceptions
+
+
 def _calculate_late_days(
     submit_time_str: Optional[str],
     due_date: datetime.datetime,
@@ -188,7 +219,7 @@ def assemble_grades(
     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,
+    due_date_exceptions_path: Optional[pathlib.Path] = None,
 ) -> Tuple[Optional[pathlib.Path], Optional[pathlib.Path]]:
     """Generate feedback zip and/or grades CSV from deductions.
 
@@ -201,12 +232,17 @@ def assemble_grades(
         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.
+        due_date_exceptions_path: Path to YAML file with due date exceptions (net_id: "YYYY-MM-DD HH:MM:SS").
 
     Returns:
         Tuple of (feedback_zip_path or None, grades_csv_path or None).
     """
     yaml_path = pathlib.Path(yaml_path)
+
+    # Load due date exceptions if path provided
+    due_date_exceptions: Dict[str, datetime.datetime] = {}
+    if due_date_exceptions_path:
+        due_date_exceptions = _load_due_date_exceptions(due_date_exceptions_path)
     ls_column = LearningSuiteColumn(yaml_path)
 
     # Get the lab name from the YAML file's parent directory
@@ -237,6 +273,32 @@ def assemble_grades(
             last_name = str(student_row["Last Name"]).strip()
             net_id = str(student_row["Net ID"]).strip()
 
+            # 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,

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

@@ -459,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)
@@ -473,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
@@ -491,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
@@ -518,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(
@@ -533,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():

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

@@ -36,9 +36,34 @@ class GradeItem:
         self.max_points = max_points
         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)
+
+    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)
+            for _, row in df.iterrows():
+                if "Net ID" in row and "First Name" in row and "Last Name" in row:
+                    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):
+                        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
+        return names_by_netid
 
     def run_grading(self, _student_grades_df, row, callback_args):
-        """Run the grading process for this item"""
+        """Run the grading process for this item.
+
+        Returns:
+            True if user requested to go back and regrade the previous student,
+            False otherwise.
+        """
         net_ids = grades_csv.get_net_ids(row)
         num_group_members = len(net_ids)
         concated_names = grades_csv.get_concated_names(row)
@@ -63,7 +88,7 @@ class GradeItem:
                 "Grade already exists for this item",
                 "(skipping)",
             )
-            return
+            return False
 
         while True:
             print_color(
@@ -219,26 +244,46 @@ class GradeItem:
                     allow_rerun=self.grader.allow_rerun,
                     student_deductions=self.student_deductions,
                     net_ids=tuple(net_ids),
+                    last_graded_net_ids=self.last_graded_net_ids,
+                    names_by_netid=self.names_by_netid,
                 )
             except KeyboardInterrupt:
                 print_color(TermColors.RED, "\nExiting")
                 sys.exit(0)
 
             if score == ScoreResult.SKIP:
-                break
+                return False
             if score == ScoreResult.REBUILD:
                 continue
             if score == ScoreResult.RERUN:
                 # run again, but don't build
                 build = False
                 continue
+            if score == ScoreResult.UNDO_LAST:
+                # Undo the last graded student and signal to go back
+                if self.last_graded_net_ids is not None:
+                    self.student_deductions.clear_student_deductions(
+                        self.last_graded_net_ids
+                    )
+                    print_color(
+                        TermColors.GREEN,
+                        f"Undid grade for {', '.join(self.last_graded_net_ids)} - going back to regrade",
+                    )
+                    self.last_graded_net_ids = None
+                    return True  # Signal to go back to previous student
+                continue
 
             # 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.ensure_student_in_file(tuple(net_ids))
-            break
+            # Track this student as last graded for undo functionality
+            self.last_graded_net_ids = tuple(net_ids)
+            return False  # Normal completion
+
+        # If we got here via break (CallbackFailed, build_only, dry_run, etc.)
+        return False
 
     def num_grades_needed_deductions(self, net_ids):
         """Return the number of group members who need a grade.

ygrader-2.4.0/ygrader/score_input.py

@@ -0,0 +1,324 @@
+"""Module for prompting users for scores during grading."""
+
+from enum import Enum, auto
+
+from .utils import TermColors, print_color
+
+
+class ScoreResult(Enum):
+    """Enum representing special score input results."""
+
+    SKIP = auto()
+    REBUILD = auto()
+    RERUN = auto()
+    CREATE_DEDUCTION = auto()
+    UNDO_LAST = auto()
+
+
+def get_score(
+    names,
+    max_points,
+    *,
+    allow_rebuild=True,
+    allow_rerun=True,
+    student_deductions,
+    net_ids,
+    last_graded_net_ids=None,
+    names_by_netid=None,
+):
+    """Prompts the user for a score for the grade column.
+
+    Args:
+        names: Student name(s) to display
+        max_points: Maximum points for this item
+        allow_rebuild: Whether rebuild option is available
+        allow_rerun: Whether rerun option is available
+        student_deductions: StudentDeductions object
+        net_ids: Tuple of net_ids for the current student
+        last_graded_net_ids: Tuple of net_ids for the last graded student (for undo)
+        names_by_netid: Dict mapping net_id -> (first_name, last_name) for search
+
+    Returns:
+        Either a numeric score (float) or a ScoreResult enum value
+    """
+    fpad2 = " " * 4
+    pad = 10
+
+    while True:
+        # Compute current score
+        deductions_total = student_deductions.total_deductions(tuple(net_ids))
+        computed_score = max(0, max_points - deductions_total)
+
+        print("")
+        print("-" * 60)
+
+        # 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}"
+        )
+        print(fpad2 + "Current deductions:")
+        if current_deductions:
+            for d in current_deductions:
+                print(fpad2 + f"  -{d.points}: {d.message}")
+        else:
+            print(fpad2 + "  (None)")
+        print("")
+
+        ################### Build input menu #######################
+        # Build menu items for two-column display (left_items, right_items)
+        left_items = []
+        right_items = []
+        allowed_cmds = {}
+
+        left_items.append(("[s]", "Skip student"))
+        allowed_cmds["s"] = ScoreResult.SKIP
+
+        if allow_rebuild:
+            left_items.append(("[b]", "Build & run"))
+            allowed_cmds["b"] = ScoreResult.REBUILD
+        if allow_rerun:
+            desc = "Re-run" if not allow_rebuild else "Re-run (no build)"
+            left_items.append(("[r]", desc))
+            allowed_cmds["r"] = ScoreResult.RERUN
+
+        # Add deduction options to right column
+        right_items.append(("[n]", "New deduction"))
+        allowed_cmds["n"] = "create"
+
+        right_items.append(("[d]", "Delete deduction"))
+        allowed_cmds["d"] = "delete"
+
+        right_items.append(("[0]", "Clear deductions"))
+
+        # Accept score at the bottom of right column
+        right_items.append(("[Enter]", "Accept score"))
+
+        # Add manage grades and undo to left column
+        left_items.append(("[g]", "Manage grades"))
+        allowed_cmds["g"] = "manage"
+
+        # Add undo option last 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
+
+        # Format menu items in two columns
+        col_width = 38  # Each column width (2 columns * 38 = 76 < 80)
+        input_txt = (
+            TermColors.BLUE + "Enter a grade for " + names + ":" + TermColors.END + "\n"
+        )
+
+        # Combine left and right items row by row
+        max_rows = max(len(left_items), len(right_items))
+        for i in range(max_rows):
+            # Left column
+            if i < len(left_items):
+                key1, desc1 = left_items[i]
+                col1 = (
+                    fpad2 + TermColors.BLUE + key1.ljust(pad) + TermColors.END + desc1
+                )
+                # Pad to column width (accounting for ANSI codes)
+                col1_visible_len = len(fpad2) + len(key1.ljust(pad)) + len(desc1)
+                col1_padded = col1 + " " * (col_width - col1_visible_len)
+            else:
+                col1_padded = " " * col_width
+
+            # Right column
+            if i < len(right_items):
+                key2, desc2 = right_items[i]
+                col2 = TermColors.BLUE + key2.ljust(pad) + TermColors.END + desc2
+                input_txt += col1_padded + col2 + "\n"
+            else:
+                input_txt += col1_padded.rstrip() + "\n"
+
+        # Show available deduction types to apply
+        input_txt += fpad2 + "Apply deduction(s):\n"
+        for (
+            deduction_id,
+            deduction_type,
+        ) in student_deductions.deduction_types.items():
+            input_txt += (
+                fpad2
+                + TermColors.BLUE
+                + f"  [{deduction_id}]".ljust(pad)
+                + TermColors.END
+                + f"-{deduction_type.points}: {deduction_type.message}\n"
+            )
+
+        input_txt += TermColors.BLUE + ">>> " + TermColors.END
+
+        ################### Get and handle user input #######################
+        txt = input(input_txt)
+
+        # Check for Enter key to accept computed score
+        if txt == "":
+            print(f"Saving score: {computed_score}")
+            return computed_score
+
+        # Check for commands
+        if txt in allowed_cmds:
+            result = allowed_cmds[txt]
+
+            # Handle special cases that need to loop back
+            if result == "create":
+                deduction_id = student_deductions.create_deduction_type_interactive()
+                if deduction_id >= 0:
+                    # Auto-apply the new deduction to this student
+                    student_deductions.apply_deduction_to_student(
+                        tuple(net_ids), deduction_id
+                    )
+                continue
+            if result == "delete":
+                student_deductions.delete_deduction_type_interactive()
+                continue
+            if result == "manage":
+                _manage_grades_interactive(student_deductions, names_by_netid)
+                continue
+            return result
+
+        # Check for clear command (must be exactly "0", not in a list)
+        if txt == "0":
+            student_deductions.clear_student_deductions(tuple(net_ids))
+            print("Cleared all deductions for this student.")
+            continue
+
+        # Check for deduction ID input
+        # Supports comma-separated list of deduction IDs (e.g., "1,2,3")
+        parts = [p.strip() for p in txt.split(",")]
+        valid_ids = []
+        all_valid = True
+        for part in parts:
+            try:
+                deduction_id = int(part)
+                # Don't allow 0 or other special commands in the list
+                if deduction_id <= 0:
+                    all_valid = False
+                    break
+                if deduction_id in student_deductions.deduction_types:
+                    valid_ids.append(deduction_id)
+                else:
+                    all_valid = False
+                    break
+            except ValueError:
+                all_valid = False
+                break
+
+        if all_valid and valid_ids:
+            # Apply the deductions
+            for deduction_id in valid_ids:
+                student_deductions.apply_deduction_to_student(
+                    tuple(net_ids), deduction_id
+                )
+                deduction_type = student_deductions.deduction_types[deduction_id]
+                print(
+                    f"Applied deduction: {deduction_type.message} (-{deduction_type.points})"
+                )
+            continue
+
+        print_color(TermColors.YELLOW, "Invalid input. Try again.")
+
+
+def _manage_grades_interactive(student_deductions, names_by_netid=None):
+    """Interactive menu to manage (view/delete) grades for any student.
+
+    Args:
+        student_deductions: StudentDeductions object to manage
+        names_by_netid: Dict mapping net_id -> (first_name, last_name) for search
+    """
+    while True:
+        graded_students = student_deductions.get_graded_students()
+
+        print("\n" + "=" * 60)
+        print_color(TermColors.BLUE, "Manage Grades")
+        print("=" * 60)
+
+        if not graded_students:
+            print("No students have been graded yet.")
+            input("Press Enter to continue...")
+            return
+
+        print(f"{len(graded_students)} student(s) graded.")
+        print("\nOptions:")
+        print("  [search]  Enter search string to find student by name or net_id")
+        print("  [*]       List all graded students")
+        print("  [Enter]   Return to grading")
+
+        txt = input("\nSearch: ").strip()
+
+        if txt == "":
+            return
+
+        # Check for wildcard to list all
+        list_all = txt == "*"
+
+        # Search for matching students (case-insensitive)
+        search_lower = txt.lower()
+        matches = []
+
+        for net_ids in graded_students:
+            match_found = list_all  # If listing all, match everything
+            display_parts = []
+
+            for net_id in net_ids:
+                # Check if search matches net_id (skip if listing all)
+                if not list_all and search_lower in net_id.lower():
+                    match_found = True
+
+                # 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()):
+                        match_found = True
+                    display_parts.append(f"{first_name} {last_name} ({net_id})")
+                else:
+                    display_parts.append(net_id)
+
+            if match_found:
+                matches.append((net_ids, ", ".join(display_parts)))
+
+        if not matches:
+            print_color(TermColors.YELLOW, f"No graded students match '{txt}'")
+            continue
+
+        # Sort matches by display name
+        matches.sort(key=lambda x: x[1].lower())
+
+        # Display matches and let user pick one
+        print(f"\nFound {len(matches)} match(es):")
+        for i, (net_ids, display) in enumerate(matches, 1):
+            deductions = student_deductions.get_student_deductions(net_ids)
+            deduction_count = len(deductions)
+            total_deducted = student_deductions.total_deductions(net_ids)
+            print(
+                f"  [{i}] {display} "
+                f"({deduction_count} deduction(s), -{total_deducted} pts)"
+            )
+
+        print("\n  [#]      Enter number to delete that student's grade")
+        print("  [Enter]  Cancel")
+
+        choice = input("\n>>> ").strip()
+
+        if choice == "":
+            continue
+
+        try:
+            idx = int(choice) - 1
+            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()
+
+                if confirm == "y":
+                    student_deductions.clear_student_deductions(student_key)
+                    print_color(TermColors.GREEN, f"Deleted grade for {display}")
+                else:
+                    print("Cancelled.")
+            else:
+                print_color(TermColors.YELLOW, "Invalid selection.")
+        except ValueError:
+            print_color(TermColors.YELLOW, "Invalid input.")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ygrader
-Version: 2.2.0
+Version: 2.4.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.2.0/ygrader/score_input.py

@@ -1,231 +0,0 @@
-"""Module for prompting users for scores during grading."""
-
-from enum import Enum, auto
-
-from .utils import TermColors, print_color
-
-
-class ScoreResult(Enum):
-    """Enum representing special score input results."""
-
-    SKIP = auto()
-    REBUILD = auto()
-    RERUN = auto()
-    CREATE_DEDUCTION = auto()
-
-
-def get_score(
-    names,
-    max_points,
-    *,
-    allow_rebuild=True,
-    allow_rerun=True,
-    student_deductions=None,
-    net_ids=None,
-):
-    """Prompts the user for a score for the grade column.
-
-    Args:
-        names: Student name(s) to display
-        max_points: Maximum points for this item (or None if no limit)
-        allow_rebuild: Whether rebuild option is available
-        allow_rerun: Whether rerun option is available
-        student_deductions: StudentDeductions object (for deductions mode)
-        net_ids: Tuple of net_ids for the current student (for deductions mode)
-
-    Returns:
-        Either a numeric score (float) or a ScoreResult enum value
-    """
-    fpad2 = " " * 4
-    pad = 10
-
-    # Check if we're in deductions mode
-    deductions_mode = student_deductions is not None and net_ids is not None
-
-    while True:
-        # Compute score if in deductions mode
-        computed_score = None
-        if deductions_mode:
-            deductions_total = student_deductions.total_deductions(tuple(net_ids))
-            computed_score = max(0, max_points - deductions_total)
-
-        print("")
-        print("-" * 60)
-
-        # Show current deductions for this student if in deductions mode (in white)
-        if deductions_mode:
-            current_deductions = student_deductions.get_student_deductions(
-                tuple(net_ids)
-            )
-            print(
-                fpad2
-                + f"Current score: {TermColors.GREEN}{computed_score}{TermColors.END}"
-            )
-            print(fpad2 + "Current deductions:")
-            if current_deductions:
-                for d in current_deductions:
-                    print(fpad2 + f"  -{d.points}: {d.message}")
-            else:
-                print(fpad2 + "  (None)")
-            print("")
-
-        ################### Build input menu #######################
-        # Build menu items for two-column display (left_items, right_items)
-        left_items = []
-        right_items = []
-        allowed_cmds = {}
-
-        # Show computed score if in deductions mode
-        if deductions_mode:
-            left_items.append(("[Enter]", "Accept score"))
-        else:
-            # Add score input (only for manual mode)
-            key = ("0-" + str(max_points)) if max_points else "#"
-            left_items.append((key, "Enter score"))
-
-        left_items.append(("[s]", "Skip student"))
-        allowed_cmds["s"] = ScoreResult.SKIP
-
-        if allow_rebuild:
-            left_items.append(("[b]", "Build & run"))
-            allowed_cmds["b"] = ScoreResult.REBUILD
-        if allow_rerun:
-            desc = "Re-run" if not allow_rebuild else "Re-run (no build)"
-            left_items.append(("[r]", desc))
-            allowed_cmds["r"] = ScoreResult.RERUN
-
-        # Add deduction options to right column (only in deductions mode)
-        if deductions_mode:
-            right_items.append(("[c]", "Create deduction"))
-            allowed_cmds["c"] = "create"
-
-            right_items.append(("[d]", "Delete deduction"))
-            allowed_cmds["d"] = "delete"
-
-            right_items.append(("[0]", "Clear deductions"))
-
-        # Format menu items in two columns
-        col_width = 38  # Each column width (2 columns * 38 = 76 < 80)
-        input_txt = (
-            TermColors.BLUE + "Enter a grade for " + names + ":" + TermColors.END + "\n"
-        )
-
-        # Combine left and right items row by row
-        max_rows = max(len(left_items), len(right_items))
-        for i in range(max_rows):
-            # Left column
-            if i < len(left_items):
-                key1, desc1 = left_items[i]
-                col1 = (
-                    fpad2 + TermColors.BLUE + key1.ljust(pad) + TermColors.END + desc1
-                )
-                # Pad to column width (accounting for ANSI codes)
-                col1_visible_len = len(fpad2) + len(key1.ljust(pad)) + len(desc1)
-                col1_padded = col1 + " " * (col_width - col1_visible_len)
-            else:
-                col1_padded = " " * col_width
-
-            # Right column
-            if i < len(right_items):
-                key2, desc2 = right_items[i]
-                col2 = TermColors.BLUE + key2.ljust(pad) + TermColors.END + desc2
-                input_txt += col1_padded + col2 + "\n"
-            else:
-                input_txt += col1_padded.rstrip() + "\n"
-
-        # Show available deduction types to apply (keep single column for these)
-        if deductions_mode:
-            input_txt += fpad2 + "Apply deduction(s):\n"
-            for (
-                deduction_id,
-                deduction_type,
-            ) in student_deductions.deduction_types.items():
-                input_txt += (
-                    fpad2
-                    + TermColors.BLUE
-                    + f"  [{deduction_id}]".ljust(pad)
-                    + TermColors.END
-                    + f"-{deduction_type.points}: {deduction_type.message}\n"
-                )
-
-        input_txt += TermColors.BLUE + ">>> " + TermColors.END
-
-        ################### Get and handle user input #######################
-        txt = input(input_txt)
-
-        # Check for Enter key to accept computed score
-        if txt == "" and deductions_mode:
-            print(f"Saving score: {computed_score}")
-            return computed_score
-
-        # Check for commands
-        if txt in allowed_cmds:
-            result = allowed_cmds[txt]
-
-            # Handle special cases that need to loop back
-            if result == "create":
-                deduction_id = student_deductions.create_deduction_type_interactive()
-                if deduction_id >= 0:
-                    # Auto-apply the new deduction to this student
-                    student_deductions.apply_deduction_to_student(
-                        tuple(net_ids), deduction_id
-                    )
-                continue
-            if result == "delete":
-                student_deductions.delete_deduction_type_interactive()
-                continue
-            return result
-
-        # Check for deduction ID input (only in deductions mode)
-        # 0 is reserved for clearing all deductions (must be standalone, not in a list)
-        # Supports comma-separated list of deduction IDs (e.g., "1,2,3")
-        if deductions_mode:
-            # Check for clear command (must be exactly "0", not in a list)
-            if txt == "0":
-                student_deductions.clear_student_deductions(tuple(net_ids))
-                print("Cleared all deductions for this student.")
-                continue
-
-            # Split by comma and try to parse each as a deduction ID
-            parts = [p.strip() for p in txt.split(",")]
-            valid_ids = []
-            all_valid = True
-            for part in parts:
-                try:
-                    deduction_id = int(part)
-                    # Don't allow 0 or other special commands in the list
-                    if deduction_id <= 0:
-                        all_valid = False
-                        break
-                    if deduction_id in student_deductions.deduction_types:
-                        valid_ids.append(deduction_id)
-                    else:
-                        all_valid = False
-                        break
-                except ValueError:
-                    all_valid = False
-                    break
-
-            if all_valid and valid_ids:
-                # Apply the deductions
-                for deduction_id in valid_ids:
-                    student_deductions.apply_deduction_to_student(
-                        tuple(net_ids), deduction_id
-                    )
-                    deduction_type = student_deductions.deduction_types[deduction_id]
-                    print(
-                        f"Applied deduction: {deduction_type.message} (-{deduction_type.points})"
-                    )
-                continue
-
-        # Check for numeric input (only allowed in manual mode)
-        if not deductions_mode:
-            try:
-                score = float(txt)
-                if (max_points is None) or (0 <= score <= max_points):
-                    return score
-                print_color(TermColors.YELLOW, "Invalid input. Try again.")
-            except ValueError:
-                print_color(TermColors.YELLOW, "Invalid input. Try again.")
-        else:
-            print_color(TermColors.YELLOW, "Invalid input. Try again.")