ygrader 1.2.4__tar.gz → 2.1.0__tar.gz

{ygrader-1.2.4/ygrader.egg-info → ygrader-2.1.0}/PKG-INFO

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

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

{ygrader-1.2.4 → ygrader-2.1.0}/test/test_interactive.py

@@ -35,12 +35,10 @@ def test_me():
         "lab1",
         run_on_milestone,
         10,
-        help_msg="This is a long string\nWith lots of advice\nFor TAs",
     )
     grader.add_item_to_grade(
         "lab1m2",
         run_on_milestone,
-        help_msg="msg2",
     )
     grader.set_submission_system_learning_suite(TEST_RESOURCES_PATH / "submissions.zip")
     grader.set_other_options(prep_fcn=run_on_lab)

ygrader-2.1.0/test/test_unittest.py

@@ -0,0 +1,139 @@
+#!/usr/bin/python3
+
+import unittest
+import pathlib
+import sys
+import filecmp
+import doctest
+
+ROOT_PATH = pathlib.Path(__file__).resolve().parent.parent
+sys.path.append(str(ROOT_PATH))
+
+import ygrader.student_repos
+from ygrader import Grader, CodeSource
+
+TEST_PATH = ROOT_PATH / "test"
+TEST_RESOURCES_PATH = TEST_PATH / "resources"
+TEST_OUTPUT_PATH = TEST_PATH / "grades"
+
+
+def load_tests(loader, tests, ignore):
+    tests.addTests(doctest.DocTestSuite(ygrader.student_repos))
+    return tests
+
+
+class TestGithub(unittest.TestCase):
+    def test_me(self):
+        class_list_csv_path = TEST_RESOURCES_PATH / "class_list_1.csv"
+        deductions1_golden_path = TEST_RESOURCES_PATH / "deductions1_golden.yaml"
+        deductions2_golden_path = TEST_RESOURCES_PATH / "deductions2_golden.yaml"
+        deductions1_yaml_path = TEST_OUTPUT_PATH / "deductions1.yaml"
+        deductions2_yaml_path = TEST_OUTPUT_PATH / "deductions2.yaml"
+
+        grader = Grader(
+            lab_name="github_test",
+            class_list_csv_path=class_list_csv_path,
+            work_path=TEST_PATH / "temp_github",
+        )
+        grader.add_item_to_grade(
+            "lab1",
+            self.runner,
+            max_points=10,
+            deductions_yaml_path=deductions1_yaml_path,
+        )
+        grader.add_item_to_grade(
+            "lab1m2",
+            self.runner,
+            max_points=20,
+            deductions_yaml_path=deductions2_yaml_path,
+        )
+        grader.set_submission_system_github(
+            "main", TEST_RESOURCES_PATH / "github.csv", use_https=True
+        )
+        grader.run()
+
+        self.assertTrue(filecmp.cmp(deductions1_yaml_path, deductions1_golden_path))
+        self.assertTrue(filecmp.cmp(deductions2_yaml_path, deductions2_golden_path))
+
+    def runner(self, **kw):
+        if kw["item_name"] == "lab1m2":
+            return [("New feedback", 2)]
+        return []
+
+
+class TestLearningSuite(unittest.TestCase):
+    def test_me(self):
+        class_list_csv_path = TEST_RESOURCES_PATH / "class_list_2.csv"
+        deductions_path = TEST_OUTPUT_PATH / "learningsuite_deductions.yaml"
+        deductions_golden_path = (
+            TEST_RESOURCES_PATH / "learningsuite_deductions_golden.yaml"
+        )
+
+        grader = Grader(
+            lab_name="learningsuite_test",
+            class_list_csv_path=class_list_csv_path,
+            work_path=TEST_PATH / "temp_learningsuite",
+        )
+        grader.add_item_to_grade(
+            item_name="lab1",
+            grading_fcn=self.runner,
+            deductions_yaml_path=deductions_path,
+            max_points=10,
+        )
+        grader.set_submission_system_learning_suite(
+            TEST_RESOURCES_PATH / "submissions.zip"
+        )
+        grader.run()
+
+        self.assertTrue(filecmp.cmp(deductions_path, deductions_golden_path))
+
+    def runner(self, student_code_path, **kw):
+        self.assertIn("section", kw)
+        self.assertIn("homework_id", kw)
+        if (student_code_path / "file_1.txt").is_file() and (
+            student_code_path / "file_2.txt"
+        ).is_file():
+            return []
+        else:
+            return [("Missing files", 10)]
+
+    def test_groups(self):
+        class_list_csv_path = TEST_RESOURCES_PATH / "class_list_3.csv"
+        deductions1_path = TEST_OUTPUT_PATH / "groups_l1.yaml"
+        deductions2_path = TEST_OUTPUT_PATH / "groups_l2.yaml"
+        deductions3_path = TEST_OUTPUT_PATH / "groups_l3.yaml"
+        deductions1_golden_path = TEST_RESOURCES_PATH / "groups_l1_golden.yaml"
+        deductions2_golden_path = TEST_RESOURCES_PATH / "groups_l2_golden.yaml"
+        deductions3_golden_path = TEST_RESOURCES_PATH / "groups_l3_golden.yaml"
+
+        grader = Grader(
+            "groups_test",
+            class_list_csv_path=class_list_csv_path,
+            work_path=TEST_PATH / "temp_groups",
+        )
+        grader.add_item_to_grade(
+            item_name="l1",
+            grading_fcn=self.group_grader_1,
+            deductions_yaml_path=deductions1_path,
+            max_points=10,
+        )
+        grader.add_item_to_grade(
+            item_name="l2",
+            grading_fcn=self.group_grader_2,
+            deductions_yaml_path=deductions2_path,
+            max_points=10,
+        )
+        grader.set_submission_system_learning_suite(
+            TEST_RESOURCES_PATH / "submissions2.zip"
+        )
+        grader.set_learning_suite_groups(TEST_RESOURCES_PATH / "groups3.csv")
+        grader.run()
+
+        self.assertTrue(filecmp.cmp(deductions1_path, deductions1_golden_path))
+        self.assertTrue(filecmp.cmp(deductions2_path, deductions2_golden_path))
+
+    def group_grader_1(self, **kw):
+        return []
+
+    def group_grader_2(self, **kw):
+        return [("Did not follow instructions", 5)]

