ygrader 1.1.28__tar.gz → 1.2.0__tar.gz

{ygrader-1.1.28/ygrader.egg-info → ygrader-1.2.0}/PKG-INFO

@@ -1,13 +1,18 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: ygrader
-Version: 1.1.28
+Version: 1.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
 Author-email: jeff.goeders@gmail.com
 License: MIT
-Platform: UNKNOWN
 License-File: LICENSE
-
-UNKNOWN
-
+Requires-Dist: pandas>=1.0.0
+Requires-Dist: pyyaml
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary

{ygrader-1.1.28 → ygrader-1.2.0}/setup.py

@@ -3,11 +3,12 @@ from setuptools import setup
 setup(
     name="ygrader",
     packages=["ygrader"],
-    version="1.1.28",
+    package_data={"ygrader": ["*.ahk"]},
+    version="1.2.0",
     description="Grading scripts used in BYU's Electrical and Computer Engineering Department",
     author="Jeff Goeders",
     author_email="jeff.goeders@gmail.com",
     license="MIT",
     url="https://github.com/byu-cpe/ygrader",
-    install_requires=["pandas>=1.0.0"],
+    install_requires=["pandas>=1.0.0", "pyyaml"],
 )

{ygrader-1.1.28 → ygrader-1.2.0}/test/test_interactive.py

@@ -32,14 +32,15 @@ def test_me():
         work_path=TEST_PATH / "temp",
     )
     grader.add_item_to_grade(
-        "lab1", run_on_milestone, 10, help_msg="This is a long string\nWith lots of advice\nFor TAs"
+        "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",
-        ],
+        help_msg="msg2",
     )
     grader.set_submission_system_learning_suite(TEST_RESOURCES_PATH / "submissions.zip")
     grader.set_other_options(prep_fcn=run_on_lab)

{ygrader-1.1.28 → ygrader-1.2.0}/test/test_unittest.py

@@ -29,10 +29,10 @@ class TestGithub(unittest.TestCase):
         grader = Grader(
             lab_name="github_test",
             grades_csv_path=TEST_RESOURCES_PATH / "grades1.csv",
-            work_path=TEST_PATH / "temp",
+            work_path=TEST_PATH / "temp_github",
         )
-        grader.add_item_to_grade("lab1", self.runner, 10)
-        grader.add_item_to_grade("lab1m2", self.runner, 20)
+        grader.add_item_to_grade("lab1", self.runner, max_points=10)
+        grader.add_item_to_grade("lab1m2", self.runner, max_points=20)
         grader.set_submission_system_github(
             "main", TEST_RESOURCES_PATH / "github.csv", use_https=True
         )
@@ -53,14 +53,16 @@ class TestLearningSuite(unittest.TestCase):
         grader = Grader(
             lab_name="learningsuite_test",
             grades_csv_path=grades_path,
-            work_path=TEST_PATH / "temp",
+            work_path=TEST_PATH / "temp_learningsuite",
         )
         grader.add_item_to_grade(
-            csv_col_names="lab1",
+            csv_col_name="lab1",
             grading_fcn=self.runner,
-            max_points=(10,),
+            max_points=10,
+        )
+        grader.set_submission_system_learning_suite(
+            TEST_RESOURCES_PATH / "submissions.zip"
         )
-        grader.set_submission_system_learning_suite(TEST_RESOURCES_PATH / "submissions.zip")
         grader.run()
 
         self.assertTrue(filecmp.cmp(grades_path, grades_path_golden))
@@ -79,16 +81,17 @@ class TestLearningSuite(unittest.TestCase):
         grader = Grader(
             "groups_test",
             TEST_RESOURCES_PATH / "grades3.csv",
-            work_path=TEST_PATH / "temp",
+            work_path=TEST_PATH / "temp_groups",
         )
         grader.add_item_to_grade(
-            csv_col_names="l1",
+            csv_col_name="l1",
             grading_fcn=self.group_grader_1,
         )
