PyKubeGrader 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

{PyKubeGrader-0.3.0.dist-info → PyKubeGrader-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyKubeGrader
-Version: 0.3.0
+Version: 0.3.2
 Summary: Add a short description here!
 Home-page: https://github.com/pyscaffold/pyscaffold/
 Author: jagar2

{PyKubeGrader-0.3.0.dist-info → PyKubeGrader-0.3.2.dist-info}/RECORD

@@ -1,13 +1,15 @@
 pykubegrader/__init__.py,sha256=AoAkdfIjDDZGWLlsIRENNq06L9h46kDGBIE8vRmsCfg,311
+pykubegrader/grading_tester.ipynb,sha256=2c1JgnV-zgP405Q3rlEkOlMJPm_9Qga0Z0MVWpFk5No,18531
 pykubegrader/initialize.py,sha256=Bwu1q18l18FB9lGppvt-L41D5gzr3S8t6zC0_UbrASw,3994
 pykubegrader/telemetry.py,sha256=50Qp5WXeF7PD5FxDLFXWFAnQ2Yobj-wL3Dxh0Hz_vh0,6552
-pykubegrader/utils.py,sha256=FrxuZ3gtTBTm5FQeH5c0bF9kFjA_AVtE5AYeFhzwKZ0,827
+pykubegrader/utils.py,sha256=jlJklKvRhY3O7Hz2aaU1m0y3p_n9eMAXNnAF7LUEaPY,1275
 pykubegrader/validate.py,sha256=OKnItGyd-L8QPKcsE0KRuwBI_IxKiJzMLJKZiA2j3II,11184
 pykubegrader/build/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 pykubegrader/build/api_notebook_builder.py,sha256=dlcVrGgsvxnt6GlAUN3e-FrpsPNJKXSHni1fstRCBik,20311
-pykubegrader/build/build_folder.py,sha256=WTdPFsV1PRJ9U_730ckcWezQfMEL2oCH4ZDoflmr30M,83138
+pykubegrader/build/build_folder.py,sha256=Asc-VdhXgxQfOfFIWJShhXrF2EITJOIZQ5Dz_2y-P2I,85358
 pykubegrader/build/clean_folder.py,sha256=8N0KyL4eXRs0DCw-V_2jR9igtFs_mOFMQufdL6tD-38,1323
 pykubegrader/build/markdown_questions.py,sha256=cSh8mkHK3hh-etJdgrZu9UQi1WPrKQtofkzLCUp1Z-w,4676
+pykubegrader/grade_reports/grade_reports.py,sha256=TmT_F2enezU_BIFPBQ0oZ4l5nBgPw4PSBo-8wJ_gt4w,5915
 pykubegrader/graders/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 pykubegrader/graders/late_assignments.py,sha256=_2-rA5RqO0BWY9WAQA_mbCxxPKTOiJOl-byD2CYWaE0,1393
 pykubegrader/log_parser/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
@@ -17,21 +19,21 @@ pykubegrader/submit/submit_assignment.py,sha256=UgJXKWw5b8-bRSFnba4iHAyXnujULHcW
 pykubegrader/tokens/tokens.py,sha256=X9f3SzrGCrAJp_BXhr6VJn5f0LxtgQ7HLPBw7zEF2BY,1198
 pykubegrader/tokens/validate_token.py,sha256=MQtgz_USvSZ9JahJ48ybjp74F5aYz64lhtvuwVc4kQw,2712
 pykubegrader/widgets/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pykubegrader/widgets/multiple_choice.py,sha256=CE7y6DPIhm4UuD8I1nwWPF2l9sKtKvYhbyPpeZ1qmQc,2686
-pykubegrader/widgets/question_processor.py,sha256=59R9oBiemuVJP0qzsR1kY8MeqDq4Kh99AYRq9RGujsg,1223
+pykubegrader/widgets/multiple_choice.py,sha256=ag6W-HN7isHkIUmB4BxtK8T1JhuV3FBLUBAhcV6rN80,2729
+pykubegrader/widgets/question_processor.py,sha256=fFH2ffMPYAJHsDn1RweEBnibfoZlSvTANUxYT3EPb5w,1375
 pykubegrader/widgets/reading_question.py,sha256=y30_swHwzH8LrT8deWTnxctAAmR8BSxTlXAqMgUrAT4,3031
-pykubegrader/widgets/select_many.py,sha256=l7YQ8QT5k71j36KC1f5LmKIAX2bXpvMDGc6nqIJ1PeQ,4116
+pykubegrader/widgets/select_many.py,sha256=7Bq1Je1Lx8BY3c_lVZixN-Ijw67IWO6EX3qWtcJ2NmM,4625
 pykubegrader/widgets/student_info.py,sha256=xhQgKehk1r5e6N_hnjAIovLdPvQju6ZqQTOiPG0aevg,3568
 pykubegrader/widgets/style.py,sha256=fVBMYy_a6Yoz21avNpiORWC3f5FD-OrVpaZ3npmunvs,1656
 pykubegrader/widgets/true_false.py,sha256=QllIhHuJstJft_RuShkxI_fFFTaDAlzNZOFNs00HLIM,2842
 pykubegrader/widgets/types_question.py,sha256=kZdRRXyFzOtYTmGdC7XWb_2oaxqg1WSuLcQn_sTj6Qc,2300
 pykubegrader/widgets_base/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pykubegrader/widgets_base/multi_select.py,sha256=Btr09qjl2g2-wtKEtI3RYwo1Xm1dfFnHnDzw_1Yfqf4,4148
-pykubegrader/widgets_base/reading.py,sha256=xmvN1UIXwk32v9S-JhsXwDc7axPlgpvoxSeM3II8sxY,5393
-pykubegrader/widgets_base/select.py,sha256=RgSieRtBapAwXLd_ByJtT1L1EeUSi-9pFTuIm7zwDVE,2649
-PyKubeGrader-0.3.0.dist-info/LICENSE.txt,sha256=YTp-Ewc8Kems8PJEE27KnBPFnZSxoWvSg7nnknzPyYw,1546
-PyKubeGrader-0.3.0.dist-info/METADATA,sha256=W0PXYFxnn7vuAKI6_E7gMHfYnoftvYbYNorwwJwSfP0,2806
-PyKubeGrader-0.3.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-PyKubeGrader-0.3.0.dist-info/entry_points.txt,sha256=BbLXpFZObpOXA8e3p3GcFkL-sHdUnDLUcnYmc6zx3NI,201
-PyKubeGrader-0.3.0.dist-info/top_level.txt,sha256=e550Klfze6higFxER1V62fnGOcIgiKRbsrl9CC4UdtQ,13
-PyKubeGrader-0.3.0.dist-info/RECORD,,
+pykubegrader/widgets_base/multi_select.py,sha256=JgjhHQJL8Pf0-1T_wdZCecAK1IgVJrZBCbR6b3jvDtk,4181
+pykubegrader/widgets_base/reading.py,sha256=ChUS3NOTa_HLtNpxR8hGX80LPKMvYMypnR6dFknfxus,5430
+pykubegrader/widgets_base/select.py,sha256=tEDg7GEjsZnz1646YTthTeamujVRS5jDJWMsXhmOQbI,2705
+PyKubeGrader-0.3.2.dist-info/LICENSE.txt,sha256=YTp-Ewc8Kems8PJEE27KnBPFnZSxoWvSg7nnknzPyYw,1546
+PyKubeGrader-0.3.2.dist-info/METADATA,sha256=le0n8bDcxtGgZ-XG4-2YXPVpq6nDgai_EKdeRdcDLcg,2806
+PyKubeGrader-0.3.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+PyKubeGrader-0.3.2.dist-info/entry_points.txt,sha256=BbLXpFZObpOXA8e3p3GcFkL-sHdUnDLUcnYmc6zx3NI,201
+PyKubeGrader-0.3.2.dist-info/top_level.txt,sha256=e550Klfze6higFxER1V62fnGOcIgiKRbsrl9CC4UdtQ,13
+PyKubeGrader-0.3.2.dist-info/RECORD,,

pykubegrader/build/build_folder.py

@@ -616,6 +616,21 @@ class NotebookProcessor:
             shutil.copy("./keys/.client_private_key.bin", client_private_key)
             shutil.copy("./keys/.server_public_key.bin", server_public_key)
 
+            # Extract the assignment config
+            config = extract_config_from_notebook(temp_notebook_path)
+
+            files = extract_files(config)
+
+            # print(f"Files: {files}, from {temp_notebook_path}")
+
+            if files:
+                for file in files:
+                    print(f"Copying {file} to {os.path.join(notebook_subfolder, file)}")
+                    shutil.copy(
+                        os.path.join(self.root_folder, file),
+                        os.path.join(notebook_subfolder, file),
+                    )
+
             client_private_key = os.path.join(
                 notebook_subfolder,
                 ".client_private_key.bin",
@@ -1352,15 +1367,18 @@ def extract_SELECT_MANY(ipynb_file):
                         1  # Increment subquestion number for each question
                     )
 
-                    # Extract question text (### heading)
-                    question_text_match = re.search(
-                        r"^###\s*\*\*(.+)\*\*", markdown_content, re.MULTILINE
-                    )
-                    question_text = (
-                        question_text_match.group(1).strip()
-                        if question_text_match
-                        else None
-                    )
+                    # # Extract question text (### heading)
+                    # question_text_match = re.search(
+                    #     r"^###\s*\*\*(.+)\*\*", markdown_content, re.MULTILINE
+                    # )
+                    # question_text = (
+                    #     question_text_match.group(1).strip()
+                    #     if question_text_match
+                    #     else None
+                    # )
+
+                    # Extract question text enable multiple lines
+                    question_text = extract_question(markdown_content)
 
                     # Extract OPTIONS (lines after #### options)
                     options_match = re.search(
@@ -2126,6 +2144,57 @@ def update_initialize_assignment(
         print(f"No matching lines found in '{notebook_path}'.")
 
 
+def extract_config_from_notebook(notebook_path):
+    """
+    Extract configuration text from a Jupyter Notebook.
+
+    Parameters:
+        notebook_path (str): Path to the Jupyter Notebook file.
+
+    Returns:
+        str: The configuration text if found, otherwise an empty string.
+    """
+    with open(notebook_path, "r", encoding="utf-8") as f:
+        notebook_data = json.load(f)
+
+    # Iterate through cells to find the configuration text
+    config_text = ""
+    for cell in notebook_data.get("cells", []):
+        if cell.get("cell_type") == "raw":  # Check for code cells
+            source = "".join(cell.get("source", []))
+            if "# ASSIGNMENT CONFIG" in source:
+                config_text = source
+                break
+
+    return config_text
+
+
+def extract_files(config_text):
+    """
+    Extract the list of files from the given configuration text, excluding .bin files.
+
+    Parameters:
+        config_text (str): The configuration text to process.
+
+    Returns:
+        list: A list of file names excluding .bin files.
+    """
+    # Regular expression to extract files list
+    file_pattern = re.search(r"files:\s*\[(.*?)\]", config_text, re.DOTALL)
+
+    if file_pattern:
+        files = file_pattern.group(1)
+        # Split the list into individual file names and exclude .bin files
+        file_list = [
+            file.strip()
+            for file in files.split(",")
+            if not file.strip().endswith(".bin")
+        ]
+        return file_list
+    else:
+        return []
+
+
 def main():
     parser = argparse.ArgumentParser(
         description="Recursively process Jupyter notebooks with '# ASSIGNMENT CONFIG', move them to a solutions folder, and run otter assign."

pykubegrader/grade_reports/grade_reports.py

@@ -0,0 +1,171 @@
+import pandas as pd
+import requests
+from requests.auth import HTTPBasicAuth
+
+from ..build.passwords import password, user
+
+
+def format_assignment_table(assignments):
+    # Create DataFrame
+    df = pd.DataFrame(assignments)
+
+    # Replacements for normalization
+    replacements = {
+        "practicequiz": "practice quiz",
+        "practice-quiz": "practice quiz",
+        "attend": "attendance",
+        "attendance": "attendance",
+    }
+
+    # Remove assignments of type 'test'
+    remove_assignments = ["test"]
+
+    # Apply replacements
+    df["assignment_name"] = df["assignment_type"].replace(replacements)
+
+    # Filter out specific assignment types
+    df = df[~df["assignment_type"].isin(remove_assignments)]
+
+    # Sort by week number and assignment name
+    df = df.sort_values(by=["assignment_name", "week_number"]).reset_index(drop=True)
+
+    return df
+
+
+def get_student_grades(
+    student_username, api_base_url="https://engr-131-api.eastus.cloudapp.azure.com/"
+):
+    params = {"username": student_username}
+    res = requests.get(
+        url=api_base_url.rstrip("/") + "/student-grades-testing",
+        params=params,
+        auth=HTTPBasicAuth(user(), password()),
+    )
+
+    [assignments, sub] = res.json()
+
+    assignments_df = format_assignment_table(assignments)
+
+    return assignments_df, pd.DataFrame(sub)
+
+
+def filter_assignments(df, max_week=None, exclude_types=None):
+    """
+    Remove assignments with week_number greater than max_week
+    or with specific assignment types.
+
+    :param df: DataFrame containing assignments.
+    :param max_week: Maximum allowed week_number (int).
+    :param exclude_types: A single assignment type or a list of assignment types to exclude.
+    :return: Filtered DataFrame.
+    """
+    if max_week is not None:
+        df = df[df["week_number"] <= max_week]
+
+    if exclude_types is not None:
+        # Ensure exclude_types is a list
+        if not isinstance(exclude_types, (list, tuple, set)):
+            exclude_types = [exclude_types]
+        df = df[~df["assignment_type"].isin(exclude_types)]
+
+    return df
+
+
+# import os
+# import numpy as np
+# import pandas as pd
+# import socket
+# import requests
+# from IPython.core.interactiveshell import ExecutionInfo
+# from requests import Response
+# from requests.auth import HTTPBasicAuth
+# from requests.exceptions import RequestException
+# from pykubegrader.graders.late_assignments import calculate_late_submission
+
+
+# api_base_url = os.getenv("DB_URL")
+# student_user = "admin" # os.getenv("user_name_student")
+# student_pw = "TrgpUuadm2PWtdgtC7Yt" # os.getenv("keys_student")
+
+# from_hostname = socket.gethostname().removeprefix("jupyter-")
+# from_env = os.getenv("JUPYTERHUB_USER")
+# params = {"username": from_env}
+
+# letteronly = lambda s: re.sub(r'[^a-zA-Z]', '', s)
+# start_date='2025-01-06'
+
+# # get assignment information
+# res = requests.get(
+#     url=api_base_url.rstrip("/") + "/assignments",
+#     auth=HTTPBasicAuth(student_user, student_pw),)
+# res.raise_for_status()
+# assignments = res.json()
+
+# # get submission information
+# res = requests.get(
+#     url=api_base_url.rstrip("/") + "/testing/get-all-assignment-subs",
+#     auth=HTTPBasicAuth('testing', 'Vok8WzmuCMVYULw3tqzJ'),
+# )
+# subs = res.json()
+# student_subs = [sub for sub in subs if sub['student_email']==from_env]
+
+# # set up new df format
+# weights = {'homework':0.15, 'lab':0.15, 'lecture':0.15, 'quiz':0.15, 'readings':0.15,
+#         # 'midterm':0.15, 'final':0.2
+#         'labattendance':0.05,  'practicequiz':0.05, }
+# assignment_types = list(set([a['assignment_type'] for a in assignments]))+['Running Avg']
+# inds = [f'week{i+1}' for i in range(11)]+['Running Avg']
+# restruct_grades = {k: np.zeros(len(inds)) for k in assignment_types}
+# restruct_grades['inds']=inds
+# new_weekly_grades = pd.DataFrame(restruct_grades)
+
+# for assignment in assignments:
+#     # get the assignment from all submissions
+#     subs = [ sub for sub in student_subs if \
+#             letteronly(sub['assignment_type'])==letteronly(assignment['assignment_type']) and \
+#             sub['week_number']==assignment['week_number'] ]
+#     if len(subs)==0: continue
+#     if len(subs)>1:
+
+#     # get due date from assignment
+#     due_date = datetime.datetime.strptime(assignment['due_date'], "%Y-%m-%d %H:%M:%S")
+#     for sub in subs:
+#         entry_date = datetime.strptime(sub['timestamp'], '%Y-%m-%dT%H:%M:%SZ')
+#         if entry_date <= due_date:
+#         else after_due).append(entry)
+#         calculate_late_submission(due = due_date, # '2025-01-21T18:59:59Z'.
+#                             submitted = subs"%Y-%m-%d %H:%M:%S".
+#     - Q0 (float): Initial value (default is 100).
+#     - Q_min (float): Minimum value (default is 40).
+#     - k (float): Decay constant per minute (default is 6.88e-5).
+
+#     # get max from before due date
+
+#     # get max score from after due date and calculate
+#     print(sub['assignment'])
+#     print(subs)
+# return
+# # fill out grades
+# new_weekly_grades.set_index('inds',inplace=True)
+# splitted = [col_name.split('-')+[grades[col_name][0]] for col_name in grades.columns]
+# for week,assignment,grade in splitted: new_weekly_grades.loc[week,assignment] = grade
+
+# # Calculate the current week (1-based indexing)
+# start_date = datetime.strptime(start_date, "%Y-%m-%d")
+# today = datetime.now()
+# days_since_start = (today - start_date).days
+# current_week = days_since_start // 7 + 1
+
+# # Get average until current week
+# new_weekly_grades.iloc[-1] = new_weekly_grades.iloc[:current_week-1].mean()
+
+# # make new dataframe with the midterm, final, and running average
+# max_key_length = max(len(k) for k in weights.keys())
+# total = 0
+# for k, v in weights.items():
+#     grade = new_weekly_grades.get(k, pd.Series([0])).iloc[-1]
+#     total+=grade*v
+#     print(f'{k:<{max_key_length}}:\t {grade:.2f}')
+# print(f'\nTotal: {total}') # exclude midterm and final
+
+# return new_out

pykubegrader/grading_tester.ipynb

@@ -0,0 +1,477 @@
+{
+ "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/\"\n",
+    "\n",
+    "\n",
+    "def get_all_students():\n",
+    "    res = requests.get(\n",
+    "        url=api_base_url.rstrip(\"/\") + \"/get-all-submission-emails\",\n",
+    "        auth=HTTPBasicAuth(user(), password()),\n",
+    "    )\n",
+    "\n",
+    "    return res.json()\n",
+    "\n",
+    "\n",
+    "# def get_student_grades(student_id):\n",
+    "#     params = {\"username\": student_id}\n",
+    "#     res = requests.get(\n",
+    "#         url=api_base_url.rstrip(\"/\") + \"/student-grades-testing\",\n",
+    "#         params=params,\n",
+    "#         auth=HTTPBasicAuth(user(), password()),\n",
+    "#     )\n",
+    "\n",
+    "#     [assignments, sub] = res.json()\n",
+    "\n",
+    "#     return assignments, sub\n",
+    "\n",
+    "\n",
+    "def get_student(student):\n",
+    "    print(student)\n",
+    "    # Get assignments and submissions for the student (assumed functions)\n",
+    "    assignments, submissions = get_student_grades(student)\n",
+    "\n",
+    "    # Recalculate grades and get a grades dictionary\n",
+    "    grades_dict = recalculate_best_grades(assignments, submissions)\n",
+    "\n",
+    "    # Calculate averages and build a row for the student\n",
+    "    row = calculate_averages(grades_dict, student)\n",
+    "\n",
+    "    # Convert the row (a dictionary) into a DataFrame\n",
+    "    # row_df = pd.DataFrame([row])\n",
+    "\n",
+    "    return row\n",
+    "\n",
+    "\n",
+    "def get_all_student_grades():\n",
+    "    # Initialize an empty DataFrame to hold all student grades\n",
+    "    df = pd.DataFrame()\n",
+    "\n",
+    "    # Get all students (assuming get_all_students() is a defined function)\n",
+    "    students = get_all_students()\n",
+    "\n",
+    "    for student in students:\n",
+    "        row_df = get_student(student)\n",
+    "\n",
+    "        # Append the row to the DataFrame\n",
+    "        df = pd.concat([df, row_df], ignore_index=True)\n",
+    "\n",
+    "    return df\n",
+    "\n",
+    "\n",
+    "def get_max_deadline(assignments, assignment_name, week_number):\n",
+    "    matching_rows = assignments[\n",
+    "        (assignments[\"week_number\"] == week_number)\n",
+    "        & (assignments[\"assignment_name\"] == assignment_name)\n",
+    "    ]\n",
+    "\n",
+    "    max_timestamp = matching_rows[\"due_date\"].max()\n",
+    "    return max_timestamp\n",
+    "\n",
+    "\n",
+    "def calculate_averages(grades_dict, student_id):\n",
+    "    # Create a DataFrame from the dictionary\n",
+    "    df = pd.DataFrame(\n",
+    "        grades_dict\n",
+    "    ).T  # Transpose the dictionary to make assignments rows\n",
+    "    df[\"score\"] = df[\"score\"].astype(float)  # Ensure the scores are floats\n",
+    "\n",
+    "    # Create a dictionary for the row data\n",
+    "    row_data = {\"student_id\": student_id}\n",
+    "\n",
+    "    # Add scores for each assignment as separate columns\n",
+    "    for assignment, details in grades_dict.items():\n",
+    "        column_name = (\n",
+    "            f\"{details['assignment_name']}_week_{details['week_number']}\".replace(\n",
+    "                \"_\", \" \"\n",
+    "            )\n",
+    "        )\n",
+    "        row_data[column_name] = float(details[\"score\"])\n",
+    "\n",
+    "    # Calculate and add average scores for each assignment category\n",
+    "    averages = df.groupby(\"assignment_name\")[\"score\"].mean()\n",
+    "    for assignment_name, avg_score in averages.items():\n",
+    "        row_data[f\"{assignment_name}_average\".replace(\"_\", \" \")] = avg_score\n",
+    "\n",
+    "    # # Course Percentage Performance\n",
+    "    row_data[\"Current Course Percentage\"] = (\n",
+    "        (row_data[\"quiz average\"] + row_data[\"practice quiz average\"] * 0.1) * 15\n",
+    "        + (row_data[\"homework average\"]) * 15\n",
+    "        + row_data[\"lab average\"] * 15\n",
+    "        + row_data[\"lecture average\"] * 15\n",
+    "        + row_data[\"readings average\"] * 15\n",
+    "        + row_data[\"attendance average\"] * 5\n",
+    "    ) / (15 + 15 + 15 + 15 + 15 + 5)\n",
+    "\n",
+    "    # Create a single-row DataFrame\n",
+    "    single_row_df = pd.DataFrame([row_data])\n",
+    "    return single_row_df\n",
+    "\n",
+    "\n",
+    "def recalculate_best_grades(\n",
+    "    assignments,\n",
+    "    submissions,\n",
+    "    custom_order=[\n",
+    "        \"lecture\",\n",
+    "        \"homework\",\n",
+    "        \"lab\",\n",
+    "        \"attendance\",\n",
+    "        \"readings\",\n",
+    "        \"quiz\",\n",
+    "        \"practice quiz\",\n",
+    "    ],\n",
+    "):\n",
+    "    assignments[\"assignment_name\"] = pd.Categorical(\n",
+    "        assignments[\"assignment_name\"], categories=custom_order, ordered=True\n",
+    "    )\n",
+    "\n",
+    "    # Sort by 'Category' (custom order) and then by 'Value'\n",
+    "    sorted_df = assignments.sort_values(by=[\"assignment_name\", \"week_number\"])\n",
+    "\n",
+    "    week_number = 3\n",
+    "\n",
+    "    exclude_types = None\n",
+    "\n",
+    "    sorted_df = filter_assignments(sorted_df, exclude_types=None, max_week=week_number)\n",
+    "\n",
+    "    # Get unique pairs of 'week_number' and 'assignment_name'\n",
+    "    unique_pairs = sorted_df[[\"week_number\", \"assignment_name\"]].drop_duplicates()\n",
+    "\n",
+    "    # Build an iterator over the unique pairs\n",
+    "    pair_iterator = unique_pairs.itertuples(index=False, name=None)\n",
+    "\n",
+    "    grade_dictionary = {}\n",
+    "\n",
+    "    # Filter rows matching each pair\n",
+    "    for week_number, assignment_name in pair_iterator:\n",
+    "        matching_rows = sorted_df[\n",
+    "            (sorted_df[\"week_number\"] == week_number)\n",
+    "            & (sorted_df[\"assignment_name\"] == assignment_name)\n",
+    "        ]\n",
+    "\n",
+    "        grade_dictionary[f\"Week {week_number} {assignment_name}\"] = {\n",
+    "            \"week_number\": week_number,\n",
+    "            \"assignment_name\": assignment_name,\n",
+    "            \"score\": 0,\n",
+    "        }\n",
+    "\n",
+    "        # # extracts the names of the assignments grades which are associated with a given assignment, this helps if two assignments have the same name.\n",
+    "        # title = matching_rows[\"title\"]\n",
+    "\n",
+    "        # print(title)\n",
+    "\n",
+    "        # gets the most recent assignment due date.\n",
+    "        assignment_due_date = get_max_deadline(\n",
+    "            assignments, assignment_name, week_number\n",
+    "        )\n",
+    "        max_score = matching_rows[\"max_score\"].min()\n",
+    "\n",
+    "        # extracts the names of the assignments grades which are associated with a given assignment, this helps if two assignments have the same name.\n",
+    "        for assignment_db_name in matching_rows[\"title\"]:\n",
+    "            assignment_submission = submissions[\n",
+    "                submissions[\"assignment\"] == assignment_db_name.replace(\" \", \"\").lower()\n",
+    "            ]\n",
+    "\n",
+    "            # Now we need to get the best score for an assignment based on the submission time.\n",
+    "            for index, submission in assignment_submission.iterrows():\n",
+    "                raw_score = submission[\"raw_score\"] / max_score\n",
+    "\n",
+    "                assignment_due_date = datetime.fromisoformat(\n",
+    "                    assignment_due_date\n",
+    "                ).strftime(\"%Y-%m-%d %H:%M:%S\")\n",
+    "                submission_timestamp = datetime.fromisoformat(\n",
+    "                    submission[\"timestamp\"]\n",
+    "                ).strftime(\"%Y-%m-%d %H:%M:%S\")\n",
+    "\n",
+    "                deflation_fraction = calculate_late_submission(\n",
+    "                    assignment_due_date, submission_timestamp\n",
+    "                )\n",
+    "\n",
+    "                score = raw_score * deflation_fraction\n",
+    "\n",
+    "                if (\n",
+    "                    score\n",
+    "                    > grade_dictionary[f\"Week {week_number} {assignment_name}\"][\"score\"]\n",
+    "                ):\n",
+    "                    grade_dictionary[f\"Week {week_number} {assignment_name}\"][\n",
+    "                        \"score\"\n",
+    "                    ] = score\n",
+    "\n",
+    "    return grade_dictionary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import requests\n",
+    "from build.passwords import password, user\n",
+    "from requests.auth import HTTPBasicAuth\n",
+    "\n",
+    "api_base_url = \"https://engr-131-api.eastus.cloudapp.azure.com/\"\n",
+    "\n",
+    "\n",
+    "def get_all_students():\n",
+    "    res = requests.get(\n",
+    "        url=api_base_url.rstrip(\"/\") + \"/get-all-submission-emails\",\n",
+    "        auth=HTTPBasicAuth(user(), password()),\n",
+    "    )\n",
+    "\n",
+    "    return res.json()\n",
+    "\n",
+    "\n",
+    "# def get_student_grades(student_id):\n",
+    "#     params = {\"username\": student_id}\n",
+    "#     res = requests.get(\n",
+    "#         url=api_base_url.rstrip(\"/\") + \"/student-grades-testing\",\n",
+    "#         params=params,\n",
+    "#         auth=HTTPBasicAuth(user(), password()),\n",
+    "#     )\n",
+    "\n",
+    "#     [assignments, sub] = res.json()\n",
+    "\n",
+    "#     return assignments, sub\n",
+    "\n",
+    "\n",
+    "def get_all_student_grades():\n",
+    "    # Initialize an empty DataFrame to hold all student grades\n",
+    "    df = pd.DataFrame()\n",
+    "\n",
+    "    # Get all students (assuming get_all_students() is a defined function)\n",
+    "    students = get_all_students()\n",
+    "\n",
+    "    for student in students:\n",
+    "        print(student)\n",
+    "        # Get assignments and submissions for the student (assumed functions)\n",
+    "        assignments, submissions = get_student_grades(student)\n",
+    "\n",
+    "        # Recalculate grades and get a grades dictionary\n",
+    "        grades_dict = recalculate_best_grades(assignments, submissions)\n",
+    "\n",
+    "        # Calculate averages and build a row for the student\n",
+    "        row = calculate_averages(grades_dict, student)\n",
+    "\n",
+    "        # # Convert the row (a dictionary) into a DataFrame\n",
+    "        # row_df = pd.DataFrame([row])\n",
+    "\n",
+    "        # Append the row to the DataFrame\n",
+    "        df = pd.concat([df, row], ignore_index=True)\n",
+    "\n",
+    "    return df\n",
+    "\n",
+    "\n",
+    "def get_max_deadline(assignments, assignment_name, week_number):\n",
+    "    matching_rows = assignments[\n",
+    "        (assignments[\"week_number\"] == week_number)\n",
+    "        & (assignments[\"assignment_name\"] == assignment_name)\n",
+    "    ]\n",
+    "\n",
+    "    max_timestamp = matching_rows[\"due_date\"].max()\n",
+    "    return max_timestamp\n",
+    "\n",
+    "\n",
+    "def calculate_averages(grades_dict, student_id):\n",
+    "    # Create a DataFrame from the dictionary\n",
+    "    df = pd.DataFrame(\n",
+    "        grades_dict\n",
+    "    ).T  # Transpose the dictionary to make assignments rows\n",
+    "    df[\"score\"] = df[\"score\"].astype(float)  # Ensure the scores are floats\n",
+    "\n",
+    "    # Create a dictionary for the row data\n",
+    "    row_data = {\"student_id\": student_id}\n",
+    "\n",
+    "    # Add scores for each assignment as separate columns\n",
+    "    for assignment, details in grades_dict.items():\n",
+    "        column_name = (\n",
+    "            f\"{details['assignment_name']}_week_{details['week_number']}\".replace(\n",
+    "                \"_\", \" \"\n",
+    "            )\n",
+    "        )\n",
+    "        row_data[column_name] = float(details[\"score\"])\n",
+    "\n",
+    "    # Calculate and add average scores for each assignment category\n",
+    "    averages = df.groupby(\"assignment_name\")[\"score\"].mean()\n",
+    "    for assignment_name, avg_score in averages.items():\n",
+    "        row_data[f\"{assignment_name}_average\".replace(\"_\", \" \")] = avg_score\n",
+    "\n",
+    "    # # Course Percentage Performance\n",
+    "    row_data[\"Current Course Percentage\"] = (\n",
+    "        (row_data[\"quiz average\"] + row_data[\"practice quiz average\"] * 0.1) * 15\n",
+    "        + (row_data[\"homework average\"]) * 15\n",
+    "        + row_data[\"lab average\"] * 15\n",
+    "        + row_data[\"lecture average\"] * 15\n",
+    "        + row_data[\"readings average\"] * 15\n",
+    "        + row_data[\"attendance average\"] * 5\n",
+    "    ) / (15 + 15 + 15 + 15 + 15 + 5)\n",
+    "\n",
+    "    # Create a single-row DataFrame\n",
+    "    single_row_df = pd.DataFrame([row_data])\n",
+    "    return single_row_df\n",
+    "\n",
+    "\n",
+    "def recalculate_best_grades(\n",
+    "    assignments,\n",
+    "    submissions,\n",
+    "    custom_order=[\n",
+    "        \"lecture\",\n",
+    "        \"homework\",\n",
+    "        \"lab\",\n",
+    "        \"attendance\",\n",
+    "        \"readings\",\n",
+    "        \"quiz\",\n",
+    "        \"practice quiz\",\n",
+    "    ],\n",
+    "):\n",
+    "    assignments[\"assignment_name\"] = pd.Categorical(\n",
+    "        assignments[\"assignment_name\"], categories=custom_order, ordered=True\n",
+    "    )\n",
+    "\n",
+    "    # Sort by 'Category' (custom order) and then by 'Value'\n",
+    "    sorted_df = assignments.sort_values(by=[\"assignment_name\", \"week_number\"])\n",
+    "\n",
+    "    week_number = 3\n",
+    "\n",
+    "    exclude_types = None\n",
+    "\n",
+    "    sorted_df = filter_assignments(sorted_df, exclude_types=None, max_week=week_number)\n",
+    "\n",
+    "    # Get unique pairs of 'week_number' and 'assignment_name'\n",
+    "    unique_pairs = sorted_df[[\"week_number\", \"assignment_name\"]].drop_duplicates()\n",
+    "\n",
+    "    # Build an iterator over the unique pairs\n",
+    "    pair_iterator = unique_pairs.itertuples(index=False, name=None)\n",
+    "\n",
+    "    grade_dictionary = {}\n",
+    "\n",
+    "    # Filter rows matching each pair\n",
+    "    for week_number, assignment_name in pair_iterator:\n",
+    "        matching_rows = sorted_df[\n",
+    "            (sorted_df[\"week_number\"] == week_number)\n",
+    "            & (sorted_df[\"assignment_name\"] == assignment_name)\n",
+    "        ]\n",
+    "\n",
+    "        grade_dictionary[f\"Week {week_number} {assignment_name}\"] = {\n",
+    "            \"week_number\": week_number,\n",
+    "            \"assignment_name\": assignment_name,\n",
+    "            \"score\": 0,\n",
+    "        }\n",
+    "\n",
+    "        # # extracts the names of the assignments grades which are associated with a given assignment, this helps if two assignments have the same name.\n",
+    "        # title = matching_rows[\"title\"]\n",
+    "\n",
+    "        # print(title)\n",
+    "\n",
+    "        # gets the most recent assignment due date.\n",
+    "        assignment_due_date = get_max_deadline(\n",
+    "            assignments, assignment_name, week_number\n",
+    "        )\n",
+    "        max_score = matching_rows[\"max_score\"].min()\n",
+    "\n",
+    "        # extracts the names of the assignments grades which are associated with a given assignment, this helps if two assignments have the same name.\n",
+    "        for assignment_db_name in matching_rows[\"title\"]:\n",
+    "            assignment_submission = submissions[\n",
+    "                submissions[\"assignment\"] == assignment_db_name.replace(\" \", \"\").lower()\n",
+    "            ]\n",
+    "\n",
+    "            # Now we need to get the best score for an assignment based on the submission time.\n",
+    "            for index, submission in assignment_submission.iterrows():\n",
+    "                raw_score = submission[\"raw_score\"] / max_score\n",
+    "\n",
+    "                assignment_due_date = datetime.fromisoformat(\n",
+    "                    assignment_due_date\n",
+    "                ).strftime(\"%Y-%m-%d %H:%M:%S\")\n",
+    "                submission_timestamp = datetime.fromisoformat(\n",
+    "                    submission[\"timestamp\"]\n",
+    "                ).strftime(\"%Y-%m-%d %H:%M:%S\")\n",
+    "\n",
+    "                deflation_fraction = calculate_late_submission(\n",
+    "                    assignment_due_date, submission_timestamp\n",
+    "                )\n",
+    "\n",
+    "                score = raw_score * deflation_fraction\n",
+    "\n",
+    "                if (\n",
+    "                    score\n",
+    "                    > grade_dictionary[f\"Week {week_number} {assignment_name}\"][\"score\"]\n",
+    "                ):\n",
+    "                    grade_dictionary[f\"Week {week_number} {assignment_name}\"][\n",
+    "                        \"score\"\n",
+    "                    ] = score\n",
+    "\n",
+    "    return grade_dictionary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "get_student(\"jab864\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = get_all_student_grades()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df.to_csv(\"grades\")"
+   ]
+  },
+  {
+   "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/utils.py

@@ -1,6 +1,6 @@
 import os
 import random
-from typing import Optional, Tuple
+from typing import Any, Optional
 
 import panel as pn
 
@@ -9,22 +9,38 @@ student_user = os.getenv("user_name_student")
 student_pw = os.getenv("keys_student")
 
 
-def list_of_lists(options: list) -> bool:
+def list_of_lists(options: list[Any]) -> bool:
     return all(isinstance(elem, list) for elem in options)
 
 
-def shuffle_options(options: list[Optional[str]], seed: int) -> list[Optional[str]]:
+def shuffle_options(options: list[Any], seed: int) -> None:
+    """
+    Shuffle options in list[Optional[str]] or list[list[Optional[str]]].
+    Shuffling is done in place.
+    We annotate options as list[Any] just to keep Mypy happy.
+
+    Args:
+        options (list[Any]): List of options to shuffle
+        seed (int): Seed for RNG
+
+    Returns:
+        None
+    """
     random.seed(seed)
-    random.shuffle(options)
 
-    return options
+    if list_of_lists(options):
+        for i in range(len(options)):
+            inner_list: list[Optional[str]] = options[i]
+            random.shuffle(inner_list)
+    else:
+        random.shuffle(options)
 
 
 def shuffle_questions(
     desc_widgets: list[pn.pane.HTML],
     dropdowns: list[pn.widgets.Select] | list[pn.Column],
     seed: int,
-) -> list[Tuple[pn.pane.HTML, pn.widgets.Select | pn.Column]]:
+) -> list[tuple[pn.pane.HTML, pn.widgets.Select | pn.Column]]:
     random.seed(seed)
 
     # Combine widgets into pairs

pykubegrader/widgets/multiple_choice.py

@@ -15,12 +15,12 @@ def MCQ(
     descriptions: list[str],
     options: list[str] | list[list[str]],
     initial_vals: list[str],
-) -> Tuple[list[pn.pane.HTML], list[pn.widgets.RadioButtonGroup]]:
+) -> Tuple[list[pn.Column], list[pn.widgets.RadioBoxGroup]]:
     # Process descriptions through `process_questions_and_codes`
     processed_titles, code_blocks = process_questions_and_codes(descriptions)
 
     # Create rows for each description and its code block
-    desc_widgets = []
+    desc_widgets: list[pn.Column] = []
     for title, code_block in zip(processed_titles, code_blocks):
         # Create an HTML pane for the title
         title_pane = pn.pane.HTML(
@@ -34,7 +34,7 @@ def MCQ(
         else:
             desc_widgets.append(pn.Column(title_pane, sizing_mode="stretch_width"))
 
-    radio_buttons = [
+    radio_buttons: list[pn.widgets.RadioBoxGroup] = [
         pn.widgets.RadioBoxGroup(
             options=option,
             value=value,

pykubegrader/widgets/question_processor.py

@@ -1,13 +1,17 @@
+from typing import Optional
+
 import panel as pn
 
 
-def process_questions_and_codes(titles):
+def process_questions_and_codes(
+    titles: str | list[str],
+) -> tuple[list[str], list[Optional[pn.pane.Markdown]]]:
     # Ensure titles is a list
     if isinstance(titles, str):
         titles = [titles]
 
-    processed_titles = []
-    code_blocks = []
+    processed_titles: list[str] = []
+    code_blocks: list[Optional[pn.pane.Markdown]] = []
 
     for title in titles:
         # Split the title at the "```python" delimiter

pykubegrader/widgets/select_many.py

@@ -2,6 +2,7 @@ import panel as pn
 
 from ..widgets.style import drexel_colors, raw_css
 from ..widgets_base.multi_select import MultiSelectQuestion
+from .question_processor import process_questions_and_codes
 
 # Pass the custom CSS to Panel
 pn.extension(design="material", global_css=[drexel_colors], raw_css=[raw_css])
@@ -24,15 +25,26 @@ def MultiSelect(
     separator = pn.pane.HTML("<hr style='border:1px solid lightgray; width:100%;'>")
 
     i = 0
+    desc_width = "500px"
 
     for question, option_set in zip(descriptions, options):
-        desc_width = "500px"
+        # Process descriptions through `process_questions_and_codes`
+        processed_titles, code_blocks = process_questions_and_codes(question)
 
-        # Create description widget with separator
-        desc_widget = pn.pane.HTML(
+        # Create an HTML pane for the title
+        title_pane = pn.pane.HTML(
             f"<hr style='border:1px solid lightgray; width:100%;'>"
-            f"<div style='text-align: left; width: {desc_width};'><b>{question}</b></div>"
+            f"<div style='text-align: left; width: {desc_width};'><b>{processed_titles[0]}</b></div>"
         )
+        # Add the title and code block in a row
+        if code_blocks[0]:
+            desc_widget = pn.Column(
+                title_pane, code_blocks[0], sizing_mode="stretch_width"
+            )
+        else:
+            desc_widget = title_pane
+
+        # # Create description widget with separator
 
         # Create checkboxes for current question
         checkbox_set = [

pykubegrader/widgets_base/multi_select.py

@@ -1,10 +1,10 @@
 import time
-from typing import Callable, Tuple
+from typing import Callable, Optional, Tuple
 
 import panel as pn
 
 from ..telemetry import ensure_responses, score_question, update_responses
-from ..utils import shuffle_questions
+from ..utils import shuffle_options, shuffle_questions
 from ..widgets.style import drexel_colors, raw_css
 
 # Pass the custom CSS to Panel
@@ -19,12 +19,12 @@ class MultiSelectQuestion:
         self,
         title: str,
         style: Callable[
-            [list[str], list[list[str]], list[bool]],
+            [list[str], list[list[Optional[str]]], list[bool]],
             Tuple[list[pn.pane.HTML], list[pn.Column]],
         ],
         question_number: int,
         keys: list[str],
-        options: list[list[str]],
+        options: list[list[Optional[str]]],
         descriptions: list[str],
         points: int,
     ):
@@ -56,8 +56,8 @@ class MultiSelectQuestion:
 
         self.initial_vals = [getattr(self, key) for key in self.keys]
 
-        # # add shuffle options to multi_select.py
-        # options = shuffle_options(options, seed)
+        # add shuffle options to multi_select.py
+        shuffle_options(options, seed)
 
         description_widgets, self.widgets = style(
             descriptions, options, self.initial_vals

pykubegrader/widgets_base/reading.py

@@ -53,9 +53,11 @@ class ReadingPython:
         # Comment dropdowns
         #
 
+        shuffle_options(options["comments_options"], seed)
+
         self.dropdowns_for_comments: dict[str, pn.widgets.Select] = {
             line: pn.widgets.Select(
-                options=shuffle_options(options["comments_options"], seed),
+                options=options["comments_options"],
                 name=f"Line {line}:",
                 value=getattr(self, f"q{question_number}_{i_comments + 1}"),
                 width=600,

pykubegrader/widgets_base/select.py

@@ -1,10 +1,10 @@
 import time
-from typing import Callable, Tuple
+from typing import Callable, Optional, Tuple
 
 import panel as pn
 
 from ..telemetry import ensure_responses, score_question, update_responses
-from ..utils import shuffle_questions
+from ..utils import shuffle_options, shuffle_questions
 from ..widgets.style import drexel_colors
 
 # Pass custom CSS to Panel
@@ -21,7 +21,7 @@ class SelectQuestion:
         ],
         question_number: int,
         keys: list[str],
-        options: list,
+        options: list[Optional[str]] | list[list[Optional[str]]],
         descriptions: list[str],
         points: int,
         shuffle_answers: bool = True,
@@ -46,8 +46,8 @@ class SelectQuestion:
 
         self.initial_vals: list = [getattr(self, key) for key in self.keys]
 
-        # if shuffle_answers:
-        #     options = shuffle_options(options, seed)
+        if shuffle_answers:
+            shuffle_options(options, seed)
 
         desc_widgets, self.widgets = style(descriptions, options, self.initial_vals)