ygrader 2.6.11__tar.gz → 2.6.13__tar.gz

{ygrader-2.6.11/ygrader.egg-info → ygrader-2.6.13}/PKG-INFO

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

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

{ygrader-2.6.11 → ygrader-2.6.13}/ygrader/deductions.py

@@ -158,7 +158,7 @@ class StudentDeductions:
                         "net_ids": FlowList(student_key),
                         "deductions": FlowList(deduction_ids),
                         **(
-                            {"submit_time": self.submit_time_by_students[student_key]}
+                            {"submit_time": self.submit_time_by_students.get(student_key)}
                             if student_key in self.submit_time_by_students
                             else {}
                         ),
@@ -502,29 +502,35 @@ class StudentDeductions:
             self._save()
 
     def is_student_graded(self, net_ids: tuple) -> bool:
-        """Check if a student has been graded (is in the deductions file).
+        """Check if a student has been graded (grading was finalized).
+
+        A student is considered graded only if they have a submit_time set,
+        which indicates grading was finalized (Enter was pressed).
+
+        This prevents students with partial/pending deductions (from a crash before
+        pressing Enter) from being considered "graded".
 
         Args:
             net_ids: Tuple of net_ids for the student.
 
         Returns:
-            True if the student is in the deductions file (graded), False otherwise.
+            True if the student's grading was finalized, False otherwise.
         """
         student_key = tuple(net_ids) if not isinstance(net_ids, tuple) else net_ids
-        return student_key in self.deductions_by_students
+        return student_key in self.submit_time_by_students
 
     def set_submit_time(self, net_ids: tuple, submit_time: Optional[str]):
         """Set the submission time for a student.
 
+        This also marks the student as graded (grading finalized).
+        The submit_time can be None if no submission time is available.
+
         Args:
             net_ids: Tuple of net_ids for the student.
