ygrader 2.5.0__tar.gz → 2.5.2__tar.gz

{ygrader-2.5.0/ygrader.egg-info → ygrader-2.5.2}/PKG-INFO

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

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

{ygrader-2.5.0 → ygrader-2.5.2}/ygrader/deductions.py

@@ -214,9 +214,14 @@ class StudentDeductions:
         # Not found, create a new one
         return self.add_deduction_type(message, points)
 
-    def create_deduction_type_interactive(self) -> int:
+    def create_deduction_type_interactive(
+        self, max_points: Optional[float] = None
+    ) -> int:
         """Interactively prompt the user to create a new deduction type.
 
+        Args:
+            max_points: Optional maximum points for validation.
+
         Returns:
             The ID of the created deduction type, or -1 if cancelled.
         """
@@ -236,6 +241,18 @@ class StudentDeductions:
                 return -1
             try:
                 points = float(points_str)
+                if points < 0:
+                    print_color(
+                        TermColors.YELLOW,
+                        "Deduction cannot be negative. Try again.",
+                    )
+                    continue
+                if max_points is not None and points > max_points:
+                    print_color(
+                        TermColors.YELLOW,
+                        f"Deduction ({points}) cannot exceed max points ({max_points}). Try again.",
+                    )
+                    continue
                 break
             except ValueError:
                 print("Invalid number. Try again.")
@@ -330,6 +347,95 @@ class StudentDeductions:
         print(f"Deleted deduction type [{deduction_id}]: {deduction_type.message}")
         return True
 
+    def change_deduction_value(self, deduction_id: int, new_points: float) -> bool:
+        """Change the point value of an existing deduction type.
+
+        Args:
+            deduction_id: The ID of the deduction type to modify.
+            new_points: The new point value.
+
+        Returns:
+            True if successful, False if deduction_id not found.
+        """
+        if deduction_id not in self.deduction_types:
+            return False
+
+        self.deduction_types[deduction_id].points = new_points
+        self._save()
+        return True
+
+    def change_deduction_value_interactive(
+        self, max_points: Optional[float] = None
+    ) -> bool:
+        """Interactively prompt the user to change a deduction type's point value.
+
+        Args:
+            max_points: Optional maximum points for validation.
+
+        Returns:
+            True if a deduction value was changed, False otherwise.
+        """
+        if not self.deduction_types:
+            print("No deduction types to modify.")
+            return False
+
+        print("\nChange deduction value (empty input to cancel):")
+        print("Available deduction types:")
+        for deduction_id, deduction_type in self.deduction_types.items():
+            in_use = " (IN USE)" if self.is_deduction_in_use(deduction_id) else ""
+            print(
+                f"  [{deduction_id}] -{deduction_type.points}: {deduction_type.message}{in_use}"
+            )
+
+        id_str = input("  Enter ID to modify: ").strip()
+        if not id_str:
+            print("Cancelled.")
+            return False
+
+        try:
+            deduction_id = int(id_str)
+        except ValueError:
+            print("Invalid ID.")
+            return False
+
+        if deduction_id not in self.deduction_types:
+            print("Deduction type not found.")
+            return False
+
+        deduction_type = self.deduction_types[deduction_id]
+        print(f"  Current value: {deduction_type.points} points")
+
+        while True:
+            points_str = input("  Enter new points value: ").strip()
+            if not points_str:
+                print("Cancelled.")
+                return False
+
+            try:
+                new_points = float(points_str)
+                if new_points < 0:
+                    print_color(
+                        TermColors.YELLOW,
+                        "Deduction cannot be negative. Try again.",
+                    )
+                    continue
+                if max_points is not None and new_points > max_points:
+                    print_color(
+                        TermColors.YELLOW,
+                        f"Deduction ({new_points}) cannot exceed max points ({max_points}). Try again.",
+                    )
+                    continue
+                break
+            except ValueError:
+                print("Invalid number. Try again.")
+
+        old_points = deduction_type.points
+        self.change_deduction_value(deduction_id, new_points)
+        print(
+            f"Changed deduction [{deduction_id}] from {old_points} to {new_points} points"
+        )
+        return True
+
     def get_student_deductions(self, net_ids: tuple) -> List[DeductionType]:
         """Get the list of deductions applied to a student.
 

{ygrader-2.5.0 → ygrader-2.5.2}/ygrader/feedback.py

@@ -154,10 +154,13 @@ def _calculate_student_score(
         Tuple of (final_score, total_possible, submitted_datetime or None if on time).
     """
     total_possible = sum(item.points for item in ls_column.items)
-    total_deductions = 0.0
+    total_score = 0.0
 
     for item in ls_column.items:
         deductions_obj = item_deductions.get(item.name)
+        student_graded = False
+        item_deduction_total = 0.0
+
         if deductions_obj:
             # Find the student's deductions
             student_key = None
