PyKubeGrader 0.3.7__py3-none-any.whl → 0.3.9__py3-none-any.whl

pykubegrader/grade_reports/class_grade_report.py

@@ -0,0 +1,137 @@
+# # import the password and user from the build folder
+# try:
+#     from pykubegrader.build.passwords import password, user
+# except:  # noqa: E722
+#     print("Passwords not found, cannot access database")
+
+from pykubegrader.grade_reports.grading_config import assignment_type_list, skipped_users
+from pykubegrader.grade_reports.grade_report import GradeReport
+# from ..build.passwords import password, user
+from pykubegrader.telemetry import get_all_students
+
+
+import os
+import requests
+from requests.auth import HTTPBasicAuth
+import socket
+import pandas as pd
+import numpy as np
+import tqdm
+
+# user = user()
+# password = password()
+
+# Set the environment variables for the database
+# os.environ["JUPYTERHUB_USER"] = "jca92"
+# os.environ["TOKEN"] = "token"
+# os.environ["DB_URL"] = "https://engr-131-api.eastus.cloudapp.azure.com/"
+# os.environ["keys_student"] = "capture"
+# os.environ["user_name_student"] = "student"
+
+api_base_url = os.getenv("DB_URL")
+student_user = os.getenv("user_name_student")
+student_pw = os.getenv("keys_student")
+
+
+class ClassGradeReport:
+    """Generates and manages a class-wide grade report.
+
+    This class retrieves a list of students, initializes a structured grade report,
+    and populates it with individual student grade data. The final report includes
+    both assignment-specific grades and a weighted average grade.
+
+    Attributes:
+        student_list (list): A sorted list of all students in the class.
+        all_student_grades_df (pd.DataFrame): A DataFrame storing grades for each student,
+            including assignment scores and a weighted average.
+
+    Methods:
+        setup_class_grades():
+            Initializes an empty DataFrame with assignment names and weighted average columns.
+        update_student_grade(student):
+            Fetches and updates an individual student’s weighted average grades in the DataFrame.
+        fill_class_grades():
+            Iterates through all students to populate the class-wide grade report.
+    """
+
+    def __init__(self, user, password):
+        """Initializes the class grade report.
+
+        Retrieves the student list using authentication, sorts it, and sets up
+        the class-wide grade report by initializing and populating a DataFrame.
+        """
+        self.user = user
+        self.password = password
+        
+        self.student_list = get_all_students(self.user, self.password)
+        self.student_list = list( set(self.student_list)-set(skipped_users) )
+        self.student_list.sort()
+
+        self.setup_class_grades()
+        self.fill_class_grades()
+        self.get_class_stats()
+        
+
+    def setup_class_grades(self):
+        """Creates an empty DataFrame to store grades for all students.
+
+        The DataFrame contains assignment columns and a "Weighted Average Grade" column,
+        with students as index labels.
+        """
+        self.all_student_grades_df = pd.DataFrame(
+            np.nan,
+            dtype=float,
+            index=self.student_list,
+            columns=[a.name for a in assignment_type_list] + ["Weighted Average Grade"],
+        )
+
+    def update_student_grade(self, student):
+        """Fetches and updates the grade report for an individual student.
+
+        Args:
+            student (str): The username or identifier of the student.
+
+        Updates:
+            The student's row in `all_student_grades_df` with their weighted average grades.
+        """
+        report = GradeReport(params={"username": student}, display_=False)
+        row_series = report.weighted_average_grades.transpose().iloc[
+            0
+        ]  # Example transformation
+        row_series = row_series.reindex(self.all_student_grades_df.columns)
+        self.all_student_grades_df.loc[student] = row_series
+
+    def fill_class_grades(self):
+        """Populates the class-wide grade report with data from all students.
+
+        Iterates through the `student_list` and updates the DataFrame by fetching
+        and storing each student's weighted average grades.
+        """
+        for student in tqdm.tqdm(self.student_list):
+            self.update_student_grade(student)
+
+    def get_class_stats(self):
+        """Calculates and stores descriptive statistics for the class-wide grade report.
+        Requires filling class grades first
+        """
+        # Calculate descriptive statistics
+        self.stats_df = self.all_student_grades_df.describe(include='all')
+
+    def write_excel_spreadsheet(self, out_name='output.xlsx'):
+        """Exports the class-wide grade report to an Excel spreadsheet.
+
+        Args:
+            out_name (str, optional): Name of output file. Defaults to 'output.xlsx'.
+        """
+        # Export to Excel with different sheets
+        with pd.ExcelWriter('output.xlsx') as writer:
+            self.all_student_grades_df.to_excel(writer, sheet_name='all_student_grades')
+            self.stats_df.to_excel(writer, sheet_name='performance_statistics')
+
+
+def main():
+    class_grades = ClassGradeReport()
+    print(class_grades.all_student_grades_df)
+
+if __name__ == "__main__":
+    main()

