ygrader 2.0.0__tar.gz → 2.2.0__tar.gz

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

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

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

{ygrader-2.0.0 → ygrader-2.2.0}/ygrader/__init__.py

@@ -7,4 +7,4 @@ from .grading_item_config import (
     LearningSuiteColumn,
     LearningSuiteColumnParseError,
 )
-from .feedback import generate_feedback_zip
+from .feedback import assemble_grades

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

@@ -44,7 +44,7 @@ class StudentDeductions:
 
     def __init__(self, yaml_path: Optional[pathlib.Path] = None):
         self.deductions_by_students = {}
-        self.days_late_by_students = {}
+        self.submit_time_by_students = {}  # ISO format timestamp strings
         self.deduction_types = {}
         self.yaml_path = yaml_path
 
@@ -102,9 +102,9 @@ class StudentDeductions:
 
                 self.deductions_by_students[student_key] = deduction_items
 
-                # Load days_late if present
-                if "days_late" in entry:
-                    self.days_late_by_students[student_key] = entry["days_late"]
+                # Load submit_time if present
+                if "submit_time" in entry:
+                    self.submit_time_by_students[student_key] = entry["submit_time"]
 
     def _write_yaml(self):
         """Write deduction types and student deductions to the YAML file.
@@ -134,9 +134,9 @@ class StudentDeductions:
                 )
             data["deduction_types"] = deduction_list
 
-        # Write student deductions (include students with deductions OR days_late)
+        # Write student deductions (include students with deductions OR submit_time)
         all_student_keys = set(self.deductions_by_students.keys()) | set(
-            self.days_late_by_students.keys()
+            self.submit_time_by_students.keys()
         )
         # Sort student keys for consistent output ordering
         sorted_student_keys = sorted(all_student_keys)
@@ -158,8 +158,8 @@ class StudentDeductions:
                         "net_ids": FlowList(student_key),
                         "deductions": FlowList(deduction_ids),
                         **(
-                            {"days_late": self.days_late_by_students[student_key]}
-                            if student_key in self.days_late_by_students
+                            {"submit_time": self.submit_time_by_students[student_key]}
+                            if student_key in self.submit_time_by_students
                             else {}
                         ),
                     }
@@ -375,8 +375,8 @@ class StudentDeductions:
         student_key = tuple(net_ids) if not isinstance(net_ids, tuple) else net_ids
         if student_key in self.deductions_by_students:
             del self.deductions_by_students[student_key]
-        if student_key in self.days_late_by_students:
-            del self.days_late_by_students[student_key]
+        if student_key in self.submit_time_by_students:
+            del self.submit_time_by_students[student_key]
         self._save()
 
     def ensure_student_in_file(self, net_ids: tuple):
@@ -405,31 +405,31 @@ class StudentDeductions:
         student_key = tuple(net_ids) if not isinstance(net_ids, tuple) else net_ids
         return student_key in self.deductions_by_students
 
-    def set_days_late(self, net_ids: tuple, days_late: int):
-        """Set the number of days late for a student.
+    def set_submit_time(self, net_ids: tuple, submit_time: Optional[str]):
+        """Set the submission time for a student.
 
         Args:
             net_ids: Tuple of net_ids for the student.
-            days_late: Number of business days late (0 or None to remove).
+            submit_time: ISO format timestamp string, or None to remove.
         """
         student_key = tuple(net_ids) if not isinstance(net_ids, tuple) else net_ids
-        if days_late and days_late > 0:
-            self.days_late_by_students[student_key] = days_late
-        elif student_key in self.days_late_by_students:
-            del self.days_late_by_students[student_key]
+        if submit_time:
+            self.submit_time_by_students[student_key] = submit_time
+        elif student_key in self.submit_time_by_students:
+            del self.submit_time_by_students[student_key]
         self._save()
 
-    def get_days_late(self, net_ids: tuple) -> Optional[int]:
-        """Get the number of days late for a student.
+    def get_submit_time(self, net_ids: tuple) -> Optional[str]:
+        """Get the submission time for a student.
 
         Args:
             net_ids: Tuple of net_ids for the student.
 
         Returns:
-            Number of business days late, or None if not set/on time.
+            ISO format timestamp string, or None if not set.
         """
         student_key = tuple(net_ids) if not isinstance(net_ids, tuple) else net_ids
-        return self.days_late_by_students.get(student_key)
+        return self.submit_time_by_students.get(student_key)
 
     def total_deductions(self, net_ids: Optional[tuple] = None) -> float:
         """Calculate the total deductions for a student or all students.

