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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyKubeGrader
-Version: 0.3.2
+Version: 0.3.4
 Summary: Add a short description here!
 Home-page: https://github.com/pyscaffold/pyscaffold/
 Author: jagar2
@@ -12,12 +12,10 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 Description-Content-Type: text/x-rst; charset=UTF-8
 License-File: LICENSE.txt
-Requires-Dist: httpx
 Requires-Dist: importlib-metadata; python_version < "3.8"
 Requires-Dist: ipython
 Requires-Dist: mypy
 Requires-Dist: nbformat
-Requires-Dist: nest_asyncio
 Requires-Dist: numpy
 Requires-Dist: pandas-stubs
 Requires-Dist: panel
@@ -28,7 +26,6 @@ Requires-Dist: ruff
 Requires-Dist: setuptools
 Requires-Dist: sphinx
 Requires-Dist: types-python-dateutil
-Requires-Dist: types-pyyaml
 Requires-Dist: types-requests
 Requires-Dist: types-setuptools
 Provides-Extra: testing

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

@@ -1,21 +1,22 @@
 pykubegrader/__init__.py,sha256=AoAkdfIjDDZGWLlsIRENNq06L9h46kDGBIE8vRmsCfg,311
-pykubegrader/grading_tester.ipynb,sha256=2c1JgnV-zgP405Q3rlEkOlMJPm_9Qga0Z0MVWpFk5No,18531
+pykubegrader/grading_tester.ipynb,sha256=wwT9jyhpR6GGM8r4todaGfrsUxS6JxM0qIqMcDYKM7w,18839
 pykubegrader/initialize.py,sha256=Bwu1q18l18FB9lGppvt-L41D5gzr3S8t6zC0_UbrASw,3994
-pykubegrader/telemetry.py,sha256=50Qp5WXeF7PD5FxDLFXWFAnQ2Yobj-wL3Dxh0Hz_vh0,6552
+pykubegrader/telemetry.py,sha256=ooLK-dY_hJQ7t4r83hWyO8wx6F_7TfWJS7tCp_nH7r8,13049
 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=Asc-VdhXgxQfOfFIWJShhXrF2EITJOIZQ5Dz_2y-P2I,85358
 pykubegrader/build/clean_folder.py,sha256=8N0KyL4eXRs0DCw-V_2jR9igtFs_mOFMQufdL6tD-38,1323
+pykubegrader/build/collate.py,sha256=cVvF7tf2U3iiH4R_dbghTcieedIx5w3Fyw9L_llInM8,6754
 pykubegrader/build/markdown_questions.py,sha256=cSh8mkHK3hh-etJdgrZu9UQi1WPrKQtofkzLCUp1Z-w,4676
-pykubegrader/grade_reports/grade_reports.py,sha256=TmT_F2enezU_BIFPBQ0oZ4l5nBgPw4PSBo-8wJ_gt4w,5915
+pykubegrader/grade_reports/grade_reports.py,sha256=n8H_n9jdZRSPn2zlIf-GQt_Y8w91p6M8ZbdVH76Sg5k,2303
 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
 pykubegrader/log_parser/parse.ipynb,sha256=5e-9dzUbJk2M8kPP55lVeksm86lSY5ocKfWOP2RSWH0,11921
 pykubegrader/log_parser/parse.py,sha256=dXzTEOTI6VTRNoHFDAjg6hZUhvB3kHtMb10_KW3NPrw,7641
-pykubegrader/submit/submit_assignment.py,sha256=UgJXKWw5b8-bRSFnba4iHAyXnujULHcWIask7hKx9ik,3421
+pykubegrader/submit/submit_assignment.py,sha256=cqVu7US8GVaCdJdaU2yjawlVBtAKP5XJc4oAvX5FeRU,2575
 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
@@ -31,9 +32,9 @@ pykubegrader/widgets_base/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-
 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-0.3.4.dist-info/LICENSE.txt,sha256=YTp-Ewc8Kems8PJEE27KnBPFnZSxoWvSg7nnknzPyYw,1546
