ygrader 2.6.5__tar.gz → 2.6.7__tar.gz

{ygrader-2.6.5/ygrader.egg-info → ygrader-2.6.7}/PKG-INFO

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

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

{ygrader-2.6.5 → ygrader-2.6.7}/ygrader/feedback.py

@@ -293,11 +293,19 @@ def assemble_grades(
 
             if items_graded and items_not_graded:
                 print_color(
-                    TermColors.YELLOW,
+                    TermColors.RED,
                     f"Partial grade: {net_id} graded for [{', '.join(items_graded)}] "
                     f"but NOT [{', '.join(items_not_graded)}]",
                 )
 
+            # Check if student has no grades at all
+            student_graded = len(items_graded) > 0
+            if not student_graded:
+                print_color(
+                    TermColors.YELLOW,
+                    f"No grades: {net_id} has no grades, receiving 0",
+                )
+
             # Get submit info for this student
             _, effective_due_date, submitted_datetime = (
                 _get_student_key_and_submit_info(
@@ -353,6 +361,7 @@ def assemble_grades(
                     late_penalty_callback=late_penalty_callback,
                     due_date=due_date,
                     due_date_exceptions=due_date_exceptions,
+                    student_graded=student_graded,
                 )
 
                 filename = (
@@ -391,6 +400,7 @@ def _generate_student_feedback(
     late_penalty_callback: Optional[LatePenaltyCallback] = None,
     due_date: Optional[datetime.datetime] = None,
     due_date_exceptions: Optional[Dict[str, datetime.datetime]] = None,
+    student_graded: bool = True,
 ) -> str:
     """Generate the feedback text content for a single student.
 
@@ -401,6 +411,7 @@ def _generate_student_feedback(
         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.
+        student_graded: Whether the student was graded at all (False if no submission).
 
     Returns:
         The formatted feedback text.
@@ -517,6 +528,12 @@ def _generate_student_feedback(
         lines.append(
             f"{late_label:<{item_col_width}} {-late_penalty_points:>{score_col_width}.1f}"
         )
+    elif not student_graded:
+        # Student was never graded (no submission)
+        final_score = score_before_late
+        lines.append(
+            f"{'Late Penalty:':<{item_col_width}} {'No Submission':>{score_col_width}}"
+        )
     else:
         final_score = score_before_late
         lines.append(

{ygrader-2.6.5 → ygrader-2.6.7}/ygrader/grader.py

@@ -21,6 +21,7 @@ import pandas
 
 from . import grades_csv, student_repos, utils
 from .grading_item import GradeItem
+from .score_input import show_completion_menu
 from .utils import (
     CallbackFailed,
     TermColors,
@@ -98,6 +99,8 @@ class Grader:
         self.items = []
         self.code_source = None
         self.prep_fcn = None
+        self.last_graded_net_ids = None  # Track last fully graded student for undo
+        self.interactive_grading_occurred = False  # Track if any user interaction happened
         self.learning_suite_submissions_zip_path = None
         self.github_csv_path = None
         self.github_csv_col_name = None
@@ -505,6 +508,7 @@ class Grader:
         rows_list = list(sorted_df.iterrows())
         idx = 0
         prev_idx = None  # Track previous student index for undo
+        any_student_needed_grading = False  # Track if any student needed grading
 
         # Loop through all of the students/groups and perform grading
         while idx < len(rows_list):
@@ -524,6 +528,8 @@ class Grader:
                 idx += 1
                 continue
 
+            any_student_needed_grading = True
+
             # Print name(s) of who we are grading
             student_work_path = self.work_path / utils.names_to_dir(
                 first_names, last_names, net_ids
@@ -588,8 +594,18 @@ class Grader:
                 # Go back to previous student
                 idx = prev_idx
                 prev_idx = None  # Clear so we can't go back twice in a row
+                self.last_graded_net_ids = None  # Clear since we're undoing
                 continue
 
+            # Track this student as last graded (only if all items completed normally)
+            if (
+                not go_back
+                and not self.build_only
+                and not self.dry_run_first
+                and not self.dry_run_all
+            ):
+                self.last_graded_net_ids = tuple(net_ids)
+
             if self.dry_run_first:
                 print_color(
                     TermColors.YELLOW,
@@ -601,6 +617,18 @@ class Grader:
             prev_idx = idx
             idx += 1
 
+        # Show completion menu when all students are done (unless in special modes)
+        # Show if interactive grading occurred OR if no students needed grading (all already graded)
+        if (
+            not self.build_only
+            and not self.dry_run_first
+            and not self.dry_run_all
+            and (self.interactive_grading_occurred or not any_student_needed_grading)
+        ):
+            # Get names_by_netid from first item for display purposes
+            names_by_netid = self.items[0].names_by_netid if self.items else None
+            show_completion_menu(self.items, names_by_netid)
+
     def _process_single_student_build(self, row):
         """Process a single student for parallel build mode. Returns (net_ids, success, message, log_path)."""
         first_names = grades_csv.get_first_names(row)
@@ -896,7 +924,10 @@ class Grader:
         student_work_path.mkdir(parents=True, exist_ok=True)
 
         # Clone student repo
-        print("Student repo url: " + row["github_url"], file=output)
+        https_url = student_repos.convert_github_url_format(
+            row["github_url"], to_https=True
+        )
+        print("Student repo url: " + https_url, file=output)
         if not student_repos.clone_repo(
             row["github_url"], self.github_tag, student_work_path, output=output
         ):

{ygrader-2.6.5 → ygrader-2.6.7}/ygrader/grading_item.py

@@ -12,7 +12,7 @@ from .utils import (
 )
 from . import grades_csv
 from .deductions import StudentDeductions
-from .score_input import get_score, ScoreResult
+from .score_input import get_score, MenuCommand
 
 
 class GradeItem:
@@ -36,7 +36,6 @@ 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)
@@ -144,43 +143,18 @@ class GradeItem:
                 )
 
             # Verify workflow hash if configured
-            if self.grader.workflow_hash is not None:
-                student_code_path = callback_args.get("student_code_path")
-                if student_code_path:
-                    workflow_file_path = (
-                        student_code_path / ".github" / "workflows" / "submission.yml"
-                    )
-                    try:
-                        verify_workflow_hash(
-                            workflow_file_path, self.grader.workflow_hash
-                        )
-                    except WorkflowHashError as e:
-                        print("")
-                        print_color(TermColors.RED, "=" * 70)
-                        print_color(
-                            TermColors.RED,
-                            "WARNING: WORKFLOW FILE VERIFICATION FAILED!",
-                        )
-                        print_color(TermColors.RED, "=" * 70)
-                        print_color(TermColors.RED, str(e))
-                        print_color(TermColors.RED, "")
-                        print_color(
-                            TermColors.RED,
-                            "This student may have modified the GitHub workflow system.",
-                        )
-                        print_color(
-                            TermColors.RED, "The submission date CANNOT be guaranteed."
-                        )
-                        print_color(TermColors.RED, "")
-                        print_color(
-                            TermColors.RED,
-                            "Please contact the instructor before grading this student.",
-                        )
-                        print_color(TermColors.RED, "=" * 70)
-                        print("")
+            workflow_errors = []
+            student_code_path = callback_args.get("student_code_path")
+            if self.grader.workflow_hash is not None and student_code_path:
+                workflow_file_path = (
+                    student_code_path / ".github" / "workflows" / "submission.yml"
+                )
+                try:
+                    verify_workflow_hash(workflow_file_path, self.grader.workflow_hash)
+                except WorkflowHashError as e:
+                    workflow_errors.append(f"Workflow hash mismatch: {e}")
 
             # Display submission date if available and store for later late calculation
-            student_code_path = callback_args.get("student_code_path")
             # Store submission time but don't save yet - will be saved only after successful grading
             pending_submit_time = None
             if student_code_path:
@@ -188,10 +162,12 @@ class GradeItem:
                 if submission_date_path.is_file():
                     try:
                         with open(submission_date_path, encoding="utf-8") as f:
-                            submission_time = datetime.datetime.strptime(
-                                f.read().strip(),
-                                "%a %b %d %H:%M:%S %Z %Y",
-                            )
+                            date_str = f.read().strip()
+                        # Expected format from workflow: "Sun Jan 12 21:51:14 MST 2026"
+                        submission_time = datetime.datetime.strptime(
+                            date_str,
+                            "%a %b %d %H:%M:%S %Z %Y",
+                        )
                         print_color(
                             TermColors.BLUE,
                             f"Submitted: {submission_time.strftime('%Y-%m-%d %H:%M:%S')}",
@@ -199,10 +175,46 @@ class GradeItem:
                         # Store as ISO format for later late calculation
                         pending_submit_time = submission_time.isoformat()
                     except (ValueError, IOError) as e:
-                        print_color(
-                            TermColors.YELLOW,
-                            f"Could not parse submission date: {e}",
-                        )
+                        workflow_errors.append(f"Submission date parsing failed: {e}")
+
+            # Print unified warning if any workflow-related errors occurred
+            if workflow_errors:
+                print("")
+                print_color(TermColors.RED, "=" * 70)
+                print_color(
+                    TermColors.RED,
+                    "WARNING: WORKFLOW VERIFICATION FAILED!",
+                )
+                print_color(TermColors.RED, "=" * 70)
+                for err in workflow_errors:
+                    print_color(TermColors.RED, f"  - {err}")
+                print_color(TermColors.RED, "")
+                print_color(
+                    TermColors.RED,
+                    "This student may have modified the GitHub workflow system.",
+                )
+                print_color(TermColors.RED, "The submission date CANNOT be guaranteed.")
+                print_color(TermColors.RED, "")
+                print_color(
+                    TermColors.RED,
+                    "Please contact the instructor before grading this student.",
+                )
+                print_color(TermColors.RED, "=" * 70)
+                print("")
+
+                # Ask for confirmation before grading
+                while True:
+                    response = (
+                        input("Do you want to grade this student anyway? [y/n]: ")
+                        .strip()
+                        .lower()
+                    )
+                    if response in ("y", "yes"):
+                        break
+                    if response in ("n", "no"):
+                        print_color(TermColors.BLUE, "Skipping student")
+                        return False
+                    print("Please enter 'y' or 'n'")
 
             # Process callback result:
             # - None: interactive mode (prompt for deductions)
@@ -248,6 +260,7 @@ class GradeItem:
 
             # callback_result is None - interactive mode
             # Prompt with deductions mode - handles everything internally
+            self.grader.interactive_grading_occurred = True
             try:
                 score = get_score(
                     concated_names,
@@ -256,35 +269,45 @@ 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,
+                    last_graded_net_ids=self.grader.last_graded_net_ids,
                     names_by_netid=self.names_by_netid,
+                    all_items=self.grader.items,
                 )
             except KeyboardInterrupt:
                 print_color(TermColors.RED, "\nExiting")
                 sys.exit(0)
 
-            if score == ScoreResult.SKIP:
+            if score == MenuCommand.SKIP:
                 return False
-            if score == ScoreResult.REBUILD:
+            if score == MenuCommand.BUILD:
                 continue
-            if score == ScoreResult.RERUN:
+            if score == MenuCommand.RERUN:
                 # run again, but don't build
                 build = False
                 continue
-            if score == ScoreResult.EXIT:
+            if score == MenuCommand.EXIT:
                 print_color(TermColors.BLUE, "Exiting grader")
                 sys.exit(0)
-            if score == ScoreResult.UNDO_LAST:
+            if score == MenuCommand.UNDO:
                 # 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
+                if self.grader.last_graded_net_ids is not None:
+                    # Clear deductions for ALL items for the last graded student
+                    for item in self.grader.items:
+                        item.student_deductions.clear_student_deductions(
+                            self.grader.last_graded_net_ids
+                        )
+                    # Also clear any partial grades for the CURRENT student
+                    # so they start fresh when we come back to them
+                    for item in self.grader.items:
+                        item.student_deductions.clear_student_deductions(tuple(net_ids))
+                    print_color(
+                        TermColors.GREEN,
+                        f"Undid grade for {', '.join(self.grader.last_graded_net_ids)} - going back to regrade",
                     )
                     print_color(
                         TermColors.GREEN,
-                        f"Undid grade for {', '.join(self.last_graded_net_ids)} - going back to regrade",
+                        f"Also cleared partial grades for {', '.join(net_ids)}",
                     )
-                    self.last_graded_net_ids = None
                     return True  # Signal to go back to previous student
                 continue
 
@@ -295,8 +318,6 @@ class GradeItem:
                     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)
             return False  # Normal completion
 
         # If we got here via break (CallbackFailed, build_only, dry_run, etc.)

ygrader-2.6.7/ygrader/score_input.py

@@ -0,0 +1,517 @@
+"""Module for prompting users for scores during grading."""
+
+import sys
+from enum import Enum
+
+from .utils import TermColors, print_color
+
+
+class MenuCommand(Enum):
+    """Enum representing menu commands, with character as value.
+
+    Used both for defining menu keys and as return values from get_score().
+    """
+
+    SKIP = "s"
+    BUILD = "b"
+    RERUN = "r"
+    NEW_DEDUCTION = "n"
+    DELETE_DEDUCTION = "d"
+    CLEAR_DEDUCTIONS = "0"
+    CHANGE_VALUE = "v"
+    MANAGE_GRADES = "g"
+    UNDO = "u"
+    EXIT = "e"
+
+    @property
+    def key_display(self):
+        """Return the key display string like '[s]'."""
+        return f"[{self.value}]"
+
+
+def _print_menu_item(cmd, description, indent="    ", pad=10):
+    """Print a single menu item with consistent formatting."""
+    print(
+        indent
+        + TermColors.BLUE
+        + cmd.key_display.ljust(pad)
+        + TermColors.END
+        + description
+    )
+
+
+def show_completion_menu(items, names_by_netid=None):
+    """Show a menu when all students have been graded.
+
+    Allows the user to manage grades, edit deduction types, etc.
+
+    Args:
+        items: List of GradeItem objects (to access their student_deductions)
+        names_by_netid: Dict mapping net_id -> (first_name, last_name) for search
+
+    Returns:
+        True if user wants to exit, False to continue showing the menu
+    """
+    if not items:
+        print_color(TermColors.YELLOW, "No grade items configured.")
+        return True
+
+    fpad2 = " " * 4
+
+    while True:
+        # Count total graded students across all items
+        all_graded_students = set()
+        for item in items:
+            for student_key in item.student_deductions.get_graded_students():
+                all_graded_students.add(student_key)
+
+        print("")
+        print("=" * 60)
+        print_color(TermColors.GREEN, "All students have been graded!")
+        print("=" * 60)
+        print("")
+
+        # Show summary
+        print(fpad2 + f"Total students graded: {len(all_graded_students)}")
+        print("")
+
+        # Show menu
+        menu_items = [
+            (MenuCommand.MANAGE_GRADES, "Manage grades (view/delete student grades)"),
+            (MenuCommand.DELETE_DEDUCTION, "Delete deduction type"),
+            (MenuCommand.CHANGE_VALUE, "Change deduction value"),
+            (MenuCommand.EXIT, "Exit grader"),
+        ]
+        print(fpad2 + "Options:")
+        for cmd, desc in menu_items:
+            _print_menu_item(cmd, desc, fpad2)
+        print("")
+
+        txt = input(TermColors.BLUE + ">>> " + TermColors.END).strip().lower()
+
+        if txt == MenuCommand.MANAGE_GRADES.value:
+            _manage_grades_interactive(items, names_by_netid)
+        elif txt == MenuCommand.DELETE_DEDUCTION.value:
+            selected_item = _select_item_interactive(
+                items, "delete deduction type from"
+            )
+            if selected_item:
+                selected_item.student_deductions.delete_deduction_type_interactive()
+        elif txt == MenuCommand.CHANGE_VALUE.value:
+            selected_item = _select_item_interactive(
+                items, "change deduction value for"
+            )
+            if selected_item:
+                selected_item.student_deductions.change_deduction_value_interactive(
+                    max_points=selected_item.max_points
+                )
+        elif txt == MenuCommand.EXIT.value:
+            print_color(TermColors.BLUE, "Exiting grader")
+            sys.exit(0)
+        else:
+            print_color(TermColors.YELLOW, "Invalid option. Try again.")
+
+
+def _select_item_interactive(items, action_description):
+    """Prompt user to select an item when there are multiple items.
+
+    Args:
+        items: List of GradeItem objects
+        action_description: String describing the action (e.g., "delete deduction type from")
+
+    Returns:
+        Selected GradeItem, or None if cancelled
+    """
+    if len(items) == 1:
+        return items[0]
+
+    print(f"\nSelect which item to {action_description}:")
+    for i, item in enumerate(items, 1):
+        print(f"  [{i}] {item.item_name}")
+    print("  [Enter] Cancel")
+
+    txt = input("\n>>> ").strip()
+    if txt == "":
+        return None
+
+    try:
+        idx = int(txt) - 1
+        if 0 <= idx < len(items):
+            return items[idx]
+        print_color(TermColors.YELLOW, "Invalid selection.")
+        return None
+    except ValueError:
+        print_color(TermColors.YELLOW, "Invalid input.")
+        return None
+
+
+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,
+    all_items=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
+        all_items: List of all GradeItem objects (for multi-item operations like [g], [d], [v])
+
+    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
+        # Each item is (MenuCommand or None, description) - None for special items like [Enter]
+        left_items = [
+            (MenuCommand.SKIP, "Skip student"),
+        ]
+        if allow_rebuild:
+            left_items.append((MenuCommand.BUILD, "Build & run"))
+        if allow_rerun:
+            desc = "Re-run" if not allow_rebuild else "Re-run (no build)"
+            left_items.append((MenuCommand.RERUN, desc))
+        left_items.append((MenuCommand.MANAGE_GRADES, "Manage grades"))
+        if last_graded_net_ids is not None:
+            left_items.append((MenuCommand.UNDO, f"Undo last ({last_graded_net_ids[0]})"))
+        left_items.append((MenuCommand.EXIT, "Exit grader"))
+
+        right_items = [
+            (MenuCommand.NEW_DEDUCTION, "New deduction"),
+            (MenuCommand.DELETE_DEDUCTION, "Delete deduction"),
+            (MenuCommand.CLEAR_DEDUCTIONS, "Clear deductions"),
+            (MenuCommand.CHANGE_VALUE, "Change deduction value"),
+            (None, "Accept score"),  # [Enter] - special case
+        ]
+
+        # Build allowed_cmds from menu items
+        allowed_cmds = {}
+        for cmd, _ in left_items + right_items:
+            if cmd is not None:
+                allowed_cmds[cmd.value] = cmd
+
+        # 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):
+                cmd, desc = left_items[i]
+                key_str = cmd.key_display if cmd else "[Enter]"
+                col1 = (
+                    fpad2 + TermColors.BLUE + key_str.ljust(pad) + TermColors.END + desc
+                )
+                # Pad to column width (accounting for ANSI codes)
+                col1_visible_len = len(fpad2) + len(key_str.ljust(pad)) + len(desc)
+                col1_padded = col1 + " " * (col_width - col1_visible_len)
+            else:
+                col1_padded = " " * col_width
+
+            # Right column
+            if i < len(right_items):
+                cmd, desc = right_items[i]
+                key_str = cmd.key_display if cmd else "[Enter]"
+                col2 = TermColors.BLUE + key_str.ljust(pad) + TermColors.END + desc
+                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:
+            cmd = allowed_cmds[txt]
+
+            # Handle special cases that need to loop back
+            if cmd == MenuCommand.NEW_DEDUCTION:
+                deduction_id = student_deductions.create_deduction_type_interactive(
+                    max_points=max_points
+                )
+                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 cmd == MenuCommand.DELETE_DEDUCTION:
+                if all_items and len(all_items) > 1:
+                    selected_item = _select_item_interactive(
+                        all_items, "delete deduction type from"
+                    )
+                    if selected_item:
+                        selected_item.student_deductions.delete_deduction_type_interactive()
+                else:
+                    student_deductions.delete_deduction_type_interactive()
+                continue
+            if cmd == MenuCommand.CHANGE_VALUE:
+                if all_items and len(all_items) > 1:
+                    selected_item = _select_item_interactive(
+                        all_items, "change deduction value for"
+                    )
+                    if selected_item:
+                        selected_item.student_deductions.change_deduction_value_interactive(
+                            max_points=selected_item.max_points
+                        )
+                else:
+                    student_deductions.change_deduction_value_interactive(
+                        max_points=max_points
+                    )
+                continue
+            if cmd == MenuCommand.MANAGE_GRADES:
+                if all_items:
+                    _manage_grades_interactive(all_items, names_by_netid)
+                else:
+                    # Fallback for single item - wrap in list
+                    # Create a minimal item-like object for backwards compatibility
+                    class _SingleItemWrapper:
+                        def __init__(self, sd):
+                            self.student_deductions = sd
+
+                    _manage_grades_interactive(
+                        [_SingleItemWrapper(student_deductions)], names_by_netid
+                    )
+                continue
+
+            # Commands that return directly (SKIP, BUILD, RERUN, UNDO, EXIT)
+            return cmd
+
+        # Check for clear command (must be exactly "0", not in a list)
+        if txt == MenuCommand.CLEAR_DEDUCTIONS.value:
+            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(all_items, names_by_netid=None):
+    """Interactive menu to manage (view/delete) grades for any student.
+
+    Args:
+        all_items: List of GradeItem objects (to access their student_deductions)
+        names_by_netid: Dict mapping net_id -> (first_name, last_name) for search
+    """
+    while True:
+        # Collect graded students from ALL items
+        all_graded_students = set()
+        for item in all_items:
+            for student_key in item.student_deductions.get_graded_students():
+                all_graded_students.add(student_key)
+
+        print("\n" + "=" * 60)
+        print_color(TermColors.BLUE, "Manage Grades")
+        print("=" * 60)
+
+        if not all_graded_students:
+            print("No students have been graded yet.")
+            input("Press Enter to continue...")
+            return
+
+        print(f"{len(all_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 all_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
+        # Show combined deduction info from all items
+        print(f"\nFound {len(matches)} match(es):")
+        for i, (net_ids, display) in enumerate(matches, 1):
+            total_deductions = 0
+            total_items_graded = 0
+            total_deduction_count = 0
+            for item in all_items:
+                if item.student_deductions.is_student_graded(net_ids):
+                    total_items_graded += 1
+                    total_deductions += item.student_deductions.total_deductions(
+                        net_ids
+                    )
+                    total_deduction_count += len(
+                        item.student_deductions.get_student_deductions(net_ids)
+                    )
+            # Format differently based on single vs multiple items
+            if len(all_items) == 1:
+                print(
+                    f"  [{i}] {display} "
+                    f"({total_deduction_count} deduction(s), -{total_deductions} pts)"
+                )
+            else:
+                print(
+                    f"  [{i}] {display} "
+                    f"(graded in {total_items_graded} item(s), -{total_deductions} pts total)"
+                )
+
+        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} from ALL items? This cannot be undone. [y/N]: "
+                    )
+                    .strip()
+                    .lower()
+                )
+
+                if confirm == "y":
+                    # Delete from ALL items
+                    for item in all_items:
+                        item.student_deductions.clear_student_deductions(student_key)
+                    print_color(
+                        TermColors.GREEN, f"Deleted grade for {display} from all items"
+                    )
+                else:
+                    print("Cancelled.")
+            else:
+                print_color(TermColors.YELLOW, "Invalid selection.")
+        except ValueError:
+            print_color(TermColors.YELLOW, "Invalid input.")

{ygrader-2.6.5 → ygrader-2.6.7/ygrader.egg-info}/PKG-INFO

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

@@ -1,343 +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()
-    UNDO_LAST = auto()
-    EXIT = 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"))
-
-        right_items.append(("[v]", "Change deduction value"))
-        allowed_cmds["v"] = "change_value"
-
-        # 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 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 = (
-            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(
-                    max_points=max_points
-                )
-                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 == "change_value":
-                student_deductions.change_deduction_value_interactive(
-                    max_points=max_points
-                )
-                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.")