ygrader-2.2.0/ygrader/feedback.py

@@ -0,0 +1,476 @@
+"""Module for generating student feedback files and grades CSV."""
+
+import datetime
+import pathlib
+import zipfile
+from typing import Callable, Dict, Optional, Tuple
+
+import numpy as np
+import pandas
+
+from .deductions import StudentDeductions
+from .grading_item_config import LearningSuiteColumn
+from .utils import warning, print_color, TermColors
+
+
+# Type alias for late penalty callback: (late_days, max_score, actual_score) -> new_score
+LatePenaltyCallback = Callable[[int, float, float], float]
+
+
+def _calculate_late_days(
+    submit_time_str: Optional[str],
+    due_date: datetime.datetime,
+) -> int:
+    """Calculate the number of business days late from a submit time.
+
+    Args:
+        submit_time_str: ISO format timestamp string of submission.
+        due_date: The effective due date for the student.
+
+    Returns:
+        Number of business days late (0 if on time or no submit time).
+    """
+    if not submit_time_str:
+        return 0
+
+    try:
+        submit_time = datetime.datetime.fromisoformat(submit_time_str)
+    except ValueError:
+        return 0
+
+    if submit_time <= due_date:
+        return 0
+
+    days_late = np.busday_count(due_date.date(), submit_time.date())
+    if days_late == 0:
+        days_late = 1  # Same day but after deadline
+    return int(days_late)
+
+
+def _get_student_key_and_max_late_days(
+    net_id: str,
+    item_deductions: Dict[str, StudentDeductions],
+    due_date: Optional[datetime.datetime] = None,
+    due_date_exceptions: Optional[Dict[str, datetime.datetime]] = None,
+) -> tuple:
+    """Find the student key and maximum late days across all items.
+
+    Args:
+        net_id: The student's net ID.
+        item_deductions: Mapping from item name to StudentDeductions.
+        due_date: The default due date for the assignment.
+        due_date_exceptions: Mapping from net_id to exception due date.
+
+    Returns:
+        Tuple of (student_key or None, max_late_days).
+    """
+    max_late_days = 0
+    found_student_key = None
+
+    if due_date_exceptions is None:
+        due_date_exceptions = {}
+
+    for deductions_obj in item_deductions.values():
+        if not deductions_obj:
+            continue
+
+        # Find the student key
+        student_key = None
+        if (net_id,) in deductions_obj.deductions_by_students:
+            student_key = (net_id,)
+        elif (net_id,) in deductions_obj.submit_time_by_students:
+            student_key = (net_id,)
+        else:
+            # Check for multi-student keys containing this net_id
+            for key in set(deductions_obj.deductions_by_students.keys()) | set(
+                deductions_obj.submit_time_by_students.keys()
+            ):
+                if net_id in key:
+                    student_key = key
+                    break
+
+        if student_key:
+            found_student_key = student_key
+
+            # Calculate late days from submit_time if we have a due date
+            if due_date is not None:
+                submit_time_str = deductions_obj.submit_time_by_students.get(
+                    student_key
+                )
+                if submit_time_str:
+                    # Calculate effective due date (using most generous exception for group)
+                    effective_due_date = due_date
+                    for member_net_id in student_key:
+                        if member_net_id in due_date_exceptions:
+                            effective_due_date = max(
+                                effective_due_date, due_date_exceptions[member_net_id]
+                            )
+
+                    days_late = _calculate_late_days(
+                        submit_time_str, effective_due_date
+                    )
+                    max_late_days = max(max_late_days, days_late)
+
+    return found_student_key, max_late_days
+
+
+def _calculate_student_score(
+    net_id: str,
+    ls_column: LearningSuiteColumn,
+    item_deductions: Dict[str, StudentDeductions],
+    *,
+    late_penalty_callback: Optional[LatePenaltyCallback] = None,
+    warn_on_missing_callback: bool = True,
+    due_date: Optional[datetime.datetime] = None,
+    due_date_exceptions: Optional[Dict[str, datetime.datetime]] = None,
+) -> Tuple[float, float, int]:
+    """Calculate a student's final score.
+
+    Args:
+        net_id: The student's net ID.
+        ls_column: The LearningSuiteColumn configuration.
+        item_deductions: Mapping from item name to StudentDeductions.
+        late_penalty_callback: Optional callback for late penalty.
+        warn_on_missing_callback: Whether to warn if late days found but no callback.
+        due_date: The default due date for the assignment.
+        due_date_exceptions: Mapping from net_id to exception due date.
+
+    Returns:
+        Tuple of (final_score, total_possible, max_late_days).
+    """
+    total_possible = sum(item.points for item in ls_column.items)
+    total_deductions = 0.0
+
+    for item in ls_column.items:
+        deductions_obj = item_deductions.get(item.name)
+        if deductions_obj:
+            # Find the student's deductions
+            student_key = None
+            if (net_id,) in deductions_obj.deductions_by_students:
+                student_key = (net_id,)
+            else:
+                for key in deductions_obj.deductions_by_students.keys():
+                    if net_id in key:
+                        student_key = key
+                        break
+
+            if student_key:
+                deductions = deductions_obj.deductions_by_students[student_key]
+                for deduction in deductions:
+                    total_deductions += deduction.points
+
+    # Calculate score before late penalty
+    score = max(0, total_possible - total_deductions)
+
+    # Get max late days
+    _, max_late_days = _get_student_key_and_max_late_days(
+        net_id, item_deductions, due_date, due_date_exceptions
+    )
+
+    # Apply late penalty if applicable
+    if max_late_days > 0:
+        if late_penalty_callback:
+            score = max(0, late_penalty_callback(max_late_days, total_possible, score))
+        elif warn_on_missing_callback:
+            warning(
+                f"Student {net_id} has {max_late_days} late day(s) but no late penalty callback provided"
+            )
+
+    return score, total_possible, max_late_days
+
+
+def assemble_grades(
+    yaml_path: pathlib.Path,
+    class_list_csv_path: pathlib.Path,
+    subitem_feedback_paths: Dict[str, pathlib.Path],
+    *,
+    output_zip_path: Optional[pathlib.Path] = None,
+    output_csv_path: Optional[pathlib.Path] = None,
+    late_penalty_callback: Optional[LatePenaltyCallback] = None,
+    due_date: Optional[datetime.datetime] = None,
+    due_date_exceptions: Optional[Dict[str, datetime.datetime]] = None,
+) -> Tuple[Optional[pathlib.Path], Optional[pathlib.Path]]:
+    """Generate feedback zip and/or grades CSV from deductions.
+
+    Args:
+        yaml_path: Path to the YAML file that can be loaded by LearningSuiteColumn.
+        class_list_csv_path: Path to CSV file with class list (Net ID, First Name, Last Name).
+        subitem_feedback_paths: Mapping from subitem name to feedback YAML file path.
+        output_zip_path: Path for the output zip file. If None, no zip is generated.
+        output_csv_path: Path for the output CSV file. If None, no CSV is generated.
+        late_penalty_callback: Optional callback function that takes
+            (late_days, max_score, actual_score) and returns the adjusted score.
+        due_date: The default due date for the assignment. Required for late penalty.
+        due_date_exceptions: Mapping from net_id to exception due date.
+
+    Returns:
+        Tuple of (feedback_zip_path or None, grades_csv_path or None).
+    """
+    yaml_path = pathlib.Path(yaml_path)
+    ls_column = LearningSuiteColumn(yaml_path)
+
+    # Get the lab name from the YAML file's parent directory
+    lab_name = yaml_path.parent.name
+
+    # Load all student deductions for each subitem
+    subitem_deductions: Dict[str, StudentDeductions] = {}
+    for subitem in ls_column.items:
+        if subitem.name in subitem_feedback_paths:
+            feedback_path = subitem_feedback_paths[subitem.name]
+            if feedback_path.exists():
+                subitem_deductions[subitem.name] = StudentDeductions(feedback_path)
+            else:
+                subitem_deductions[subitem.name] = StudentDeductions()
+        else:
+            subitem_deductions[subitem.name] = StudentDeductions()
+
+    # Load class list
+    students_df = pandas.read_csv(class_list_csv_path)
+
+    # Prepare for CSV output
+    grades_data = []
+
+    def process_students(zip_file: Optional[zipfile.ZipFile]) -> None:
+        """Process all students, adding to grades_data and optionally writing to zip."""
+        for _, student_row in students_df.iterrows():
+            first_name = str(student_row["First Name"]).strip()
+            last_name = str(student_row["Last Name"]).strip()
+            net_id = str(student_row["Net ID"]).strip()
+
+            # Calculate score before late penalty
+            score_before_late, total_possible, max_late_days = _calculate_student_score(
+                net_id=net_id,
+                ls_column=ls_column,
+                item_deductions=subitem_deductions,
+                late_penalty_callback=None,  # Don't apply late penalty yet
+                warn_on_missing_callback=False,
+                due_date=due_date,
+                due_date_exceptions=due_date_exceptions,
+            )
+
+            # Apply late penalty if applicable
+            final_score = score_before_late
+            if max_late_days > 0 and late_penalty_callback:
+                final_score = max(
+                    0,
+                    late_penalty_callback(
+                        max_late_days, total_possible, score_before_late
+                    ),
+                )
+                print_color(
+                    TermColors.YELLOW,
+                    f"Late: {net_id} ({max_late_days} day{'s' if max_late_days != 1 else ''}): "
+                    f"{score_before_late:.1f} -> {final_score:.1f}",
+                )
+
+            # Add to grades data
+            if output_csv_path:
+                grades_data.append(
+                    {"Net ID": net_id, ls_column.csv_col_name: final_score}
+                )
+
+            # Generate feedback file
+            if zip_file:
+                feedback_content = _generate_student_feedback(
+                    student_row=student_row,
+                    ls_column=ls_column,
+                    subitem_deductions=subitem_deductions,
+                    late_penalty_callback=late_penalty_callback,
+                    due_date=due_date,
+                    due_date_exceptions=due_date_exceptions,
+                )
+
+                filename = (
+                    first_name
+                    + "_"
+                    + last_name
+                    + "_"
+                    + net_id
+                    + "_feedback-"
+                    + lab_name
+                    + ".txt"
+                )
+                zip_file.writestr(filename, feedback_content)
+
+    # Process students with or without zip file
+    if output_zip_path:
+        with zipfile.ZipFile(output_zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+            process_students(zf)
+    else:
+        process_students(None)
+
+    # Write CSV (sorted by Net ID for easier git diffs)
+    if output_csv_path and grades_data:
+        grades_df = pandas.DataFrame(grades_data)
+        grades_df = grades_df.sort_values("Net ID")
+        grades_df.to_csv(output_csv_path, index=False)
+
+    return (output_zip_path, output_csv_path)
+
+
+def _generate_student_feedback(
+    student_row: pandas.Series,
+    ls_column: LearningSuiteColumn,
+    subitem_deductions: Dict[str, StudentDeductions],
+    *,
+    late_penalty_callback: Optional[LatePenaltyCallback] = None,
+    due_date: Optional[datetime.datetime] = None,
+    due_date_exceptions: Optional[Dict[str, datetime.datetime]] = None,
+) -> str:
+    """Generate the feedback text content for a single student.
+
+    Args:
+        student_row: A row from the student DataFrame.
+        ls_column: The LearningSuiteColumn object.
+        subitem_deductions: Mapping from subitem name to StudentDeductions.
+        late_penalty_callback: Optional callback for calculating late penalty.
+        due_date: The default due date for the assignment.
+        due_date_exceptions: Mapping from net_id to exception due date.
+
+    Returns:
+        The formatted feedback text.
+    """
+    net_id = str(student_row["Net ID"]).strip()
+    first_name = str(student_row["First Name"]).strip()
+    last_name = str(student_row["Last Name"]).strip()
+
+    lines = []
+    lines.append(f"Feedback for {first_name} {last_name} ({net_id})")
+    lines.append("=" * 60)
+    lines.append("")
+
+    total_points_possible = 0
+    total_points_deducted = 0
+
+    # Column widths for formatting
+    # Total width is 60 characters to match separator lines
+    # Item name column + score column (e.g., "10.0 / 10.0")
+    item_col_width = 42
+    score_col_width = 17
+    # For deduction lines: "  - " prefix (4 chars) + message + points
+    deduction_prefix = "  - "
+    deduction_msg_width = 38
+    deduction_pts_width = 17
+
+    for item in ls_column.items:
+        subitem_points_possible = item.points
+        total_points_possible += subitem_points_possible
+
+        subitem_points_deducted = 0
+        item_deductions = []
+
+        # Get deductions for this student in this item
+        student_deductions_obj = subitem_deductions.get(item.name)
+        if student_deductions_obj:
+            # Find the student's deductions (try single net_id first, then tuple)
+            student_key = None
+            if (net_id,) in student_deductions_obj.deductions_by_students:
+                student_key = (net_id,)
+            else:
+                # Check for multi-student keys containing this net_id
+                for key in student_deductions_obj.deductions_by_students.keys():
+                    if net_id in key:
+                        student_key = key
+                        break
+
+            if student_key:
+                deductions = student_deductions_obj.deductions_by_students[student_key]
+                for deduction in deductions:
+                    item_deductions.append((deduction.message, deduction.points))
+                    subitem_points_deducted += deduction.points
+
+        # Calculate item score
+        subitem_score = max(0, subitem_points_possible - subitem_points_deducted)
+        score_str = f"{subitem_score:.1f} / {subitem_points_possible:.1f}"
+
+        # Item line with score
+        item_name_with_colon = f"{item.name}:"
+        lines.append(
+            f"{item_name_with_colon:<{item_col_width}} {score_str:>{score_col_width}}"
+        )
+
+        # Deduction lines (indented)
+        for msg, pts in item_deductions:
+            # Wrap long messages
+            wrapped = _wrap_text(msg, deduction_msg_width)
+            for i, line_text in enumerate(wrapped):
+                if i == 0:
+                    lines.append(
+                        f"{deduction_prefix}{line_text:<{deduction_msg_width}} {-pts:>{deduction_pts_width}.1f}"
+                    )
+                else:
+                    # Continuation lines - no points
+                    lines.append(f"{deduction_prefix}{line_text}")
+
+        total_points_deducted += subitem_points_deducted
+
+    # Calculate score before late penalty (clamped to 0)
+    score_before_late = max(0, total_points_possible - total_points_deducted)
+
+    # Get max late days for this student
+    _, max_late_days = _get_student_key_and_max_late_days(
+        net_id, subitem_deductions, due_date, due_date_exceptions
+    )
+
+    # Late penalty section
+    lines.append("")
+    lines.append("=" * 60)
+    if max_late_days > 0 and late_penalty_callback:
+        final_score = late_penalty_callback(
+            max_late_days, 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 ({max_late_days} day{'s' if max_late_days != 1 else ''}):"
+        )
+        lines.append(
+            f"{late_label:<{item_col_width}} {-late_penalty_points:>{score_col_width}.1f}"
+        )
+    else:
+        final_score = score_before_late
+        lines.append(
+            f"{'Late Penalty:':<{item_col_width}} {'On Time':>{score_col_width}}"
+        )
+
+    # Total score section
+    total_score_str = f"{final_score:.1f} / {total_points_possible:.1f}"
+    lines.append(
+        f"{'TOTAL SCORE:':<{item_col_width}} {total_score_str:>{score_col_width}}"
+    )
+    lines.append("=" * 60)
+
+    return "\n".join(lines)
+
+
+def _wrap_text(text: str, width: int) -> list:
+    """Wrap text to fit within a given width.
+
+    Args:
+        text: The text to wrap.
+        width: Maximum width for each line.
+
+    Returns:
+        List of wrapped lines.
+    """
+    if len(text) <= width:
+        return [text]
+
+    words = text.split()
+    lines = []
+    current_line = ""
+
+    for word in words:
+        if not current_line:
+            current_line = word
+        elif len(current_line) + 1 + len(word) <= width:
+            current_line += " " + word
+        else:
+            lines.append(current_line)
+            current_line = word
+
+    if current_line:
+        lines.append(current_line)
+
+    return lines if lines else [""]

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

@@ -1,6 +1,5 @@
 """Main ygrader module"""
 
-import datetime as dt
 import enum
 import inspect
 import os
@@ -13,7 +12,6 @@ from collections import defaultdict
 from typing import Callable
 
 import pandas
-import yaml
 
 from . import grades_csv, student_repos, utils
 from .grading_item import GradeItem
@@ -101,7 +99,6 @@ class Grader:
         self.github_https = None
         self.groups_csv_path = None
         self.groups_csv_col_name = None
-        self.due_date_exceptions = {}
         self.set_other_options()
 
     def add_item_to_grade(
@@ -335,8 +332,6 @@ class Grader:
         dry_run_first=False,
         dry_run_all=False,
         workflow_hash=None,
-        due_date=None,
-        due_date_exceptions_path=None,
     ):
         """
         This can be used to set other options for the grader.
@@ -376,15 +371,6 @@ class Grader:
             (Optional) Expected hash of the GitHub workflow file. If provided, the workflow file will be verified
             before grading each student. If the hash doesn't match, a warning will be displayed indicating
             the student may have modified the workflow system.
-        due_date: datetime.datetime
-            (Optional) Due date for the assignment. If provided, the submission date will be compared to this
-            and late days will be calculated and displayed.
-        due_date_exceptions_path: str
-            (Optional) Path to a YAML file containing per-student due date exceptions. The file should be
-            a simple dictionary mapping net_ids to deadline strings in "YYYY-MM-DD HH:MM:SS" format.
-            Example:
-                "student1": "2025-01-15 23:59:59"
-                "student2": "2025-01-17 23:59:59"
         """
         self.format_code = format_code
         self.build_only = build_only
@@ -392,9 +378,6 @@ class Grader:
         self.allow_rebuild = allow_rebuild
         self.allow_rerun = allow_rerun
         self.workflow_hash = workflow_hash
-        self.due_date = due_date
-        self.due_date_exceptions = {}
-        self.due_date_exceptions_path = due_date_exceptions_path
         if prep_fcn and not isinstance(prep_fcn, Callable):
             error("The 'prep_fcn' argument must provide a callable function pointer")
         self.prep_fcn = prep_fcn
@@ -424,36 +407,6 @@ class Grader:
                 + "set_submission_system_learning_suite() or set_submission_system_github()."
             )
 