+PyKubeGrader-0.3.4.dist-info/METADATA,sha256=6aq3PWnDPR8lNxPMmWvDkbd2GvZNfLkpYNcpOLSbHqc,2729
+PyKubeGrader-0.3.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+PyKubeGrader-0.3.4.dist-info/entry_points.txt,sha256=RR57KvzDRJrP4omy5heS5cZ3E7g56YxcxJhDnp57ZU0,253
+PyKubeGrader-0.3.4.dist-info/top_level.txt,sha256=e550Klfze6higFxER1V62fnGOcIgiKRbsrl9CC4UdtQ,13
+PyKubeGrader-0.3.4.dist-info/RECORD,,

{PyKubeGrader-0.3.2.dist-info → PyKubeGrader-0.3.4.dist-info}/entry_points.txt

@@ -1,4 +1,5 @@
 [console_scripts]
+collate-questions = pykubegrader.build.collate:main
 markdown-question = pykubegrader.build.markdown_questions:main
 otter-folder-builder = pykubegrader.build.build_folder:main
 otter-folder-cleaner = pykubegrader.build.clean_folder:main

pykubegrader/build/collate.py

@@ -0,0 +1,190 @@
+import argparse
+import json
+import os
+
+from nbformat.v4 import new_markdown_cell, new_notebook
+
+
+class QuestionCollator:
+    def __init__(self, root_folder: str, output_path: str):
+        """
+        Initializes the QuestionCollator with the root folder and output path.
+
+        Args:
+            root_folder (str): Path to the root folder containing the solution files.
+            output_path (str): Path to save the collated notebook.
+        """
+        self.root_folder = root_folder
+        self.output_path = output_path
+
+    def find_solution_folders(self):
+        """
+        Finds all immediate subdirectories inside '_solution*' folders that contain notebooks.
+
+        Returns:
+            list: List of folder paths containing notebooks.
+        """
+        solution_folders = []
+
+        # Look for _solution* folders inside the root_folder
+        for dir_name in os.listdir(self.root_folder):
+            solution_folder_path = os.path.join(self.root_folder, dir_name)
+
+            if os.path.isdir(solution_folder_path) and dir_name.startswith("_solution"):
+                print(f"Found solution folder: {solution_folder_path}")  # Debug output
+
+                # Now, look for immediate subdirectories inside this _solution* folder
+                for sub_dir in os.listdir(solution_folder_path):
+                    sub_dir_path = os.path.join(solution_folder_path, sub_dir)
+
+                    if os.path.isdir(sub_dir_path):
+                        # Check if this subdirectory contains at least one .ipynb file
+                        if any(f.endswith(".ipynb") for f in os.listdir(sub_dir_path)):
+                            solution_folders.append(sub_dir_path)
+
+        print(f"Final list of solution subfolders: {solution_folders}")  # Debug output
+        return solution_folders
+
+    def extract_questions(self, folder_path):
+        """
+        Extracts questions from all notebooks in the solution folder.
+
+        Args:
+            folder_path (str): Path to the solution folder.
+
+        Returns:
+            dict: Dictionary of categorized questions.
+        """
+        questions = {
+            "multiple_choice": [],
+            "select_many": [],
+            "true_false": [],
+            "other": [],
+        }
+
+        for file in os.listdir(folder_path):
+            if file.endswith(".ipynb"):
+                file_path = os.path.join(folder_path, file)
+                print(
+                    f"Processing notebook: {file_path}"
+                )  # Print the full path of the notebook
+                with open(file_path, "r") as f:
+                    content = json.load(f)
+
+                # Track whether we are inside a question block
+                in_question_block = False
+                current_question_content = []
+
+                for cell in content["cells"]:
+                    if "# BEGIN MULTIPLE CHOICE" in cell["source"]:
+                        # Start of a question block
+                        in_question_block = True
+                        current_question_content = []
+                    elif "# END MULTIPLE CHOICE" in cell["source"]:
+                        # End of a question block
+                        in_question_block = False
+                        if current_question_content:
+                            questions["multiple_choice"].append(
+                                {"source": "\n".join(current_question_content)}
+                            )
+                        current_question_content = []
+                    elif in_question_block and cell["cell_type"] == "markdown":
+                        # Capture markdown cells within the question block
+                        current_question_content.append(cell["source"])
+
+        return questions
+
+    def create_collated_notebook(self, questions):
+        """
+        Creates a new notebook with questions organized by type.
+
+        Args:
+            questions (dict): Dictionary of categorized questions.
+
+        Returns:
+            Notebook: The collated notebook.
+        """
+        nb = new_notebook()
+
+        # Add Multiple Choice Questions
+        nb.cells.append(new_markdown_cell("# Multiple Choice Questions"))
+        for q in questions["multiple_choice"]:
+            nb.cells.append(new_markdown_cell(q["source"]))
+
+        # Add Select Many Questions
+        nb.cells.append(new_markdown_cell("# Select Many Questions"))
+        for q in questions["select_many"]:
+            nb.cells.append(new_markdown_cell(q["source"]))
+
+        # Add True/False Questions
+        nb.cells.append(new_markdown_cell("# True/False Questions"))
+        for q in questions["true_false"]:
+            nb.cells.append(new_markdown_cell(q["source"]))
+
+        # Add Other Questions
+        nb.cells.append(new_markdown_cell("# Other Questions"))
+        for q in questions["other"]:
+            nb.cells.append(new_markdown_cell(q["source"]))
+
+        return nb
+
+    def save_notebook(self, nb):
+        """
+        Saves the collated notebook to the specified output path.
+
+        Args:
+            nb (Notebook): The notebook to save.
+        """
+        import nbformat
+
+        with open(self.output_path, "w") as f:
+            nbformat.write(nb, f)
+
+    def collate_questions(self):
+        """
+        Collates questions from all solution folders and saves them to a new notebook.
+        """
+        solution_folders = self.find_solution_folders()
+        all_questions = {
+            "multiple_choice": [],
+            "select_many": [],
+            "true_false": [],
+            "other": [],
+        }
+
+        for folder in solution_folders:
+            questions = self.extract_questions(folder)
+            all_questions["multiple_choice"].extend(questions["multiple_choice"])
+            all_questions["select_many"].extend(questions["select_many"])
+            all_questions["true_false"].extend(questions["true_false"])
+            all_questions["other"].extend(questions["other"])
+
+        collated_nb = self.create_collated_notebook(all_questions)
+        self.save_notebook(collated_nb)
+        print(f"Collated notebook saved to {self.output_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Collate questions from solution folders into a single notebook."
+    )
+    parser.add_argument(
+        "root_folder",
+        type=str,
+        help="Path to the root folder containing solution folders",
+    )
+    parser.add_argument(
+        "output_path", type=str, help="Path to save the collated notebook"
+    )
+
+    args = parser.parse_args()
+    collator = QuestionCollator(
+        root_folder=args.root_folder, output_path=args.output_path
+    )
+    collator.collate_questions()
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main())