ygrader-2.1.0/ygrader/__init__.py

@@ -0,0 +1,10 @@
+"""Default imports for package"""
+
+from .grader import Grader, CodeSource
+from .upstream_merger import UpstreamMerger
+from .utils import CallbackFailed
+from .grading_item_config import (
+    LearningSuiteColumn,
+    LearningSuiteColumnParseError,
+)
+from .feedback import assemble_grades

{ygrader-1.2.4 → ygrader-2.1.0}/ygrader/deductions.py

@@ -138,9 +138,11 @@ class StudentDeductions:
         all_student_keys = set(self.deductions_by_students.keys()) | set(
             self.days_late_by_students.keys()
         )
-        if all_student_keys:
+        # Sort student keys for consistent output ordering
+        sorted_student_keys = sorted(all_student_keys)
+        if sorted_student_keys:
             student_deduction_list = []
-            for student_key in all_student_keys:
+            for student_key in sorted_student_keys:
                 deduction_items = self.deductions_by_students.get(student_key, [])
                 # Find the deduction IDs for these deduction items
                 deduction_ids = []
@@ -164,6 +166,9 @@ class StudentDeductions:
                 )
             data["student_deductions"] = student_deduction_list
 
+        # Create parent directory if it doesn't exist
+        self.yaml_path.parent.mkdir(parents=True, exist_ok=True)
+
         # Write to file
         with open(self.yaml_path, "w", encoding="utf-8") as f:
             yaml.dump(data, f, default_flow_style=False, sort_keys=False)
@@ -191,6 +196,24 @@ class StudentDeductions:
         self._save()
         return next_id
 
+    def find_or_create_deduction_type(self, message: str, points: float = 0.0) -> int:
+        """Find an existing deduction type by message, or create a new one if not found.
+
+        Args:
+            message: The deduction message/description to find or create
+            points: Points to deduct (used only if creating a new type)
+
+        Returns:
+            The ID of the existing or newly created deduction type
+        """
+        # Search for existing deduction type with matching message
+        for deduction_id, deduction_type in self.deduction_types.items():
+            if deduction_type.message == message:
+                return deduction_id
+
+        # Not found, create a new one
+        return self.add_deduction_type(message, points)
+
     def create_deduction_type_interactive(self) -> int:
         """Interactively prompt the user to create a new deduction type.
 
@@ -356,6 +379,32 @@ class StudentDeductions:
             del self.days_late_by_students[student_key]
         self._save()
 
+    def ensure_student_in_file(self, net_ids: tuple):
+        """Ensure a student is in the deductions file, even with no deductions.
+
+        This is used to indicate that a student has been graded (with a perfect score)
+        rather than being absent from the file (not yet graded).
+
+        Args:
+            net_ids: Tuple of net_ids for the student.
+        """
+        student_key = tuple(net_ids) if not isinstance(net_ids, tuple) else net_ids
+        if student_key not in self.deductions_by_students:
+            self.deductions_by_students[student_key] = []
+            self._save()
+
+    def is_student_graded(self, net_ids: tuple) -> bool:
+        """Check if a student has been graded (is in the deductions file).
+
+        Args:
+            net_ids: Tuple of net_ids for the student.
+
+        Returns:
+            True if the student is in the deductions file (graded), False otherwise.
+        """
+        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.
 

ygrader-2.1.0/ygrader/feedback.py

@@ -0,0 +1,383 @@
+"""Module for generating student feedback files and grades CSV."""
+
+import pathlib
+import zipfile
+from typing import Callable, Dict, Optional, Tuple
+
+import pandas
+
+from .deductions import StudentDeductions
+from .grading_item_config import LearningSuiteColumn
+from .utils import warning
+
+
+# Type alias for late penalty callback: (late_days, max_score, actual_score) -> new_score
+LatePenaltyCallback = Callable[[int, float, float], float]
+
+
+def _get_student_key_and_max_late_days(
+    net_id: str,
+    item_deductions: Dict[str, StudentDeductions],
+) -> 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.
+
+    Returns:
+        Tuple of (student_key or None, max_late_days).
+    """
+    max_late_days = 0
+    found_student_key = None
+
+    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.days_late_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.days_late_by_students.keys()
+            ):
+                if net_id in key:
+                    student_key = key
+                    break
+
+        if student_key:
+            found_student_key = student_key
+            days_late = deductions_obj.days_late_by_students.get(student_key, 0)
+            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,
+) -> 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.
+
+    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)
+
+    # 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,
+) -> 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.
+
+    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 final score (only warn once, when generating CSV)
+            final_score, _, _ = _calculate_student_score(
+                net_id=net_id,
+                ls_column=ls_column,
+                item_deductions=subitem_deductions,
+                late_penalty_callback=late_penalty_callback,
+                warn_on_missing_callback=(output_csv_path is not None),
+            )
+
+            # 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,
+                )
+
+                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,
+) -> 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.
+
+    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)
+
+    # 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 [""]