-    def _load_due_date_exceptions(self):
-        """Load due date exceptions from YAML file (simple net_id: deadline format)"""
-
-        self.due_date_exceptions = {}
-        if not self.due_date_exceptions_path:
-            return
-
-        try:
-            with open(self.due_date_exceptions_path, "r", encoding="utf-8") as f:
-                exceptions_raw = yaml.safe_load(f)
-        except (IOError, yaml.YAMLError) as e:
-            print_color(
-                TermColors.YELLOW, f"Warning: Could not load exceptions file: {e}"
-            )
-            return
-
-        if not exceptions_raw or not isinstance(exceptions_raw, dict):
-            return
-
-        for net_id, deadline_str in exceptions_raw.items():
-            try:
-                self.due_date_exceptions[net_id] = dt.datetime.strptime(
-                    deadline_str, "%Y-%m-%d %H:%M:%S"
-                )
-            except ValueError as e:
-                print_color(
-                    TermColors.YELLOW,
-                    f"Warning: Could not parse deadline for {net_id}: {e}",
-                )
-
     def _get_all_csv_cols_to_grade(self):
         """Collect all columns that will be graded into a single list.
 
@@ -465,7 +418,6 @@ class Grader:
         """Call this to start (or resume) the grading process"""
 
         self._validate_config()
-        self._load_due_date_exceptions()
 
         # Print starting message
         print_color(TermColors.BLUE, "Running grader for", self.lab_name)

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

@@ -3,8 +3,6 @@
 import datetime
 import sys
 
-import numpy as np
-
 from .utils import (
     CallbackFailed,
     TermColors,
@@ -149,10 +147,10 @@ class GradeItem:
                         print_color(TermColors.RED, "=" * 70)
                         print("")
 
-            # Display submission date if available
+            # Display submission date if available and store for later late calculation
             student_code_path = callback_args.get("student_code_path")
-            # Calculate days_late but don't save yet - will be saved only after successful grading
-            pending_days_late = None
+            # Store submission time but don't save yet - will be saved only after successful grading
+            pending_submit_time = None
             if student_code_path:
                 submission_date_path = student_code_path / ".commitdate"
                 if submission_date_path.is_file():
@@ -166,43 +164,8 @@ class GradeItem:
                             TermColors.BLUE,
                             f"Submitted: {submission_time.strftime('%Y-%m-%d %H:%M:%S')}",
                         )
-
-                        # Calculate late days if due_date is configured
-                        if self.grader.due_date is not None:
-                            # Check for student-specific due date exception
-                            # Use the latest (most generous) exception if multiple group members have them
-                            effective_due_date = self.grader.due_date
-                            for net_id in net_ids:
-                                if net_id in self.grader.due_date_exceptions:
-                                    exception_date = self.grader.due_date_exceptions[
-                                        net_id
-                                    ]
-                                    effective_due_date = max(
-                                        effective_due_date, exception_date
-                                    )
-
-                            has_exception = effective_due_date != self.grader.due_date
-                            if has_exception:
-                                print_color(
-                                    TermColors.YELLOW,
-                                    f"Exception due date: {effective_due_date.strftime('%Y-%m-%d %H:%M:%S')}",
-                                )
-
-                            if submission_time <= effective_due_date:
-                                print_color(TermColors.GREEN, "Status: ON TIME")
-                                pending_days_late = 0
-                            else:
-                                days_late = np.busday_count(
-                                    effective_due_date.date(),
-                                    submission_time.date(),
-                                )
-                                if days_late == 0:
-                                    days_late = 1  # Same day but after deadline
-                                print_color(
-                                    TermColors.RED,
-                                    f"Status: LATE ({days_late} business day(s))",
-                                )
-                                pending_days_late = int(days_late)
+                        # Store as ISO format for later late calculation
+                        pending_submit_time = submission_time.isoformat()
                     except (ValueError, IOError) as e:
                         print_color(
                             TermColors.YELLOW,
@@ -230,10 +193,10 @@ class GradeItem:
                             TermColors.BLUE,
                             f"Applied deduction: {deduction_desc} (-{deduction_points})",
                         )
-                    # Save days_late now that grading succeeded
-                    if pending_days_late is not None:
-                        self.student_deductions.set_days_late(
-                            tuple(net_ids), pending_days_late
+                    # 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
                         )
                     # Ensure student is in the deductions file
                     self.student_deductions.ensure_student_in_file(tuple(net_ids))
@@ -270,10 +233,10 @@ class GradeItem:
                 build = False
                 continue
 
-            # Record score - save days_late and ensure the student is in the deductions file
+            # 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_days_late is not None:
-                self.student_deductions.set_days_late(tuple(net_ids), pending_days_late)
+            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
 

{ygrader-2.0.0 → ygrader-2.2.0}/ygrader/grading_item_config.py

@@ -19,7 +19,7 @@ class LearningSuiteColumn:
         self.csv_col_name = None
         self.other_data = {}
 
-        # First make sure the YAML file exists in a directory of the same name
+        # Make sure the YAML file exists
         if yaml_path.suffix != ".yaml":
             raise LearningSuiteColumnParseError(
                 "The item_yaml_path must point to a .yaml file."
@@ -28,10 +28,6 @@ class LearningSuiteColumn:
             raise LearningSuiteColumnParseError(
                 f"The specified YAML file does not exist: {yaml_path}"
             )
-        if yaml_path.parent.name != yaml_path.stem:
-            raise LearningSuiteColumnParseError(
-                f"The YAML file must be located in a directory of the same name. Currently {yaml_path} is in {yaml_path.parent}"
-            )
 
         with yaml_path.open("r") as f:
             data = yaml.safe_load(f)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ygrader
-Version: 2.0.0
+Version: 2.2.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.0.0/ygrader/feedback.py

@@ -1,218 +0,0 @@
-"""Module for generating student feedback files."""
-
-import pathlib
-import zipfile
-from typing import Dict
-
-import pandas
-
-from .deductions import StudentDeductions
-from .grading_item_config import LearningSuiteColumn
-
-
-def generate_feedback_zip(
-    yaml_path: pathlib.Path,
-    class_list_csv_path: pathlib.Path,
-    subitem_feedback_paths: Dict[str, pathlib.Path],
-    output_zip_path: pathlib.Path = None,
-) -> pathlib.Path:
-    """Generate a zip file containing feedback files for each student.
-
-    Args:
-        yaml_path: Path to the YAML file that can be loaded by LearningSuiteColumn.
-        class_list_csv_path: Path to CSV file with class list (Net ID, First Name, Last Name).
-        subitem_feedback_paths: Mapping from subitem name to feedback YAML file path.
-        output_zip_path: Path for the output zip file. If None, defaults to
-            <yaml_dir>/feedback.zip.
-
-    Returns:
-        Path to the generated zip file.
-    """
-    yaml_path = pathlib.Path(yaml_path)
-    ls_column = LearningSuiteColumn(yaml_path)
-
-    # Get the lab name from the YAML file's parent directory
-    lab_name = yaml_path.stem
-
-    # Default output path
-    if output_zip_path is None:
-        output_zip_path = yaml_path.parent / "feedback.zip"
-
-    # Load all student deductions for each subitem
-    subitem_deductions: Dict[str, StudentDeductions] = {}
-    for subitem in ls_column.items:
-        if subitem.name in subitem_feedback_paths:
-            feedback_path = subitem_feedback_paths[subitem.name]
-            if feedback_path.exists():
-                subitem_deductions[subitem.name] = StudentDeductions(feedback_path)
-            else:
-                subitem_deductions[subitem.name] = StudentDeductions()
-        else:
-            subitem_deductions[subitem.name] = StudentDeductions()
-
-    # Load class list from provided CSV
-    students_df = pandas.read_csv(class_list_csv_path)
-
-    # Create the zip file
-    with zipfile.ZipFile(output_zip_path, "w", zipfile.ZIP_DEFLATED) as zip_file:
-        for _, student_row in students_df.iterrows():
-            first_name = str(student_row["First Name"]).strip()
-            last_name = str(student_row["Last Name"]).strip()
-            net_id = str(student_row["Net ID"]).strip()
-
-            # Generate feedback content for this student
-            feedback_content = _generate_student_feedback(
-                student_row=student_row,
-                ls_column=ls_column,
-                subitem_deductions=subitem_deductions,
-            )
-
-            # Generate filename
-            filename = (
-                first_name
-                + "_"
-                + last_name
-                + "_"
-                + net_id
-                + "_feedback-"
-                + lab_name
-                + ".txt"
-            )
-
-            # Add to zip file
-            zip_file.writestr(filename, feedback_content)
-
-    return output_zip_path
-
-
-def _generate_student_feedback(
-    student_row: pandas.Series,
-    ls_column: LearningSuiteColumn,
-    subitem_deductions: Dict[str, StudentDeductions],
-) -> str:
-    """Generate the feedback text content for a single student.
-
-    Args:
-        student_row: A row from the student DataFrame.
-        ls_column: The LearningSuiteColumn object.
-        subitem_deductions: Mapping from subitem name to StudentDeductions.
-
-    Returns:
-        The formatted feedback text.
-    """
-    net_id = str(student_row["Net ID"]).strip()
-    first_name = str(student_row["First Name"]).strip()
-    last_name = str(student_row["Last Name"]).strip()
-
-    lines = []
-    lines.append(f"Feedback for {first_name} {last_name} ({net_id})")
-    lines.append("=" * 60)
-    lines.append("")
-
-    total_points_possible = 0
-    total_points_deducted = 0
-
-    # Column widths for formatting
-    feedback_col_width = 45
-    points_col_width = 15
-
-    for item in ls_column.items:
-        subitem_points_possible = item.points
-        total_points_possible += subitem_points_possible
-
-        lines.append(f"{item.name} ({subitem_points_possible} points)")
-        lines.append("-" * 60)
-
-        # Header row
-        header = f"{'Feedback':<{feedback_col_width}} {'Points Deducted':>{points_col_width}}"
-        lines.append(header)
-        lines.append("-" * 60)
-
-        subitem_points_deducted = 0
-
-        # Get deductions for this student in this item
-        student_deductions_obj = subitem_deductions.get(item.name)
-        if student_deductions_obj:
-            # Find the student's deductions (try single net_id first, then tuple)
-            student_key = None
-            if (net_id,) in student_deductions_obj.deductions_by_students:
-                student_key = (net_id,)
-            else:
-                # Check for multi-student keys containing this net_id
-                for key in student_deductions_obj.deductions_by_students.keys():
-                    if net_id in key:
-                        student_key = key
-                        break
-
-            if student_key:
-                deductions = student_deductions_obj.deductions_by_students[student_key]
-                for deduction in deductions:
-                    feedback_text = deduction.message
-                    points = deduction.points
-
-                    # Wrap long feedback text
-                    wrapped_lines = _wrap_text(feedback_text, feedback_col_width)
-                    for i, line_text in enumerate(wrapped_lines):
-                        if i == 0:
-                            row = f"{line_text:<{feedback_col_width}} {points:>{points_col_width}.1f}"
-                        else:
-                            row = f"{line_text:<{feedback_col_width}} {'':{points_col_width}}"
-                        lines.append(row)
-
-                    subitem_points_deducted += points
-
-        if subitem_points_deducted == 0:
-            lines.append(
-                f"{'No deductions':<{feedback_col_width}} {'0.0':>{points_col_width}}"
-            )
-
-        lines.append("-" * 60)
-        subitem_score = subitem_points_possible - subitem_points_deducted
-        lines.append(
-            f"{'Subitem Total:':<{feedback_col_width}} {subitem_score:>{points_col_width}.1f} / {subitem_points_possible:.1f}"
-        )
-        lines.append("")
-
-        total_points_deducted += subitem_points_deducted
-
-    # Total score section
-    lines.append("=" * 60)
-    total_score = total_points_possible - total_points_deducted
-    lines.append(
-        f"{'TOTAL SCORE:':<{feedback_col_width}} {total_score:>{points_col_width}.1f} / {total_points_possible:.1f}"
-    )
-    lines.append("=" * 60)
-
-    return "\n".join(lines)
-
-
-def _wrap_text(text: str, width: int) -> list:
-    """Wrap text to fit within a given width.
-
-    Args:
-        text: The text to wrap.
-        width: Maximum width for each line.
-
-    Returns:
-        List of wrapped lines.
-    """
-    if len(text) <= width:
-        return [text]
-
-    words = text.split()
-    lines = []
-    current_line = ""
-
-    for word in words:
-        if not current_line:
-            current_line = word
-        elif len(current_line) + 1 + len(word) <= width:
-            current_line += " " + word
-        else:
-            lines.append(current_line)
-            current_line = word
-
-    if current_line:
-        lines.append(current_line)
-
-    return lines if lines else [""]