pykubegrader/grade_reports/grade_reports.py

@@ -1,9 +1,9 @@
+import os
+
 import pandas as pd
 import requests
 from requests.auth import HTTPBasicAuth
 
-from ..build.passwords import password, user
-
 
 def format_assignment_table(assignments):
     # Create DataFrame
@@ -32,16 +32,21 @@ def format_assignment_table(assignments):
     return df
 
 
-def get_student_grades(
-    student_username, api_base_url="https://engr-131-api.eastus.cloudapp.azure.com/"
-):
+def get_student_grades(student_username):
+    # Get env variables here, in the function, rather than globally
+    api_base_url = os.getenv("DB_URL")
+    student_user = os.getenv("user_name_student")
+    student_pw = os.getenv("keys_student")
+
+    if not api_base_url or not student_user or not student_pw:
+        raise ValueError("Environment variables not set")
+
     params = {"username": student_username}
     res = requests.get(
         url=api_base_url.rstrip("/") + "/student-grades-testing",
         params=params,
-        auth=HTTPBasicAuth(user(), password()),
+        auth=HTTPBasicAuth(student_user, student_pw),
     )
-
     [assignments, sub] = res.json()
 
     assignments_df = format_assignment_table(assignments)
@@ -69,103 +74,3 @@ def filter_assignments(df, max_week=None, exclude_types=None):
         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

