ygrader 1.2.3__tar.gz → 2.0.0__tar.gz

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

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

@@ -4,7 +4,7 @@ setup(
     name="ygrader",
     packages=["ygrader"],
     package_data={"ygrader": ["*.ahk"]},
-    version="1.2.3",
+    version="2.0.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.3 → ygrader-2.0.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.0.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-1.2.3 → ygrader-2.0.0}/ygrader/__init__.py

@@ -1,7 +1,10 @@
 """Default imports for package"""
 
-from .grader import Grader, CodeSource, ScoreMode
+from .grader import Grader, CodeSource
 from .upstream_merger import UpstreamMerger
 from .utils import CallbackFailed
-from .grading_item_config import generate_subitem_csvs, GradeItemConfig
+from .grading_item_config import (
+    LearningSuiteColumn,
+    LearningSuiteColumnParseError,
+)
 from .feedback import generate_feedback_zip

{ygrader-1.2.3 → ygrader-2.0.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-1.2.3 → ygrader-2.0.0}/ygrader/feedback.py

@@ -7,18 +7,20 @@ from typing import Dict
 import pandas
 
 from .deductions import StudentDeductions
-from .grading_item_config import GradeItemConfig
+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 GradeItemConfig.
+        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.
@@ -27,7 +29,7 @@ def generate_feedback_zip(
         Path to the generated zip file.
     """
     yaml_path = pathlib.Path(yaml_path)
-    grade_item_config = GradeItemConfig(yaml_path)
+    ls_column = LearningSuiteColumn(yaml_path)
 
     # Get the lab name from the YAML file's parent directory
     lab_name = yaml_path.stem
@@ -38,7 +40,7 @@ def generate_feedback_zip(
 
     # Load all student deductions for each subitem
     subitem_deductions: Dict[str, StudentDeductions] = {}
-    for subitem in grade_item_config.subitems:
+    for subitem in ls_column.items:
         if subitem.name in subitem_feedback_paths:
             feedback_path = subitem_feedback_paths[subitem.name]
             if feedback_path.exists():
@@ -48,15 +50,8 @@ def generate_feedback_zip(
         else:
             subitem_deductions[subitem.name] = StudentDeductions()
 
-    # Load the first subitem's CSV to get the list of students
-    # (all subitems should have the same students)
-    first_subitem = grade_item_config.subitems[0]
-    if not first_subitem.csv_path.exists():
-        raise FileNotFoundError(
-            f"CSV file for subitem '{first_subitem.name}' not found at {first_subitem.csv_path}"
-        )
-
-    students_df = pandas.read_csv(first_subitem.csv_path)
+    # 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:
@@ -68,7 +63,7 @@ def generate_feedback_zip(
             # Generate feedback content for this student
             feedback_content = _generate_student_feedback(
                 student_row=student_row,
-                grade_item_config=grade_item_config,
+                ls_column=ls_column,
                 subitem_deductions=subitem_deductions,
             )
 
@@ -92,14 +87,14 @@ def generate_feedback_zip(
 
 def _generate_student_feedback(
     student_row: pandas.Series,
-    grade_item_config: GradeItemConfig,
+    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.
-        grade_item_config: The GradeItemConfig object.
+        ls_column: The LearningSuiteColumn object.
         subitem_deductions: Mapping from subitem name to StudentDeductions.
 
     Returns:
@@ -121,11 +116,11 @@ def _generate_student_feedback(
     feedback_col_width = 45
     points_col_width = 15
 
-    for subitem in grade_item_config.subitems:
-        subitem_points_possible = subitem.points
+    for item in ls_column.items:
+        subitem_points_possible = item.points
         total_points_possible += subitem_points_possible
 
-        lines.append(f"{subitem.name} ({subitem_points_possible} points)")
+        lines.append(f"{item.name} ({subitem_points_possible} points)")
         lines.append("-" * 60)
 
         # Header row
@@ -135,8 +130,8 @@ def _generate_student_feedback(
 
         subitem_points_deducted = 0
 
-        # Get deductions for this student in this subitem
-        student_deductions_obj = subitem_deductions.get(subitem.name)
+        # 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

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

@@ -16,7 +16,7 @@ import pandas
 import yaml
 
 from . import grades_csv, student_repos, utils
-from .grading_item import GradeItem, ScoreMode
+from .grading_item import GradeItem
 from .utils import (
     CallbackFailed,
     TermColors,
@@ -40,7 +40,7 @@ class Grader:
     def __init__(
         self,
         lab_name: str,
-        grades_csv_path: pathlib.Path,
+        class_list_csv_path: pathlib.Path,
         work_path: pathlib.Path = pathlib.Path.cwd() / "temp",
     ):
         """
@@ -48,27 +48,31 @@ class Grader:
         ----------
         lab_name: str
             Name of the lab/assignment that you are grading (ie. 'lab3').
-            This is used for folder naming, logging mesasge, etc., and passed back to your callback functions.
-        grades_csv_path: pathlib.Path
-            Path to CSV file with student grades exported from LearningSuite.  You need to export netid, first
-            and last name, and any grade columns you want to populate.
+            This is used for logging messages and passed back to your callback functions.
+        class_list_csv_path: pathlib.Path
+            Path to CSV file with class list exported from LearningSuite. You need to export netid, first
+            and last name columns.
         work_path: pathlib.Path
             Path to directory where student files will be placed.  For example, if you pass in '.', then student
             code would be placed in './lab3'.  By default the working path is a "temp" folder created in your working directory.
         """
         self.lab_name = lab_name
-        self.grades_csv_path = pathlib.Path(grades_csv_path).resolve()
+        self.class_list_csv_path = pathlib.Path(class_list_csv_path).resolve()
 
-        # Make sure grades csv exists, and that file is writable
-        if not self.grades_csv_path.is_file():
-            error("grades_csv_path", "(" + str(grades_csv_path) + ")", "does not exist")
+        # Make sure class list csv exists and is readable
+        if not self.class_list_csv_path.is_file():
+            error(
+                "class_list_csv_path",
+                "(" + str(class_list_csv_path) + ")",
+                "does not exist",
+            )
         try:
-            with open(grades_csv_path, "a", encoding="utf-8"):
+            with open(class_list_csv_path, "r", encoding="utf-8"):
                 pass
         except PermissionError:
             error(
-                "You do not have permissions to modify the grades_csv_path file",
-                "(" + str(grades_csv_path) + ").",
+                "You do not have permissions to read the class_list_csv_path file",
+                "(" + str(class_list_csv_path) + ").",
                 "Is this file open and locked?",
             )
 
@@ -78,11 +82,11 @@ class Grader:
 
         # Read CSV and make sure it isn't empty
         try:
-            pandas.read_csv(self.grades_csv_path)
+            pandas.read_csv(self.class_list_csv_path)
         except pandas.errors.EmptyDataError:
             error(
-                "Your grades csv",
-                "(" + str(grades_csv_path) + ")",
+                "Your class list csv",
+                "(" + str(class_list_csv_path) + ")",
                 "appears to be empty",
             )
 
@@ -102,29 +106,24 @@ class Grader:
 
     def add_item_to_grade(
         self,
-        csv_col_name,
+        item_name,
         grading_fcn,
+        deductions_yaml_path,
         *,
         grading_fcn_args_dict=None,
         max_points=None,
-        score_mode=ScoreMode.MANUAL,
-        deductions_yaml_path=None,
-        help_msg=None,
     ):
         """Add a new item you want to grade.
 
         Parameters
         ----------
-        csv_col_name: str
-            The column name from your grading CSV file that you want to grade.
         grading_fcn: Callable
             The callback function that will perform all your grading work. Your callback function will be provided with the following arguments:
 
               * lab_name (*str*): This will pass back the lab name you passed to *__init__*.
                 Useful if you use the same callback function to grade multiple different assignments.
-
+              * item_name (*str*): The name of the item being graded (e.g., "answers.txt").
               * student_code_path (*pathlib.Path*): The location where the unzipped/cloned student files are stored.
-              * csv_col_name (*str*): The current CSV column being graded.
               * points (*int*): The maximum number of points possible for the item being graded, used for validating the
                 grade when prompting the user to input a grade.  If your callback function automatically calcuates and
                 returns a grade, this argument is ignored.
@@ -157,38 +156,22 @@ class Grader:
                 def my_callback(**kw):
                     lab_name = kw["lab_name"]
                     first_name = kw["first_names"][0]
+        deductions_yaml_path: pathlib.Path
+            Path to the YAML file for storing deductions and tracking grading status.
         grading_fcn_args_dict: dict
             (Optional) A dictionary of additional arguments that will be passed to your grading function.
         max_points: int
             (Optional) Number of max points for the graded column.
-        deductions_yaml_path: pathlib.Path
-            (Optional) Path to the YAML file for storing deductions. Required if score_mode is DEDUCTIONS.
-        help_msg: str
-            (Optional) When the script asks the user for a grade, it will print this message first.  This can be a helpful
-            reminder to the TAs of a grading rubric, things they should watch out for, etc.
         """
         # Check data types
         if not isinstance(grading_fcn, Callable):
             error("'grading_fcn' must be a callable function")
 
-        df = pandas.read_csv(self.grades_csv_path)
-        if csv_col_name is not None and csv_col_name not in df:
-            error(
-                "Provided grade column name",
-                "(" + csv_col_name + ")",
-                "does not exist in grades_csv_path",
-                "(" + str(self.grades_csv_path) + ").",
-                "Columns:",
-                list(df.columns),
-            )
-
         item = GradeItem(
             self,
-            csv_col_name,
-            grading_fcn,
-            max_points,
-            help_msg=help_msg,
-            score_mode=score_mode,
+            item_name,
+            fcn=grading_fcn,
+            max_points=max_points,
             deductions_yaml_path=deductions_yaml_path,
             fcn_args_dict=grading_fcn_args_dict,
         )
@@ -197,21 +180,32 @@ class Grader:
         )
         self.items.append(item)
 
-    def add_analysis_item(
+    def add_item_to_grade_from_config(
         self,
-        analysis_fcn,
+        grade_item_config,
+        grading_fcn,
     ):
-        """Run an analysis function on the student code, without performing any grading.
+        """Add a new item to grade using a GradeItemConfig object.
+
+        This is a convenience method that extracts all necessary information from
+        a GradeItemConfig object and calls add_item_to_grade.
 
         Parameters
         ----------
-        analysis_fcn: Callable
-            The callback function that will perform the analysis.
-            The callback will be provided with the same arguments as when you register a grading function.
-
+        grade_item_config: GradeItemConfig
+            The configuration object for the grade item, containing points,
+            feedback_path, and other_data.
+        grading_fcn: Callable
+            The callback function that will perform the grading work.
+            See add_item_to_grade for details on the callback function signature.
         """
-
-        self.add_item_to_grade(None, analysis_fcn)
+        self.add_item_to_grade(
+            grading_fcn=grading_fcn,
+            item_name=grade_item_config.name,
+            deductions_yaml_path=grade_item_config.feedback_path,
+            grading_fcn_args_dict=grade_item_config.other_data,
+            max_points=grade_item_config.points,
+        )
 
     def set_submission_system_learning_suite(self, zip_path):
         """
@@ -461,10 +455,11 @@ class Grader:
                 )
 
     def _get_all_csv_cols_to_grade(self):
-        """Collect all columns that will be graded into a single list"""
-        return [
-            item.csv_col_name for item in self.items if item.csv_col_name is not None
-        ]
+        """Collect all columns that will be graded into a single list.
+
+        Returns empty list since grades are stored in deductions files, not CSV columns.
+        """
+        return []
 
     def run(self):
         """Call this to start (or resume) the grading process"""
@@ -477,7 +472,7 @@ class Grader:
 
         # Read in CSV and validate.  Print # students who need a grade
         student_grades_df = grades_csv.parse_and_check(
-            self.grades_csv_path, self._get_all_csv_cols_to_grade()
+            self.class_list_csv_path, self._get_all_csv_cols_to_grade()
         )
 
         # Filter by students who need a grade
@@ -520,14 +515,13 @@ class Grader:
             concated_names = grades_csv.get_concated_names(row)
 
             # Check if student/group needs grading
-            if not any(item.analysis_only for item in self.items):
-                num_group_members_need_grade_per_item = [
-                    item.num_grades_needed(row) for item in self.items
-                ]
+            num_group_members_need_grade_per_item = [
+                item.num_grades_needed_deductions(net_ids) for item in self.items
+            ]
 
-                if sum(num_group_members_need_grade_per_item) == 0:
-                    # This student/group is already fully graded
-                    continue
+            if sum(num_group_members_need_grade_per_item) == 0:
+                # This student/group is already fully graded
+                continue
 
             # Print name(s) of who we are grading
             student_work_path = self.work_path / utils.names_to_dir(
@@ -798,6 +792,7 @@ class Grader:
 def _verify_callback_fcn(fcn, item, fcn_extra_args_dict=None):
     callback_args = [
         "lab_name",
+        "item_name",
         "student_code_path",
         "run",
         "build",
@@ -809,10 +804,6 @@ def _verify_callback_fcn(fcn, item, fcn_extra_args_dict=None):
         if item.max_points:
             callback_args.append("max_points")
 
-        # If this is a fcn for a graded item (not a prep-only function), then
-        # this argument is required.
-        callback_args.append("csv_col_name")
-
     callback_args_optional = [
         "section",
         "homework_id",

{ygrader-1.2.3 → ygrader-2.0.0}/ygrader/grades_csv.py

@@ -1,4 +1,4 @@
-""" Manage the grade CSV file"""
+"""Manage the grade CSV file"""
 
 import pandas
 
@@ -6,14 +6,14 @@ from .student_repos import convert_github_url_format
 from .utils import TermColors, error, print_color, warning
 
 
-def parse_and_check(grades_csv_path, csv_cols):
-    """Parse the grades CSV file and check that column names are valid"""
+def parse_and_check(class_list_csv_path, csv_cols):
+    """Parse the class list CSV file and check that column names are valid"""
     try:
-        grades_df = pandas.read_csv(grades_csv_path)
+        grades_df = pandas.read_csv(class_list_csv_path)
     except pandas.errors.EmptyDataError:
         error(
             "Exception: pandas.errors.EmptyDataError.  Is your",
-            grades_csv_path.name,
+            class_list_csv_path.name,
             "file empty?",
         )
     check_csv_column_names(grades_df, csv_cols)