-            submit_time: ISO format timestamp string, or None to remove.
+            submit_time: ISO format timestamp string, or None if not available.
         """
         student_key = tuple(net_ids) if not isinstance(net_ids, tuple) else net_ids
-        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.submit_time_by_students[student_key] = submit_time
         self._save()
 
     def get_submit_time(self, net_ids: tuple) -> Optional[str]:

{ygrader-2.6.11 → ygrader-2.6.13}/ygrader/grader.py

@@ -512,124 +512,135 @@ class Grader:
 
         # 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
-        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)
-            concated_names = grades_csv.get_concated_names(row)
-
-            # Check if student/group needs grading
-            num_group_members_need_grade_per_item = [
-                item.num_grades_needed_deductions(net_ids) for item in self.items
-            ]
 
-            if sum(num_group_members_need_grade_per_item) == 0:
-                # This student/group is already fully graded
-                idx += 1
-                continue
+        # Outer loop to allow re-grading after deleting from completion menu
+        while True:
+            idx = 0
+            prev_idx = None  # Track previous student index for undo
+
+            # Loop through all of the students/groups and perform grading
+            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)
+                concated_names = grades_csv.get_concated_names(row)
+
+                # Check if student/group needs grading
+                num_group_members_need_grade_per_item = [
+                    item.num_grades_needed_deductions(net_ids) for item in self.items
+                ]
+
+                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
-            student_work_path = self.work_path / utils.names_to_dir(
-                first_names, last_names, net_ids
-            )
-            print_color(
-                TermColors.PURPLE,
-                "\nGrading: ",
-                concated_names,
-                "-",
-                student_work_path.relative_to(self.work_path.parent),
-            )
+                # Print name(s) of who we are grading
+                student_work_path = self.work_path / utils.names_to_dir(
+                    first_names, last_names, net_ids
+                )
+                print_color(
+                    TermColors.PURPLE,
+                    "\nGrading: ",
+                    concated_names,
+                    "-",
+                    student_work_path.relative_to(self.work_path.parent),
+                )
 
-            # Get student code from zip or github.  If this fails it returns False.
-            # 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
+                # Get student code from zip or github.  If this fails it returns False.
+                # 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
-            if self.format_code:
-                print_color(TermColors.BLUE, "Formatting code")
-                utils.clang_format_code(student_work_path)
+                # Format student code
+                if self.format_code:
+                    print_color(TermColors.BLUE, "Formatting code")
+                    utils.clang_format_code(student_work_path)
+
+                callback_args = {}
+                callback_args["lab_name"] = self.lab_name
+                callback_args["student_code_path"] = student_work_path
+                callback_args["run"] = not self.build_only
+                callback_args["first_names"] = first_names
+                callback_args["last_names"] = last_names
+                callback_args["net_ids"] = net_ids
+                callback_args["output"] = sys.stdout  # Default to stdout in sequential mode
+                if self.code_source == CodeSource.GITHUB:
+                    callback_args["repo_url"] = row["github_url"]
+                    callback_args["tag"] = self.github_tag
+                if "Section Number" in row:
+                    callback_args["section"] = row["Section Number"]
+                if "Course Homework ID" in row:
+                    callback_args["homework_id"] = row["Course Homework ID"]
+
+                if self.prep_fcn is not None:
+                    try:
+                        self.prep_fcn(
+                            **callback_args,
+                            build=not self.run_only,
+                        )
+                    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:
+                    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
+                    self.last_graded_net_ids = None  # Clear since we're undoing
+                    continue
 
-            callback_args = {}
-            callback_args["lab_name"] = self.lab_name
-            callback_args["student_code_path"] = student_work_path
-            callback_args["run"] = not self.build_only
-            callback_args["first_names"] = first_names
-            callback_args["last_names"] = last_names
-            callback_args["net_ids"] = net_ids
-            callback_args["output"] = sys.stdout  # Default to stdout in sequential mode
-            if self.code_source == CodeSource.GITHUB:
-                callback_args["repo_url"] = row["github_url"]
-                callback_args["tag"] = self.github_tag
-            if "Section Number" in row:
-                callback_args["section"] = row["Section Number"]
-            if "Course Homework ID" in row:
-                callback_args["homework_id"] = row["Course Homework ID"]
-
-            if self.prep_fcn is not None:
-                try:
-                    self.prep_fcn(
-                        **callback_args,
-                        build=not self.run_only,
+                # 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,
+                        "'dry_run_first' is set, so exiting after first student.",
                     )
-                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:
-                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
-                self.last_graded_net_ids = None  # Clear since we're undoing
-                continue
+                    break
+
+                # Move to next student and remember this one for potential undo
+                prev_idx = idx
+                idx += 1
 
-            # Track this student as last graded (only if all items completed normally)
+            # Show completion menu when all students are done (unless disabled or in special modes)
+            # If a grade is deleted from the menu, re-run the grading loop
             if (
-                not go_back
-                and not self.build_only
-                and not self.dry_run_first
-                and not self.dry_run_all
+                not self.show_completion_menu
+                or self.build_only
+                or self.dry_run_first
+                or self.dry_run_all
             ):
-                self.last_graded_net_ids = tuple(net_ids)
-
-            if self.dry_run_first:
-                print_color(
-                    TermColors.YELLOW,
-                    "'dry_run_first' is set, so exiting after first student.",
-                )
-                break
+                break  # Exit outer loop - no completion menu
 
-            # Move to next student and remember this one for potential undo
-            prev_idx = idx
-            idx += 1
-
-        # Show completion menu when all students are done (unless disabled or in special modes)
-        if (
-            self.show_completion_menu
-            and not self.build_only
-            and not self.dry_run_first
-            and not self.dry_run_all
-        ):
             # Get names_by_netid from first item for display purposes
             names_by_netid = self.items[0].names_by_netid if self.items else None
-            display_completion_menu(self.items, names_by_netid)
+            if display_completion_menu(self.items, names_by_netid):
+                # A grade was deleted, continue outer loop to re-run grading
+                self.last_graded_net_ids = None
+                continue
+            # User exited normally
+            break
 
     def _process_single_student_build(self, row):
         """Process a single student for parallel build mode. Returns (net_ids, success, message, log_path)."""

{ygrader-2.6.11 → ygrader-2.6.13}/ygrader/grading_item.py

@@ -243,10 +243,10 @@ class GradeItem:
                             f"Applied deduction: {deduction_desc} (-{deduction_points})",
                         )
                     # Save submit_time now that grading succeeded
-                    if pending_submit_time is not None:
-                        self.student_deductions.set_submit_time(
-                            tuple(net_ids), pending_submit_time
-                        )
+                    # (may be None if no .commitdate file exists)
+                    self.student_deductions.set_submit_time(
+                        tuple(net_ids), pending_submit_time
+                    )
                     # Ensure student is in the deductions file
                     self.student_deductions.ensure_student_in_file(tuple(net_ids))
                     break
@@ -312,10 +312,8 @@ class GradeItem:
 
             # Record score - save submit_time and ensure the student is in the deductions file
             # (even if they have no deductions, to indicate they were graded)
-            if pending_submit_time is not None:
-                self.student_deductions.set_submit_time(
-                    tuple(net_ids), pending_submit_time
-                )
+            # submit_time may be None if no .commitdate file exists
+            self.student_deductions.set_submit_time(tuple(net_ids), pending_submit_time)
             self.student_deductions.ensure_student_in_file(tuple(net_ids))
             return False  # Normal completion
 

{ygrader-2.6.11 → ygrader-2.6.13}/ygrader/score_input.py

@@ -50,7 +50,8 @@ def display_completion_menu(items, names_by_netid=None):
         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
+        True if a grade was deleted (caller should re-run grading loop),
+        False otherwise (user exited normally)
     """
     if not items:
         print_color(TermColors.YELLOW, "No grade items configured.")