@@ -1,5 +1,16 @@
 {
  "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from grade_reports.grade_reports import filter_assignments, get_student_grades\n",
+    "\n",
+    "get_student_grades"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -19,13 +30,13 @@
     "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",
+    "# 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",
+    "#     return res.json()\n",
     "\n",
     "\n",
     "# def get_student_grades(student_id):\n",
@@ -41,47 +52,47 @@
     "#     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",
+    "# 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",
+    "#     # 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",
+    "#     # 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",
+    "#     # Convert the row (a dictionary) into a DataFrame\n",
+    "#     # row_df = pd.DataFrame([row])\n",
     "\n",
-    "    return row\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",
+    "# 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",
+    "#     # 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",
+    "#     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",
+    "#         # Append the row to the DataFrame\n",
+    "#         df = pd.concat([df, row_df], ignore_index=True)\n",
     "\n",
-    "    return df\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",
+    "# 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",
+    "#     max_timestamp = matching_rows[\"due_date\"].max()\n",
+    "#     return max_timestamp\n",
     "\n",
     "\n",
     "def calculate_averages(grades_dict, student_id):\n",
@@ -455,7 +466,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "engr131_dev",
+   "display_name": "engr131w25",
    "language": "python",
    "name": "python3"
   },
@@ -469,7 +480,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.7"
+   "version": "3.13.1"
   }
  },
  "nbformat": 4,

pykubegrader/submit/submit_assignment.py

@@ -1,12 +1,7 @@
-import asyncio
-import base64
 import os
 
-import httpx
-import nest_asyncio  # type: ignore
-
-# Apply nest_asyncio for environments like Jupyter
-nest_asyncio.apply()
+import requests
+from requests.auth import HTTPBasicAuth
 
 
 def get_credentials():
@@ -22,55 +17,52 @@ def get_credentials():
     return {"username": username, "password": password}
 
 
-async def call_score_assignment(
+def call_score_assignment(
     assignment_title: str, notebook_title: str, file_path: str = ".output_reduced.log"
-) -> dict:
+) -> dict[str, str]:
     """
-    Submit an assignment to the scoring endpoint.
+    Submit an assignment to the scoring endpoint
 
     Args:
-        assignment_title (str): Title of the assignment.
-        file_path (str): Path to the log file to upload.
+        assignment_title (str): Title of the assignment
+        notebook_title (str): Title of the notebook
+        file_path (str): Path to the log file to upload
 
     Returns:
-        dict: JSON response from the server.
+        dict: JSON response from the server
     """
-    # Fetch the endpoint URL from environment variables
+
     base_url = os.getenv("DB_URL")
     if not base_url:
-        raise ValueError("Environment variable 'DB_URL' is not set.")
-    url = f"{base_url}score-assignment?assignment_title={assignment_title}&notebook_title={notebook_title}"
-
-    # Get credentials
-    credentials = get_credentials()
-    username = credentials["username"]
-    password = credentials["password"]
-
-    # Encode credentials for Basic Authentication
-    auth_header = (
-        f"Basic {base64.b64encode(f'{username}:{password}'.encode()).decode()}"
-    )
-
-    # Send the POST request
-    async with httpx.AsyncClient() as client:
-        try:
-            with open(file_path, "rb") as file:
-                response = await client.post(
-                    url,
-                    headers={"Authorization": auth_header},  # Add Authorization header
-                    files={"log_file": file},  # Upload log file
-                )
-
-                # Handle the response
-                response.raise_for_status()  # Raise an exception for HTTP errors
-                response_data = response.json()
-                return response_data
-        except FileNotFoundError:
-            raise FileNotFoundError(f"The file {file_path} does not exist.")
-        except httpx.RequestError as e:
-            raise RuntimeError(f"An error occurred while requesting {url}: {e}")
-        except Exception as e:
-            raise RuntimeError(f"An unexpected error occurred: {e}")
+        raise ValueError("Environment variable 'DB_URL' not set")
+
+    url = base_url.rstrip("/") + "/score-assignment"
+
+    params = {
+        "assignment_title": assignment_title,
+        "notebook_title": notebook_title,
+    }
+
+    username, password = get_credentials().values()
+
+    try:
+        with open(file_path, "rb") as file:
+            res = requests.post(
+                url=url,
+                params=params,
+                auth=HTTPBasicAuth(username, password),
+                files={"log_file": file},
+            )
+            res.raise_for_status()
+
+            return res.json()
+
+    except FileNotFoundError:
+        raise FileNotFoundError(f"File {file_path} does not exist")
+    except requests.RequestException as err:
+        raise RuntimeError(f"An error occurred while requesting {url}: {err}")
+    except Exception as err:
+        raise RuntimeError(f"An unexpected error occurred: {err}")
 
 
 def submit_assignment(
@@ -85,17 +77,9 @@ def submit_assignment(
         assignment_title (str): Title of the assignment.
         file_path (str): Path to the log file to upload.
     """
-    # Get the current event loop or create one
-    try:
-        loop = asyncio.get_event_loop()
-    except RuntimeError:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-
-    # Run the async function in the event loop
-    response = loop.run_until_complete(
-        call_score_assignment(assignment_title, notebook_title, file_path)
-    )
+
+    response = call_score_assignment(assignment_title, notebook_title, file_path)
+
     print("Server Response:", response.get("message", "No message in response"))
 
 

pykubegrader/telemetry.py

@@ -1,5 +1,6 @@
 import base64
 import datetime
+import gzip
 import json
 import logging
 import os
@@ -9,11 +10,13 @@ from typing import Any, Optional
 import nacl.public
 import pandas as pd
 import requests
+from dateutil import parser
 from IPython.core.interactiveshell import ExecutionInfo
 from requests import Response
 from requests.auth import HTTPBasicAuth
 from requests.exceptions import RequestException
 
+from .graders.late_assignments import calculate_late_submission
 from .utils import api_base_url, student_pw, student_user
 
 #
@@ -205,10 +208,14 @@ def verify_server(jhub_user: Optional[str] = None) -> str:
     return message
 
 
+# TODO: reformat into a nice table
 def get_my_grades() -> pd.DataFrame:
+    # get all submissions,
+    # recalculate late penalty in new columns,
+    # take max,
+    # divide by total points
     if not student_user or not student_pw or not api_base_url:
         raise ValueError("Necessary environment variables not set")
-
     from_hostname = socket.gethostname().removeprefix("jupyter-")
     from_env = os.getenv("JUPYTERHUB_USER")
     if from_hostname != from_env:
@@ -233,3 +240,191 @@ def get_my_grades() -> pd.DataFrame:
     sorted_vertical_df = vertical_df.sort_index()
 
     return sorted_vertical_df
+
+
+#
+# Code execution log testing
+#
+
+
+def upload_execution_log() -> None:
+    if not student_user or not student_pw or not api_base_url:
+        raise ValueError("Necessary environment variables not set")
+
+    responses = ensure_responses()
+    student_email: str = responses["jhub_user"]
+    assignment: str = responses["assignment"]
+    if not student_email or not assignment:
+        raise ValueError("Missing student email and/or assignment name")
+
+    print(f"Student: {student_email}")
+    print(f"Assignment: {assignment}")
+    print("Uploading code execution log...")
+
+    try:
+        with open(".output_code.log", "rb") as f:
+            log_bytes = f.read()
+    except FileNotFoundError:
+        raise FileNotFoundError("Code execution log not found")
+
+    print(f"Uncompressed log size: {len(log_bytes)} bytes")
+
+    compressed = gzip.compress(log_bytes)
+
+    print(f"Compressed log size: {len(compressed)} bytes")
+
+    encoded = base64.b64encode(compressed).decode("utf-8")
+
+    payload = {
+        "student_email": student_email,
+        "assignment": assignment,
+        "encrypted_content": encoded,
+    }
+
+    res = requests.post(
+        url=api_base_url.rstrip("/") + "/execution-logs",
+        json=payload,
+        auth=HTTPBasicAuth(student_user, student_pw),
+    )
+    res.raise_for_status()
+
+    print("Execution log uploaded successfully")
+
+
+# #
+# # Qiao's work on grades
+#
+
+
+def get_assignments_submissions():
+    if not student_user or not student_pw or not api_base_url:
+        raise ValueError("Necessary environment variables not set")
+    from_hostname = socket.gethostname().removeprefix("jupyter-")
+    from_env = os.getenv("JUPYTERHUB_USER")
+    if from_hostname != from_env:
+        raise ValueError("Problem with JupyterHub username")
+
+    params = {"username": from_env}
+    # get submission information
+    res = requests.get(
+        url=api_base_url.rstrip("/") + "/my-grades-testing",
+        params=params,
+        auth=HTTPBasicAuth(student_user, student_pw),
+    )
+    return res.json()
+
+
+def setup_grades_df(assignments):
+    assignment_types = list(set([a["assignment_type"] for a in assignments]))
+
+    inds = [f"week{i + 1}" for i in range(11)] + ["Running Avg"]
+    restruct_grades = {k: [0 for i in range(len(inds))] for k in assignment_types}
+    restruct_grades["inds"] = inds
+    new_weekly_grades = pd.DataFrame(restruct_grades)
+    new_weekly_grades.set_index("inds", inplace=True)
+    return new_weekly_grades
+
+
+def fill_grades_df(new_weekly_grades, assignments, student_subs):
+    for assignment in assignments:
+        # get the assignment from all submissions
+        subs = [
+            sub
+            for sub in student_subs
+            if sub["assignment_type"] == assignment["assignment_type"]
+            and sub["week_number"] == assignment["week_number"]
+        ]
+        if len(subs) == 0:
+            # print(assignment['title'], 0, assignment['max_score'])
+            continue
+        elif len(subs) == 1:
+            grade = subs[0]["raw_score"] / assignment["max_score"]
+            # print(assignment['title'], sub['raw_score'], assignment['max_score'])
+        else:
+            # get due date from assignment
+            due_date = parser.parse(assignment["due_date"])
+            grades = []
+            for sub in subs:
+                entry_date = parser.parse(sub["timestamp"])
+                if entry_date <= due_date:
+                    grades.append(sub["raw_score"])
+                else:
+                    grades.append(
+                        calculate_late_submission(
+                            due_date.strftime("%Y-%m-%d %H:%M:%S"),
+                            entry_date.strftime("%Y-%m-%d %H:%M:%S"),
+                        )
+                    )
+            # print(assignment['title'], grades, assignment['max_score'])
+            grade = max(grades) / assignment["max_score"]
+
+        # fill out new df with max
+        new_weekly_grades.loc[
+            f"week{assignment['week_number']}", assignment["assignment_type"]
+        ] = grade
+
+        # Merge different names
+        new_weekly_grades["attend"] = new_weekly_grades[["attend", "attendance"]].max(
+            axis=1
+        )
+        new_weekly_grades["practicequiz"] = new_weekly_grades[
+            ["practicequiz", "practice-quiz"]
+        ].max(axis=1)
+        new_weekly_grades.drop(
+            ["attendance", "practice-quiz", "test"],
+            axis=1,
+            inplace=True,
+            errors="ignore",
+        )
+
+        return new_weekly_grades
+
+
+def get_current_week(start_date):
+    # Calculate the current week (1-based indexing)
+    start_date = datetime.datetime.strptime(start_date, "%Y-%m-%d")
+    today = datetime.datetime.now()
+    days_since_start = (today - start_date).days
+    return days_since_start // 7 + 1
+
+
+# This function currently has many undefined variables and other problems!
+def get_my_grades_testing(start_date="2025-01-06"):
+    """takes in json.
+    reshapes columns into reading, lecture, practicequiz, quiz, lab, attendance, homework, exam, final.
+    fills in 0 for missing assignments
+    calculate running average of each category"""
+
+    # 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,
+    }
+
+    assignments, student_subs = get_assignments_submissions()
+
+    new_grades_df = setup_grades_df(assignments)
+
+    new_weekly_grades = fill_grades_df(new_grades_df, assignments, student_subs)
+
+    current_week = get_current_week(start_date)
+
+    # 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_weekly_grades  # get rid of test and running avg columns