@@ -170,12 +173,18 @@ def _calculate_student_score(
                         break
 
             if student_key:
+                student_graded = True
                 deductions = deductions_obj.deductions_by_students[student_key]
                 for deduction in deductions:
-                    total_deductions += deduction.points
+                    item_deduction_total += deduction.points
+
+        # Only award points if the student was graded for this item
+        if student_graded:
+            total_score += max(0, item.points - item_deduction_total)
+        # else: student gets 0 for this item (not graded)
 
-    # Calculate score before late penalty
-    score = max(0, total_possible - total_deductions)
+    # Score is already calculated
+    score = total_score
 
     # Get submit info
     _, effective_due_date, submitted_datetime = _get_student_key_and_submit_info(
@@ -290,8 +299,10 @@ def assemble_grades(
                 )
 
             # Get submit info for this student
-            _, effective_due_date, submitted_datetime = _get_student_key_and_submit_info(
-                net_id, subitem_deductions, due_date, due_date_exceptions
+            _, effective_due_date, submitted_datetime = (
+                _get_student_key_and_submit_info(
+                    net_id, subitem_deductions, due_date, due_date_exceptions
+                )
             )
 
             # Calculate score before late penalty
@@ -421,7 +432,8 @@ def _generate_student_feedback(
         total_points_possible += subitem_points_possible
 
         subitem_points_deducted = 0
-        item_deductions = []
+        item_deduction_list = []
+        student_graded = False
 
         # Get deductions for this student in this item
         student_deductions_obj = subitem_deductions.get(item.name)
@@ -438,13 +450,19 @@ def _generate_student_feedback(
                         break
 
             if student_key:
+                student_graded = True
                 deductions = student_deductions_obj.deductions_by_students[student_key]
                 for deduction in deductions:
-                    item_deductions.append((deduction.message, deduction.points))
+                    item_deduction_list.append((deduction.message, deduction.points))
                     subitem_points_deducted += deduction.points
 
-        # Calculate item score
-        subitem_score = max(0, subitem_points_possible - subitem_points_deducted)
+        # Calculate item score (0 if not graded)
+        if student_graded:
+            subitem_score = max(0, subitem_points_possible - subitem_points_deducted)
+        else:
+            subitem_score = 0
+            item_deduction_list.append(("Not graded", subitem_points_possible))
+            subitem_points_deducted = subitem_points_possible
         score_str = f"{subitem_score:.1f} / {subitem_points_possible:.1f}"
 
         # Item line with score
@@ -454,7 +472,7 @@ def _generate_student_feedback(
         )
 
         # Deduction lines (indented)
-        for msg, pts in item_deductions:
+        for msg, pts in item_deduction_list:
             # Wrap long messages
             wrapped = _wrap_text(msg, deduction_msg_width)
             for i, line_text in enumerate(wrapped):
@@ -485,12 +503,17 @@ def _generate_student_feedback(
         and effective_due_date is not None
     ):
         final_score = late_penalty_callback(
-            effective_due_date, submitted_datetime, total_points_possible, score_before_late
+            effective_due_date,
+            submitted_datetime,
+            total_points_possible,
+            score_before_late,
         )
         # Ensure final score is not negative
         final_score = max(0, final_score)
         late_penalty_points = score_before_late - final_score
-        late_label = f"Late Penalty (submitted {submitted_datetime.strftime('%Y-%m-%d %H:%M')}):"
+        late_label = (
+            f"Late Penalty (submitted {submitted_datetime.strftime('%Y-%m-%d %H:%M')}):"
+        )
         lines.append(
             f"{late_label:<{item_col_width}} {-late_penalty_points:>{score_col_width}.1f}"
         )

{ygrader-2.5.0 → ygrader-2.5.2}/ygrader/grading_item.py

@@ -37,12 +37,15 @@ class GradeItem:
         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)
+        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)
@@ -51,7 +54,11 @@ class GradeItem:
                     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):
+                    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
@@ -259,6 +266,9 @@ class GradeItem:
                 # run again, but don't build
                 build = False
                 continue
+            if score == ScoreResult.EXIT:
+                print_color(TermColors.BLUE, "Exiting grader")
+                sys.exit(0)
             if score == ScoreResult.UNDO_LAST:
                 # Undo the last graded student and signal to go back
                 if self.last_graded_net_ids is not None:
@@ -276,7 +286,9 @@ 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)
+                self.student_deductions.set_submit_time(
+                    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)

{ygrader-2.5.0 → ygrader-2.5.2}/ygrader/score_input.py

@@ -13,6 +13,7 @@ class ScoreResult(Enum):
     RERUN = auto()
     CREATE_DEDUCTION = auto()
     UNDO_LAST = auto()
+    EXIT = auto()
 
 
 def get_score(
@@ -55,8 +56,7 @@ def get_score(
         # 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}"
+            fpad2 + f"Current score: {TermColors.GREEN}{computed_score}{TermColors.END}"
         )
         print(fpad2 + "Current deductions:")
         if current_deductions:
@@ -92,6 +92,9 @@ def get_score(
 
         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"))
 
@@ -99,11 +102,15 @@ def get_score(
         left_items.append(("[g]", "Manage grades"))
         allowed_cmds["g"] = "manage"
 
-        # Add undo option last if there's a last graded student
+        # 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 = (
@@ -163,7 +170,9 @@ def get_score(
 
             # Handle special cases that need to loop back
             if result == "create":
-                deduction_id = student_deductions.create_deduction_type_interactive()
+                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(
@@ -173,6 +182,11 @@ def get_score(
             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
@@ -269,7 +283,10 @@ def _manage_grades_interactive(student_deductions, names_by_netid=None):
                 # 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()):
+                    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:
@@ -309,9 +326,11 @@ def _manage_grades_interactive(student_deductions, names_by_netid=None):
             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()
+                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)

{ygrader-2.5.0 → ygrader-2.5.2/ygrader.egg-info}/PKG-INFO

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