pykubegrader/grade_reports/grade_report.py

@@ -0,0 +1,353 @@
+# TODO: if not due yet and score is 0, make NAN, fix the rendering
+
+from pykubegrader.telemetry import get_assignments_submissions
+from pykubegrader.grade_reports.assignments import Assignment
+from pykubegrader.grade_reports.grading_config import (
+    assignment_type_list,
+    aliases,
+    globally_exempted_assignments,
+    dropped_assignments,
+    optional_drop_week,
+    exclude_from_running_avg,
+    custom_grade_adjustments,
+)
+
+import pandas as pd
+from datetime import datetime
+from IPython.display import display
+import numpy as np
+
+from ..telemetry import get_assignments_submissions
+
+
+class GradeReport:
+    """Class to generate a grade report for a course and perform grade calculations for each student."""
+
+    def __init__(self, start_date="2025-01-06", verbose=True, params=None, display_ = True):
+        """Initializes an instance of the GradeReport class.
+        Args:
+            start_date (str, optional): The start date of the course. Defaults to "2025-01-06".
+            verbose (bool, optional): Indicates if verbose output should be displayed. Defaults to True.
+        """
+        self.assignments, self.student_subs = get_assignments_submissions(params=params)
+
+        self.start_date = start_date
+        self.verbose = verbose
+        self.assignment_type_list = assignment_type_list
+        self.aliases = aliases
+        self.globally_exempted_assignments = globally_exempted_assignments
+        self.dropped_assignments = dropped_assignments
+        self.optional_drop_week = optional_drop_week
+
+        # assignments that have been dropped for a given students.
+        self.student_assignments_dropped = []
+
+        self.setup_grades_df()
+        self.build_assignments()
+        self.update_global_exempted_assignments()
+        self.calculate_grades()
+        self.update_assignments_not_due_yet()
+        self.calculate_grades()
+        self.drop_lowest_n_for_types(1)
+        self.update_weekly_table()
+        self._build_running_avg()
+        self._calculate_final_average()
+        if display_:
+            try:
+                display(self.weekly_grades_df)
+                display(self.weighted_average_grades)
+            except:  # noqa: E722
+                pass
+
+    def update_assignments_not_due_yet(self):
+        """
+        Updates the score of assignments that are not due yet to NaN.
+        """
+        for assignment in self.graded_assignments:
+            if assignment.due_date:
+                # Convert due date to datetime object
+                due_date = datetime.fromisoformat(assignment.due_date.replace("Z", "+00:00"))
+                if due_date > datetime.now(due_date.tzinfo) and assignment.score == 0:
+                    assignment.score = np.nan
+                    assignment.exempted = True
+
+    def _calculate_final_average(self):
+        total_percentage = 1
+        df_ = self.compute_final_average()
+        score_earned = 0
+
+        for assignment_type in self.assignment_type_list:
+            if assignment_type.name in exclude_from_running_avg:
+                total_percentage -= assignment_type.weight
+
+            score_earned += assignment_type.weight * df_[assignment_type.name]
+
+        self.final_grade = score_earned / total_percentage
+        self.weighted_average_grades = pd.concat(
+            [
+                pd.DataFrame(self.final_grades),
+                pd.DataFrame(
+                    {"Running Avg": [self.final_grade]},
+                    index=["Weighted Average Grade"],
+                ),
+            ]
+        )
+
+    def grade_report(self):
+        """Generates a grade report for the course.
+        Returns:
+            pd.DataFrame: A DataFrame containing the grade report or weekly grades only.
+        """
+        self._update_running_avg()
+        return self.weekly_grades_df
+
+    def update_weekly_table(self):
+        """Updates the weekly grades table with the calculated scores."""
+        for assignment in self.graded_assignments:
+            if assignment.weekly:
+                self.weekly_grades_df.loc[f"week{assignment.week}", assignment.name] = (
+                    assignment.score
+                )
+
+    def update_global_exempted_assignments(self):
+        """Updates the graded assignments with the globally exempted assignments. If assignment doesn't exist, pass."""
+        for assignment_type, week in self.globally_exempted_assignments:
+            try:
+                self.get_graded_assignment(week, assignment_type)[0].exempted = True
+            except:  # noqa: E722
+                pass
+
+    def build_assignments(self):
+        """Generates a list of Assignment objects for each week, applying custom adjustments where needed."""
+        self.graded_assignments = []
+        weekly_assignments = self.get_weekly_assignments()
+
+        for assignment_type in weekly_assignments:
+            for week in range(1, self.get_num_weeks() + 1):  # Weeks start at 1
+                self.graded_assignment_constructor(assignment_type, week=week)
+
+        non_weekly_assignments = self.get_non_weekly_assignments()
+
+        for assignment_type in non_weekly_assignments:
+            self.graded_assignment_constructor(assignment_type)
+
+    def graded_assignment_constructor(self, assignment_type: str, **kwargs):
+        """Constructs a graded assignment object and appends it to the graded_assignments list.
+
+        Args:
+            assignment_type (str): Type of assignment. Options: readings, lecture, practicequiz, quiz, homework, lab, labattendance, practicemidterm, midterm, practicefinal, final.
+        """
+        custom_func = custom_grade_adjustments.get(
+            (assignment_type.name, kwargs.get("week", None)), None
+        )
+
+        filtered_assignments = self.get_assignment(
+            kwargs.get("week", None), assignment_type.name
+        )
+
+        new_assignment = Assignment(
+            name=assignment_type.name,
+            weekly=assignment_type.weekly,
+            weight=assignment_type.weight,
+            score=0,
+            grade_adjustment_func=custom_func,
+            # filters the submissions for an assignment and gets the last due date
+            due_date=self.determine_due_date(filtered_assignments),
+            max_score=self.get_max_score(filtered_assignments),
+            **kwargs,
+        )
+        self.graded_assignments.append(new_assignment)
+
+    def calculate_grades(self):
+        """Calculates the grades for each student based on the graded assignments.
+        If there are filtered assignments, the score is updated based on the submission.
+        Otherwise,
+        """
+        for assignment in self.graded_assignments:
+            filtered_submission = self.filter_submissions(
+                assignment.week, assignment.name
+            )
+
+            if filtered_submission:
+                for submission in filtered_submission:
+                    assignment.update_score(submission)
+
+            # runs if there are no filtered submissions
+            else:
+                assignment.update_score()
+
+    def compute_final_average(self):
+        """
+        Computes the final average by combining the running average from weekly assignments
+        and the midterm/final exam scores.
+        """
+
+        # Extract running average from the weekly table
+        self.final_grades = self.weekly_grades_df.loc["Running Avg"]
+
+        for assignment in self.graded_assignments:
+            if not assignment.weekly:
+                self.final_grades[f"{assignment.name}"] = assignment.score
+
+        return self.final_grades
+
+    def filter_submissions(self, week_number, assignment_type):
+        # Normalize the assignment type using aliases
+        normalized_type = self.aliases.get(
+            assignment_type.lower(), [assignment_type.lower()]
+        )
+
+        if week_number:
+            # Filter the assignments based on the week number and normalized assignment type
+            filtered = [
+                assignment
+                for assignment in self.student_subs
+                if assignment["week_number"] == week_number
+                and assignment["assignment_type"].lower() in normalized_type
+            ]
+
+        # If week_number is None, filter based on the normalized assignment type only
+        else:
+            # Filter the assignments based on the normalized assignment type
+            filtered = [
+                assignment
+                for assignment in self.student_subs
+                if assignment["assignment_type"].lower() in normalized_type
+            ]
+
+        return filtered
+
+    def get_assignment(self, week_number, assignment_type):
+        # Normalize the assignment type using aliases
+        normalized_type = self.aliases.get(
+            assignment_type.lower(), [assignment_type.lower()]
+        )
+
+        # Filter the assignments based on the week number and normalized assignment type
+        filtered = [
+            assignment
+            for assignment in self.assignments
+            if (assignment["week_number"] == week_number or week_number is None)
+            and assignment["assignment_type"].lower() in normalized_type
+        ]
+
+        return filtered
+
+    def get_graded_assignment(self, week_number, assignment_type):
+        return list(
+            filter(
+                lambda a: isinstance(a, Assignment)
+                and a.name == assignment_type
+                and (week_number is None or a.week == week_number),
+                self.graded_assignments,
+            )
+        )
+
+    def get_max_score(self, filtered_assignments):
+        if not filtered_assignments:
+            return None
+
+        return max(filtered_assignments, key=lambda x: x["id"])["max_score"]
+
+    def determine_due_date(self, filtered_assignments):
+        if not filtered_assignments:
+            return None  # Return None if the list is empty
+
+        # Convert due_date strings to datetime objects and find the max
+        max_due = max(
+            filtered_assignments,
+            key=lambda x: datetime.fromisoformat(x["due_date"].replace("Z", "+00:00")),
+        )
+
+        return max_due["due_date"]  # Return the max due date as a string
+
+    def get_non_weekly_assignments(self):
+        """Get all weekly assignments from the assignment list configuration"""
+        non_weekly_assignments = [
+            assignment
+            for assignment in self.assignment_type_list
+            if not assignment.weekly
+        ]
+        return non_weekly_assignments
+
+    def get_weekly_assignments(self):
+        """Get all weekly assignments from the assignment list configuration"""
+        weekly_assignments = [
+            assignment for assignment in self.assignment_type_list if assignment.weekly
+        ]
+        return weekly_assignments
+
+    def get_num_weeks(self):
+        """Get the number of weeks in the course"""
+        max_week_number = max(item["week_number"] for item in self.assignments)
+        return max_week_number
+
+    def setup_grades_df(self):
+        weekly_assignments = self.get_weekly_assignments()
+        max_week_number = self.get_num_weeks()
+        inds = [f"week{i + 1}" for i in range(max_week_number)] + ["Running Avg"]
+        restruct_grades = {
+            k.name: [0 for i in range(len(inds))] for k in weekly_assignments
+        }
+        new_weekly_grades = pd.DataFrame(restruct_grades, dtype=float)
+        new_weekly_grades["inds"] = inds
+        new_weekly_grades.set_index("inds", inplace=True)
+        self.weekly_grades_df = new_weekly_grades
+
+    def _build_running_avg(self):
+        """
+        Subfunction to compute and update the Running Avg row, handling NaNs.
+        """
+        
+        self.weekly_grades_df.loc["Running Avg"] = self.weekly_grades_df.drop(
+            "Running Avg", errors="ignore"
+        ).mean(axis=0, skipna=True)
+
+    def drop_lowest_n_for_types(self, n, assignments_=None):
+        """
+        Exempts the lowest n assignments for each specified assignment type.
+        If the lowest dropped score is from week 1, an additional lowest score is dropped.
+
+        :param assignments_: List of assignment types (names) to process.
+        :param n: Number of lowest scores to exempt per type.
+        """
+        from collections import defaultdict
+        import numpy as np
+
+        # Group assignments by name
+        assignment_groups = defaultdict(list)
+        for assignment in self.graded_assignments:
+            if assignments_ is None:
+                if (
+                    assignment.name in self.dropped_assignments
+                    and not assignment.exempted
+                ):
+                    assignment_groups[assignment.name].append(assignment)
+            else:
+                if assignment.name in assignments_ and not assignment.exempted:
+                    assignment_groups[assignment.name].append(assignment)
+
+        # Iterate over each specified assignment type and drop the lowest n scores
+        for name, assignments in assignment_groups.items():
+            # Filter assignments that are not already exempted (NaN scores should not count)
+            valid_assignments = [a for a in assignments if not np.isnan(a.score)]
+
+            # Sort assignments by score in ascending order
+            valid_assignments.sort(key=lambda a: a.score)
+
+            # Exempt the lowest `n` assignments
+            dropped = []
+            for i in range(min(n, len(valid_assignments))):
+                valid_assignments[i].exempted = True
+                dropped.append(valid_assignments[i])
+                self.student_assignments_dropped.append(valid_assignments[i])
+
+            # Check if the lowest dropped assignment is from week 1
+            if dropped and any(a.week in self.optional_drop_week for a in dropped):
+                # Find the next lowest non-exempted assignment and drop it
+                for a in valid_assignments:
+                    if not a.exempted:
+                        a.exempted = True
+                        break
+
+        self.calculate_grades()