-        grader.add_item_to_grade(
-            ("l2", "l3"), self.group_grader_2, help_msg=("rubric message 1", "rubric message 2")
+        grader.add_item_to_grade("l2", self.group_grader_2, help_msg="rubric message 1")
+        grader.add_item_to_grade("l3", self.group_grader_3, help_msg="rubric message 2")
+        grader.set_submission_system_learning_suite(
+            TEST_RESOURCES_PATH / "submissions2.zip"
         )
-        grader.set_submission_system_learning_suite(TEST_RESOURCES_PATH / "submissions2.zip")
         grader.set_learning_suite_groups(TEST_RESOURCES_PATH / "groups3.csv")
         grader.run()
 
@@ -96,4 +99,7 @@ class TestLearningSuite(unittest.TestCase):
         return 1.5
 
     def group_grader_2(self, **kw):
-        return (2, 3.0)
+        return 2
+
+    def group_grader_3(self, **kw):
+        return 3.0

ygrader-1.2.0/ygrader/__init__.py

@@ -0,0 +1,6 @@
+"""Default imports for package"""
+
+from .grader import Grader, CodeSource, ScoreMode
+from .upstream_merger import UpstreamMerger
+from .utils import CallbackFailed
+from .sub_items import generate_subitem_csvs, ParentItem

ygrader-1.2.0/ygrader/deductions.py

@@ -0,0 +1,401 @@
+"""
+Deduction system for student assignments.
+"""
+
+import pathlib
+from typing import List, Optional
+
+import yaml
+
+from .utils import TermColors, print_color
+
+
+class FlowList(list):
+    """A list subclass that will be serialized in YAML flow style (inline)."""
+
+
+def flow_list_representer(dumper, data):
+    """Custom YAML representer for FlowList to use flow style."""
+    return dumper.represent_sequence("tag:yaml.org,2002:seq", data, flow_style=True)
+
+
+yaml.add_representer(FlowList, flow_list_representer)
+
+
+class DeductionType:
+    """A reusable deduction type that can be applied across multiple students."""
+
+    message: str
+    points: float = 0.0
+
+    def __init__(self, message: str, points: float = 0.0):
+        self.message = message
+        self.points = points
+
+    def __str__(self) -> str:
+        """String representation of the deduction type."""
+        if self.points != 0:
+            return f"{self.message} ({self.points:+.1f} points)"
+        return self.message
+
+
+class StudentDeductions:
+    """Collection of all deductions for students."""
+
+    def __init__(self, yaml_path: Optional[pathlib.Path] = None):
+        self.deductions_by_students = {}
+        self.days_late_by_students = {}
+        self.deduction_types = {}
+        self.yaml_path = yaml_path
+
+        # Load from YAML file if it exists
+        if yaml_path is not None and yaml_path.is_file():
+            self._load_from_yaml()
+
+    def _save(self):
+        """Save the current state to YAML file if a path is set."""
+        if self.yaml_path is not None:
+            self._write_yaml()
+
+    def _load_from_yaml(self):
+        """Load deduction types and student deductions from the YAML file.
+
+        Expected YAML structure:
+        deduction_types:
+          - id: 0
+            desc: Deduction description
+            points: 5
+
+        student_deductions:
+          - net_ids: ["idA", "idB"]
+            deductions: [0, 3]
+        """
+        assert self.yaml_path.exists(), f"YAML file {self.yaml_path} does not exist."
+
+        with open(self.yaml_path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+
+        # Load deduction types if present
+        if data and "deduction_types" in data:
+            for deduction in data["deduction_types"]:
+                deduction_id = deduction["id"]
+                desc = deduction["desc"]
+                points = deduction["points"]
+
+                # Create a DeductionType for this deduction
+                deduction_type = DeductionType(message=desc, points=points)
+                self.deduction_types[deduction_id] = deduction_type
+
+        # Load student deductions if present
+        if data and "student_deductions" in data:
+            for entry in data["student_deductions"]:
+                net_ids = entry["net_ids"]
+                deduction_ids = entry["deductions"]
+
+                # Use tuple of net_ids as the key
+                student_key = tuple(net_ids)
+                deduction_items = []
+
+                for deduction_id in deduction_ids:
+                    if deduction_id in self.deduction_types:
+                        deduction_items.append(self.deduction_types[deduction_id])
+
+                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"]
+
+    def _write_yaml(self):
+        """Write deduction types and student deductions to the YAML file.
+
+        Writes in the format:
+        deduction_types:
+          - id: 0
+            desc: Deduction description
+            points: 5
+
+        student_deductions:
+          - net_ids: ["idA", "idB"]
+            deductions: [0, 3]
+        """
+        data = {}
+
+        # Write deduction types
+        if self.deduction_types:
+            deduction_list = []
+            for deduction_id, deduction_type in self.deduction_types.items():
+                deduction_list.append(
+                    {
+                        "id": deduction_id,
+                        "desc": deduction_type.message,
+                        "points": deduction_type.points,
+                    }
+                )
+            data["deduction_types"] = deduction_list
+
+        # Write student deductions (include students with deductions OR days_late)
+        all_student_keys = set(self.deductions_by_students.keys()) | set(
+            self.days_late_by_students.keys()
+        )
+        if all_student_keys:
+            student_deduction_list = []
+            for student_key in all_student_keys:
+                deduction_items = self.deductions_by_students.get(student_key, [])
+                # Find the deduction IDs for these deduction items
+                deduction_ids = []
+                for deduction_item in deduction_items:
+                    # Find the ID of this deduction item in deduction_types
+                    for deduction_id, dt_item in self.deduction_types.items():
+                        if dt_item is deduction_item:
+                            deduction_ids.append(deduction_id)
+                            break
+
+                student_deduction_list.append(
+                    {
+                        "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
+                            else {}
+                        ),
+                    }
+                )
+            data["student_deductions"] = student_deduction_list
+
+        # 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)
+
+    def add_deduction_type(self, message: str, points: float = 0.0) -> int:
+        """Add a new deduction type.
+
+        Args:
+            message: The deduction message/description
+            points: Points to deduct (can be negative for bonus points)
+
+        Returns:
+            The ID assigned to this deduction type
+        """
+        # Find the next available ID (start at 1, reserve 0 for clear command)
+        if self.deduction_types:
+            next_id = max(self.deduction_types.keys()) + 1
+        else:
+            next_id = 1
+
+        # Create and store the deduction type
+        deduction_type = DeductionType(message=message, points=points)
+        self.deduction_types[next_id] = deduction_type
+
+        self._save()
+        return next_id
+
+    def create_deduction_type_interactive(self) -> int:
+        """Interactively prompt the user to create a new deduction type.
+
+        Returns:
+            The ID of the created deduction type, or -1 if cancelled.
+        """
+        print("\nCreate new deduction type (empty input to cancel):")
+
+        # Prompt for description
+        description = input("  Description: ").strip()
+        if not description:
+            print("Cancelled.")
+            return -1
+
+        # Prompt for points
+        while True:
+            points_str = input("  Points to deduct: ").strip()
+            if not points_str:
+                print("Cancelled.")
+                return -1
+            try:
+                points = float(points_str)
+                break
+            except ValueError:
+                print("Invalid number. Try again.")
+
+        # Add the new deduction type
+        deduction_id = self.add_deduction_type(description, points)
+        print(
+            f"Created deduction type [{deduction_id}]: {description} ({points} points)"
+        )
+
+        return deduction_id
+
+    def is_deduction_in_use(self, deduction_id: int) -> bool:
+        """Check if a deduction type is currently applied to any student.
+
+        Args:
+            deduction_id: The ID of the deduction type to check.
+
+        Returns:
+            True if any student has this deduction, False otherwise.
+        """
+        if deduction_id not in self.deduction_types:
+            return False
+
+        deduction_type = self.deduction_types[deduction_id]
+        for student_deductions in self.deductions_by_students.values():
+            if deduction_type in student_deductions:
+                return True
+        return False
+
+    def delete_deduction_type(self, deduction_id: int) -> bool:
+        """Delete a deduction type if it's not in use by any student.
+
+        Args:
+            deduction_id: The ID of the deduction type to delete.
+
+        Returns:
+            True if deleted successfully, False if in use or not found.
+        """
+        if deduction_id not in self.deduction_types:
+            return False
+
+        if self.is_deduction_in_use(deduction_id):
+            return False
+
+        del self.deduction_types[deduction_id]
+        self._save()
+        return True
+
+    def delete_deduction_type_interactive(self) -> bool:
+        """Interactively prompt the user to delete a deduction type.
+
+        Returns:
+            True if a deduction was deleted, False otherwise.
+        """
+        if not self.deduction_types:
+            print("No deduction types to delete.")
+            return False
+
+        print("\nDelete deduction type (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 delete: ").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
+
+        if self.is_deduction_in_use(deduction_id):
+            print_color(
+                TermColors.YELLOW,
+                "Cannot delete - deduction is in use by one or more students.",
+            )
+            return False
+
+        deduction_type = self.deduction_types[deduction_id]
+        self.delete_deduction_type(deduction_id)
+        print(f"Deleted deduction type [{deduction_id}]: {deduction_type.message}")
+        return True
+
+    def get_student_deductions(self, net_ids: tuple) -> List[DeductionType]:
+        """Get the list of deductions applied to a student.
+
+        Args:
+            net_ids: Tuple of net_ids to look up.
+
+        Returns:
+            List of DeductionType objects applied to this student.
+        """
+        student_key = tuple(net_ids) if not isinstance(net_ids, tuple) else net_ids
+        return self.deductions_by_students.get(student_key, [])
+
+    def apply_deduction_to_student(self, net_ids: tuple, deduction_id: int) -> bool:
+        """Apply a deduction type to a student.
+
+        Args:
+            net_ids: Tuple of net_ids for the student.
+            deduction_id: The ID of the deduction type to apply.
+
+        Returns:
+            True if successful, False if deduction_id not found.
+        """
+        if deduction_id not in self.deduction_types:
+            return False
+
+        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] = []
+
+        deduction_type = self.deduction_types[deduction_id]
+        if deduction_type not in self.deductions_by_students[student_key]:
+            self.deductions_by_students[student_key].append(deduction_type)
+            self._save()
+
+        return True
+
+    def clear_student_deductions(self, net_ids: tuple):
+        """Clear all deductions for a student.
+
+        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 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]
+        self._save()
+
+    def set_days_late(self, net_ids: tuple, days_late: int):
+        """Set the number of days late 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).
+        """
+        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]
+        self._save()
+
+    def get_days_late(self, net_ids: tuple) -> Optional[int]:
+        """Get the number of days late 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.
+        """
+        student_key = tuple(net_ids) if not isinstance(net_ids, tuple) else net_ids
+        return self.days_late_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.
+
+        Args:
+            net_ids: Tuple of net_ids to look up. If None, returns 0.
+
+        Returns:
+            The total points deducted for the specified student(s).
+        """
+        if net_ids is None:
+            return 0.0
+
+        # Look up the student by their net_ids tuple
+        student_key = tuple(net_ids) if not isinstance(net_ids, tuple) else net_ids
+        deduction_items = self.deductions_by_students.get(student_key, [])
+
+        return sum(item.points for item in deduction_items)