@@ -90,7 +91,9 @@ def display_completion_menu(items, names_by_netid=None):
         txt = input(TermColors.BLUE + ">>> " + TermColors.END).strip().lower()
 
         if txt == MenuCommand.MANAGE_GRADES.value:
-            _manage_grades_interactive(items, names_by_netid)
+            if _manage_grades_interactive(items, names_by_netid):
+                # A grade was deleted, signal caller to re-run grading
+                return True
         elif txt == MenuCommand.DELETE_DEDUCTION.value:
             selected_item = _select_item_interactive(
                 items, "delete deduction type from"
@@ -387,6 +390,9 @@ def _manage_grades_interactive(all_items, names_by_netid=None):
     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
+
+    Returns:
+        True if a grade was deleted, False otherwise
     """
     while True:
         # Collect graded students from ALL items
@@ -402,7 +408,7 @@ def _manage_grades_interactive(all_items, names_by_netid=None):
         if not all_graded_students:
             print("No students have been graded yet.")
             input("Press Enter to continue...")
-            return
+            return False
 
         print(f"{len(all_graded_students)} student(s) graded.")
         print("\nOptions:")
@@ -413,7 +419,7 @@ def _manage_grades_interactive(all_items, names_by_netid=None):
         txt = input("\nSearch: ").strip()
 
         if txt == "":
-            return
+            return False
 
         # Check for wildcard to list all
         list_all = txt == "*"
@@ -487,7 +493,7 @@ def _manage_grades_interactive(all_items, names_by_netid=None):
         choice = input("\n>>> ").strip()
 
         if choice == "":
-            continue
+            return False
 
         try:
             idx = int(choice) - 1
@@ -509,8 +515,8 @@ def _manage_grades_interactive(all_items, names_by_netid=None):
                     print_color(
                         TermColors.GREEN, f"Deleted grade for {display} from all items"
                     )
-                else:
-                    print("Cancelled.")
+                    return True  # Signal that a grade was deleted
+                print("Cancelled.")
             else:
                 print_color(TermColors.YELLOW, "Invalid selection.")
         except ValueError:

{ygrader-2.6.11 → ygrader-2.6.13}/ygrader/utils.py

@@ -8,6 +8,7 @@ import subprocess
 import hashlib
 import time
 import os
+import shlex
 
 
 class TermColors:
@@ -163,6 +164,26 @@ def is_wsl():
 _FOCUS_WARNING_PRINTED = False
 
 
+def opener(file_path, sleep_time=1.0):
+    """Open a file using VS Code or a custom opener defined in the OPENER environment variable.
+
+    Parameters
+    ----------
+    file_path: pathlib.Path or str
+        Path to the file to open
+    sleep_time: float, optional
+        Time in seconds to wait for the editor to open (default: 1.0)
+    """
+    if "OPENER" not in os.environ:
+        open_file_in_vscode(file_path, sleep_time)
+    else:
+        subprocess.run(
+            f'{os.environ["OPENER"]} {shlex.quote(str(file_path))}',
+            shell=True,
+            check=False,
+        )
+
+
 def open_file_in_vscode(file_path, sleep_time=1.0):
     """Open a file in VS Code and return focus to terminal.
 

{ygrader-2.6.11 → ygrader-2.6.13/ygrader.egg-info}/PKG-INFO

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