pykubegrader/grade_reports/grading_config.py

@@ -0,0 +1,70 @@
+from pykubegrader.grade_reports.assignments import assignment_type
+
+# Assignment types, weekly, and weight
+# Total should add up to 1.0
+assignment_type_list = [
+    assignment_type("readings", True, 0.15),
+    assignment_type("lecture", True, 0.15),
+    assignment_type("practicequiz", True, 0.015),
+    assignment_type("quiz", True, 0.15),
+    assignment_type("homework", True, 0.15),
+    assignment_type("lab", True, 0.15),
+    assignment_type("labattendance", True, 0.05),
+    assignment_type("practicemidterm", False, 0.015),
+    assignment_type("midterm", False, 0.15),
+    assignment_type("practicefinal", False, 0.02),
+    assignment_type("final", False, 0.2),
+]
+
+# Custom grade adjustments, key is a tuple of assignment type and week, value is a lambda function that takes the score and returns the adjusted score
+custom_grade_adjustments = {
+    ("lecture", 3): lambda score: 100.0 if score > 0 else 0.0,
+    ("lecture", 4): lambda score: 100.0 if score > 0 else 0.0,
+    ("lecture", 5): lambda score: 100.0 if score > 0 else 0.0,
+}
+
+# Exempted assignments, key is a tuple of assignment type and week
+globally_exempted_assignments = [
+    ("readings", 6),
+    ("quiz", 6),
+    ("practicequiz", 6),
+    ("lecture", 6),
+    ("homework", 5),
+    ("lab", 5),
+    ("labattendance", 5),
+]
+
+# Common Assignment Aliases, these are other names used for the same assignment category
+aliases = {
+    "practicequiz": [
+        "practice quiz",
+        "practice-quiz",
+        "practice quiz",
+        "practice_quiz",
+        "practicequiz",
+    ],
+    "labattendance": ["labattendance", "attendance", "attend"],
+}
+
+# Skipped assignments, key is a tuple of assignment type and week
+skipped_assignments = {}
+
+# Dropped assignments a list of assignments which lowest score will be dropped
+dropped_assignments = [
+    "readings",
+    "lecture",
+    "practicequiz",
+    "quiz",
+    "homework",
+    "lab",
+    "labattendance",
+]
+
+# TAs and other users to skip in class grade report
+skipped_users = ['JCA', 'jca92', 'cnp68', 'dak329', 'xz498', 'ag4328', 'rg897', 'jce63', 'qt49']
+
+# Optional drop week, a list of weeks where the lowest score will be dropped
+optional_drop_week = [1]
+
+# Excluded from running average, a list of assignment types that will be excluded from the running average calculation
+exclude_from_running_avg = ["final"]

pykubegrader/grade_reports/test.ipynb

@@ -0,0 +1,43 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pykubegrader.grade_reports.class_grade_report import ClassGradeReport\n",
+    "\n",
+    "out = ClassGradeReport().run()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "engr131_dev",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

pykubegrader/grading_tester.ipynb

@@ -1,5 +1,56 @@
 {
  "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datetime import datetime\n",
+    "\n",
+    "import pandas as pd\n",
+    "import requests\n",
+    "from build.passwords import password, user\n",
+    "from grade_reports.grade_reports import filter_assignments, get_student_grades\n",
+    "from requests.auth import HTTPBasicAuth\n",
+    "\n",
+    "from pykubegrader.graders.late_assignments import calculate_late_submission\n",
+    "\n",
+    "api_base_url = \"https://engr-131-api.eastus.cloudapp.azure.com/\" "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from telemetry import get_assignments_submissions\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "self.assignments, self.student_subs = get_assignments_submissions()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -466,7 +517,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "engr131w25",
+   "display_name": "engr131_dev",
    "language": "python",
    "name": "python3"
   },
@@ -480,7 +531,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.13.1"
+   "version": "3.12.7"
   }
  },
  "nbformat": 4,

pykubegrader/submit/submit_assignment.py

@@ -42,9 +42,10 @@ def call_score_assignment(
         "assignment_title": assignment_title,
         "notebook_title": notebook_title,
     }
-    
-    if  os.environ["TOKEN"] is not None:
-        params["key_used"] = os.environ["TOKEN"]
+
+    token = os.getenv("TOKEN")
+    if token:
+        params["key_used"] = token
 
     username, password = get_credentials().values()