PyKubeGrader 0.1.12__tar.gz → 0.1.14__tar.gz

{pykubegrader-0.1.12/src/PyKubeGrader.egg-info → pykubegrader-0.1.14}/PKG-INFO

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

{pykubegrader-0.1.12 → pykubegrader-0.1.14/src/PyKubeGrader.egg-info}/PKG-INFO

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

{pykubegrader-0.1.12 → pykubegrader-0.1.14}/src/PyKubeGrader.egg-info/SOURCES.txt

@@ -39,6 +39,8 @@ src/pykubegrader/utils.py
 src/pykubegrader/validate.py
 src/pykubegrader/build/api_notebook_builder.py
 src/pykubegrader/build/build_folder.py
+src/pykubegrader/log_parser/parse.ipynb
+src/pykubegrader/log_parser/parse.py
 src/pykubegrader/widgets/__init__.py
 src/pykubegrader/widgets/multiple_choice.py
 src/pykubegrader/widgets/reading_question.py

{pykubegrader-0.1.12 → pykubegrader-0.1.14}/src/pykubegrader/build/api_notebook_builder.py

@@ -1,23 +1,25 @@
+import ast
+import json
+import re
+import shutil
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional
-import json
+
 import nbformat
-import json
-import re
-import shutil
-import ast
 
 
 @dataclass
 class FastAPINotebookBuilder:
     notebook_path: str
     temp_notebook: Optional[str] = None
+    assignment_tag: Optional[str] = ""
 
     def __post_init__(self):
         self.root_path, self.filename = FastAPINotebookBuilder.get_filename_and_root(
             self.notebook_path
         )
+        self.total_points = 0
         self.run()
 
     def run(self):
@@ -34,6 +36,8 @@ class FastAPINotebookBuilder:
         self.add_api_code()
 
     def add_api_code(self):
+        self.compute_max_points_free_response()
+
         for i, (cell_index, cell_dict) in enumerate(self.assertion_tests_dict.items()):
             print(
                 f"Processing cell {cell_index + 1}, {i} of {len(self.assertion_tests_dict)}"
@@ -75,19 +79,32 @@ class FastAPINotebookBuilder:
                 ["earned_points = float(os.environ.get('EARNED_POINTS', 0))\n"]
             )
             updated_cell_source.extend(["earned_points += score\n"])
+
+            short_filename = self.filename.split(".")[0].replace("_temp", "")
             updated_cell_source.extend(
-                [f'log_variable(f"{{score}}, {{max_score}}", question_id)\n']
+                [
+                    f'log_variable("{short_filename}",f"{{score}}, {{max_score}}", question_id)\n'
+                ]
             )
             updated_cell_source.extend(
                 ["os.environ['EARNED_POINTS'] = str(earned_points)\n"]
             )
 
-            # cell_source = FastAPINotebookBuilder.insert_list_at_index(
-            #     cell_source, updated_cell_source, last_import_line_ind + 1
-            # )
-
             self.replace_cell_source(cell_index, updated_cell_source)
 
+    def compute_max_points_free_response(self):
+        for i, (cell_index, cell_dict) in enumerate(self.assertion_tests_dict.items()):
+            # gets the question name from the first cell to not double count
+            if cell_dict["is_first"]:
+                # get the max points for the question
+                max_question_points = sum(
+                    cell["points"]
+                    for cell in self.assertion_tests_dict.values()
+                    if cell["question"] == cell_dict["question"]
+                )
+
+                self.total_points += max_question_points
+
     def construct_first_cell_question_header(self, cell_dict):
         max_question_points = sum(
             cell["points"]
@@ -95,9 +112,19 @@ class FastAPINotebookBuilder:
             if cell["question"] == cell_dict["question"]
         )
 
-        first_cell_header = ["max_question_points = " + str(max_question_points) + "\n"]
+        first_cell_header = [f"max_question_points = str({max_question_points})\n"]
         first_cell_header.append("earned_points = 0 \n")
         first_cell_header.append("os.environ['EARNED_POINTS'] = str(earned_points)\n")
+        first_cell_header.append(
+            f"os.environ['TOTAL_POINTS_FREE_RESPONSE'] = str({self.total_points})\n"
+        )
+
+        short_filename = self.filename.split(".")[0].replace("_temp", "")
+        first_cell_header.extend(
+            [
+                f'log_variable("total-points",f"{self.assignment_tag}, {short_filename}", {self.total_points})\n'
+            ]
+        )
 
         return first_cell_header
 
@@ -202,7 +229,7 @@ class FastAPINotebookBuilder:
             "    ensure_responses,\n",
             "    log_variable,\n",
             "    score_question,\n",
-            "    submit_question_new,\n",
+            "    submit_question,\n",
             "    telemetry,\n",
             "    update_responses,\n",
             ")\n",

{pykubegrader-0.1.12 → pykubegrader-0.1.14}/src/pykubegrader/build/build_folder.py

@@ -8,7 +8,9 @@ import shutil
 import subprocess
 import sys
 from dataclasses import dataclass, field
+
 import nbformat
+
 from .api_notebook_builder import FastAPINotebookBuilder
 
 
@@ -19,12 +21,14 @@ class NotebookProcessor:
 
     Attributes:
         root_folder (str): The root directory containing notebooks to process.
+        assignment_tag (str): Tag for the assignment being processed.
         solutions_folder (str): The directory where processed notebooks and solutions are stored.
         verbose (bool): Flag for verbose output to the console.
         log (bool): Flag to enable or disable logging.
     """
 
     root_folder: str
+    assignment_tag: str = field(default="")
     solutions_folder: str = field(init=False)
     verbose: bool = False
     log: bool = True
@@ -61,6 +65,8 @@ class NotebookProcessor:
         )  # Create a logger instance specific to this module
         self.logger = logger  # Assign the logger instance to the class for use in instance methods
 
+        self.total_point_log = {}
+
     def process_notebooks(self):
         """
         Recursively processes Jupyter notebooks in a given folder and its subfolders.
@@ -115,6 +121,12 @@ class NotebookProcessor:
                 # Process the notebook if it meets the criteria
                 self._process_single_notebook(notebook_path)
 
+        # Write the dictionary to a JSON file
+        with open(f"{self.solutions_folder}/total_points.json", "w") as json_file:
+            json.dump(
+                self.total_point_log, json_file, indent=4
+            )  # `indent=4` for pretty formatting
+
     def _print_and_log(self, message):
         """
         Logs a message and optionally prints it to the console.
@@ -167,6 +179,11 @@ class NotebookProcessor:
             None
         """
 
+        self.select_many_total_points = 0
+        self.mcq_total_points = 0
+        self.tf_total_points = 0
+        self.otter_total_points = 0
+
         print(f"Processing notebook: {notebook_path}")
 
         logging.info(f"Processing notebook: {notebook_path}")
@@ -211,7 +228,7 @@ class NotebookProcessor:
         if any([solution_path_1, solution_path_2, solution_path_3]) is not None:
             solution_path = solution_path_1 or solution_path_2 or solution_path_3
 
-        student_notebook = self.free_response_parser(
+        student_notebook, self.otter_total_points = self.free_response_parser(
             temp_notebook_path, notebook_subfolder, notebook_name
         )
 
@@ -274,11 +291,32 @@ class NotebookProcessor:
                 os.path.join(questions_folder_jbook, question_file_name_sanitized),
             )
 
+        total_points = (
+            self.select_many_total_points
+            + self.mcq_total_points
+            + self.tf_total_points
+            + self.otter_total_points
+        )
+
+        self.total_point_log.update({notebook_name: total_points})
+
     def free_response_parser(
         self, temp_notebook_path, notebook_subfolder, notebook_name
     ):
         if self.has_assignment(temp_notebook_path, "# ASSIGNMENT CONFIG"):
             # TODO: This is hardcoded for now, but should be in a configuration file.
+            client_private_key = os.path.join(
+                os.path.dirname(temp_notebook_path),
+                ".client_private_key.bin",
+            )
+            server_public_key = os.path.join(
+                os.path.dirname(temp_notebook_path),
+                ".server_public_key.bin",
+            )
+
+            shutil.copy("./keys/.client_private_key.bin", client_private_key)
+            shutil.copy("./keys/.server_public_key.bin", server_public_key)
+
             client_private_key = os.path.join(
                 notebook_subfolder,
                 ".client_private_key.bin",
@@ -291,7 +329,9 @@ class NotebookProcessor:
             shutil.copy("./keys/.client_private_key.bin", client_private_key)
             shutil.copy("./keys/.server_public_key.bin", server_public_key)
 
-            FastAPINotebookBuilder(notebook_path=temp_notebook_path)
+            out = FastAPINotebookBuilder(
+                notebook_path=temp_notebook_path, assignment_tag=self.assignment_tag
+            )
 
             debug_notebook = os.path.join(
                 notebook_subfolder,
@@ -336,10 +376,10 @@ class NotebookProcessor:
             os.remove(client_private_key)
             os.remove(server_public_key)
 
-            return student_notebook
+            return student_notebook, out.total_points
         else:
             NotebookProcessor.add_initialization_code(temp_notebook_path)
-            return None
+            return None, 0
 
     @staticmethod
     def remove_assignment_config_cells(notebook_path):
@@ -388,7 +428,9 @@ class NotebookProcessor:
 
             for data_ in data:
                 # Generate the solution file
-                self.generate_solution_MCQ(data, output_file=solution_path)
+                self.mcq_total_points = self.generate_solution_MCQ(
+                    data, output_file=solution_path
+                )
 
                 question_path = (
                     f"{new_notebook_path.replace(".ipynb", "")}_questions.py"
@@ -428,7 +470,9 @@ class NotebookProcessor:
 
             # for data_ in data:
             # Generate the solution file
-            self.generate_solution_MCQ(data, output_file=solution_path)
+            self.tf_total_points = self.generate_solution_MCQ(
+                data, output_file=solution_path
+            )
 
             question_path = f"{new_notebook_path.replace(".ipynb", "")}_questions.py"
 
@@ -464,7 +508,9 @@ class NotebookProcessor:
 
             # for data_ in data:
             # Generate the solution file
-            self.generate_solution_MCQ(data, output_file=solution_path)
+            self.select_many_total_points = self.generate_solution_MCQ(
+                data, output_file=solution_path
+            )
 
             question_path = f"{new_notebook_path.replace(".ipynb", "")}_questions.py"
 
@@ -671,12 +717,14 @@ class NotebookProcessor:
             if hasattr(existing_module, "total_points"):
                 total_points.extend(existing_module.total_points)
 
+        question_points = 0
         # Process new question data and update solutions and total_points
         for question_set in data_list:
             for key, question_data in question_set.items():
                 solution_key = f"q{question_data['question number']}-{question_data['subquestion_number']}-{key}"
                 solutions[solution_key] = question_data["solution"]
                 total_points.extend([question_data["points"]])
+                question_points += question_data["points"]
 
         # Write updated total_points and solutions back to the file
         with open(output_file, "w", encoding="utf-8") as f:
@@ -689,6 +737,8 @@ class NotebookProcessor:
                 f.write(f'    "{key}": {repr(solution)},\n')
             f.write("}\n")
 
+        return question_points
+
     def extract_MCQ(ipynb_file):
         """
         Extracts questions from markdown cells and organizes them as a nested dictionary,
@@ -1635,9 +1685,18 @@ def main():
     parser.add_argument(
         "root_folder", type=str, help="Path to the root folder to process"
     )
-    args = parser.parse_args()
 
-    processor = NotebookProcessor(args.root_folder)
+    parser.add_argument(
+        "--assignment-tag",
+        type=str,
+        help="assignment-tag used for calculating grades",
+        default="Reading-Week-X",
+    )
+
+    args = parser.parse_args()
+    processor = NotebookProcessor(
+        root_folder=args.root_folder, assignment_tag=args.assignment_tag
+    )
     processor.process_notebooks()
 
 

pykubegrader-0.1.14/src/pykubegrader/initialize.py

@@ -0,0 +1,108 @@
+import os
+import shutil
+from pathlib import Path
+
+import panel as pn
+import requests
+from IPython import get_ipython
+
+from .telemetry import ensure_responses, log_variable, telemetry, update_responses
+
+
+def initialize_assignment(
+    name: str,
+    url: str = "https://engr-131-api.eastus.cloudapp.azure.com/",
+    verbose: bool = False,
+) -> dict:
+    """
+    Initialize an assignment in a Jupyter environment.
+
+    Args:
+        name (str): The name of the assignment.
+        url (str): The URL of the API server.
+        verbose (bool): Whether to print detailed initialization information.
+
+    Returns:
+        dict: The responses dictionary after initialization.
+
+    Raises:
+        Exception: If the environment is unsupported or initialization fails.
+    """
+
+    ipython = get_ipython()
+    if ipython is None:
+        raise Exception("Setup unsuccessful. Are you in a Jupyter environment?")
+
+    try:
+        move_dotfiles()
+        ipython.events.register("pre_run_cell", telemetry)
+    except Exception as e:
+        raise Exception(f"Failed to register telemetry: {e}")
+
+    jhub_user = os.getenv("JUPYTERHUB_USER")
+    if jhub_user is None:
+        raise Exception("Setup unsuccessful. Are you on JupyterHub?")
+
+    try:
+        seed = hash(jhub_user) % 1000
+        update_responses(key="seed", value=seed)
+
+        update_responses(key="assignment", value=name)
+        update_responses(key="jhub_user", value=jhub_user)
+
+        log_variable("Student Info", jhub_user, seed)
+
+        responses = ensure_responses()
+        # TODO: Add more checks here?
+        assert isinstance(responses.get("seed"), int), "Seed not set"
+
+        pn.extension(silent=True)
+
+        # Check connection to API server
+        params = {"jhub_user": responses["jhub_user"]}
+        response = requests.get(url, params=params)
+        if verbose:
+            print(f"status code: {response.status_code}")
+            data = response.json()
+            for k, v in data.items():
+                print(f"{k}: {v}")
+    except Exception as e:
+        raise Exception(f"Failed to initialize assignment: {e}")
+
+    print("Assignment successfully initialized")
+    if verbose:
+        print(f"Assignment: {name}")
+        print(f"Username: {jhub_user}")
+
+    return responses
+
+
+#
+# Helper functions
+#
+
+
+def move_dotfiles():
+    """
+    Move essential dotfiles from a fixed source directory to the current working directory.
+
+    Raises:
+        FileNotFoundError: If a source file is missing.
+        Exception: If copying fails for any other reason.
+    """
+    source_dir = Path("/opt/dotfiles")
+    target_dir = Path.cwd()
+
+    files_to_copy = [".client_private_key.bin", ".server_public_key.bin"]
+
+    for file_name in files_to_copy:
+        source_file = source_dir / file_name
+        target_file = target_dir / file_name
+
+        if not source_file.exists():
+            raise FileNotFoundError(f"Key file not found: {source_file}")
+
+        try:
+            shutil.copy2(source_file, target_file)
+        except Exception as e:
+            raise Exception(f"Failed to copy {source_file} to {target_file}: {e}")

pykubegrader-0.1.14/src/pykubegrader/log_parser/parse.ipynb

@@ -0,0 +1,214 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from .parse import LogParser\n",
+    "\n",
+    "# ----------------- Example usage -----------------\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    log_lines = [\n",
+    "        \"Student Info, 449, jovyan, 2024-12-27 20:55:12\",\n",
+    "        \"total-points, 4.0, week1-readings, 17_operators_q, 2024-12-27 20:55:23\",\n",
+    "        \"17_operators_q, question-operators-mario-dining-1, 0, 0.5, 2024-12-27 20:55:23\",\n",
+    "        \"17_operators_q, question-operators-mario-dining-2, 0, 0.5, 2024-12-27 20:55:23\",\n",
+    "        \"17_operators_q, question-operators-mario-dining-3, 0, 0.5, 2024-12-27 20:55:23\",\n",
+    "        \"17_operators_q, question-operators-mario-dining-4, 0, 0.5, 2024-12-27 20:55:23\",\n",
+    "        \"17_operators_q, question-operators-mario-dining-5, 0, 1.0, 2024-12-27 20:55:23\",\n",
+    "        \"total-points, 4.0, week1-readings, 17_operators_q, 2024-12-27 20:55:42\",\n",
+    "        \"17_operators_q, question-operators-mario-dining-1, 0.5, 0.5, 2024-12-27 20:55:42\",\n",
+    "        \"17_operators_q, question-operators-mario-dining-2, 0.5, 0.5, 2024-12-27 20:55:42\",\n",
+    "        \"17_operators_q, question-operators-mario-dining-3, 0.5, 0.5, 2024-12-27 20:55:42\",\n",
+    "        \"17_operators_q, question-operators-mario-dining-4, 0.5, 0.5, 2024-12-27 20:55:42\",\n",
+    "        \"17_operators_q, question-operators-mario-dining-5, 1.0, 1.0, 2024-12-27 20:55:42\",\n",
+    "        \"total-points, 2.0, week1-readings, 17_operators_q, 2024-12-27 20:55:47\",\n",
+    "        \"17_operators_q, question-operators-mario-dining-1, 0.5, 0.5, 2024-12-27 20:55:47\",\n",
+    "        \"17_operators_q, question-operators-mario-dining-2, 0, 0.5, 2024-12-27 20:55:47\",\n",
+    "        \"17_operators_q, question-operators-mario-dining-3, 0.5, 0.5, 2024-12-27 20:55:47\",\n",
+    "        \"17_operators_q, question-operators-mario-dining-4, 0, 0.5, 2024-12-27 20:55:47\",\n",
+    "        \"17_operators_q, question-operators-mario-dining-5, 0, 1.0, 2024-12-27 20:55:47\",\n",
+    "        \"19_operators_q, question-operators-mario-dining-3, 0.5, 0.5, 2024-12-27 20:55:47\",\n",
+    "    ]\n",
+    "\n",
+    "    parser = LogParser(log_lines=log_lines, week_tag=\"week1-readings\")\n",
+    "    parser.parse_logs()\n",
+    "    parser.calculate_total_scores()\n",
+    "    results = parser.get_results()\n",
+    "\n",
+    "    print(\"Student Information:\")\n",
+    "    print(results[\"student_information\"])\n",
+    "\n",
+    "    print(\"\\nAssignment Information:\")\n",
+    "    for assignment, info in results[\"assignment_information\"].items():\n",
+    "        print(f\"\\nAssignment Tag: {assignment}\")\n",
+    "        print(f\"Latest Timestamp: {info['latest_timestamp']}\")\n",
+    "        print(f\"Total Score: {info['total_score']}\")\n",
+    "        print(f\"Max Points: {info['max_points']}\")\n",
+    "\n",
+    "    print(\"\\nAssignment Scores:\")\n",
+    "    for assignment, score_info in results[\"assignment_scores\"].items():\n",
+    "        print(f\"\\nAssignment Tag: {assignment}\")\n",
+    "        print(f\"Total Score Earned: {score_info['total_score']}\")\n",
+    "        print(\"Questions:\")\n",
+    "        for q_tag, q_data in score_info[\"questions\"].items():\n",
+    "            print(f\"  {q_tag}:\")\n",
+    "            print(f\"    score_earned: {q_data['score_earned']}\")\n",
+    "            print(f\"    score_possible: {q_data['score_possible']}\")\n",
+    "            print(f\"    timestamp: {q_data['timestamp']}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "log_lines = [\n",
+    "    # Student Info\n",
+    "    \"Student Info, 449, jovyan, 2024-12-27 20:55:12\",\n",
+    "    # Week 1 Assignment: 17_operators_q\n",
+    "    \"total-points, 3.0, week1-readings, 17_operators_q, 2024-12-27 20:55:23\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-1, 0, 0.5, 2024-12-27 20:55:23\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-2, 0.5, 0.5, 2024-12-27 20:55:23\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-3, 0.5, 0.5, 2024-12-27 20:55:23\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-4, 0.5, 0.5, 2024-12-27 20:55:23\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-5, 1.0, 1.0, 2024-12-27 20:55:23\",\n",
+    "    # Week 1 Assignment: 18_advanced_q\n",
+    "    \"total-points, 4.0, week1-readings, 18_advanced_q, 2024-12-27 20:56:00\",\n",
+    "    \"18_advanced_q, question-advanced-problem-1, 1.0, 1.0, 2024-12-27 20:56:00\",\n",
+    "    \"18_advanced_q, question-advanced-problem-2, 1.0, 1.0, 2024-12-27 20:56:00\",\n",
+    "    \"18_advanced_q, question-advanced-problem-3, 0.5, 1.0, 2024-12-27 20:56:00\",\n",
+    "    \"18_advanced_q, question-advanced-problem-4, 0.5, 1.0, 2024-12-27 20:56:00\",\n",
+    "    # Week 2 Assignment: 19_concepts_q\n",
+    "    \"total-points, 5.0, week2-concepts, 19_concepts_q, 2024-12-28 20:57:00\",\n",
+    "    \"19_concepts_q, question-concepts-basic-1, 0.5, 1.0, 2024-12-28 20:57:00\",\n",
+    "    \"19_concepts_q, question-concepts-basic-2, 0.5, 1.0, 2024-12-28 20:57:00\",\n",
+    "    \"19_concepts_q, question-concepts-basic-3, 0.5, 1.0, 2024-12-28 20:57:00\",\n",
+    "    \"19_concepts_q, question-concepts-basic-4, 0.5, 1.0, 2024-12-28 20:57:00\",\n",
+    "    \"19_concepts_q, question-concepts-basic-5, 1.0, 1.0, 2024-12-28 20:57:00\",\n",
+    "]\n",
+    "\n",
+    "\n",
+    "parser = LogParser(log_lines=log_lines, week_tag=\"week1-readings\")\n",
+    "parser.parse_logs()\n",
+    "parser.calculate_total_scores()\n",
+    "results = parser.get_results()\n",
+    "\n",
+    "results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "log_lines = [\n",
+    "    # Student Info\n",
+    "    \"Student Info, 550, jovyan2, 2024-12-27 20:55:12\",\n",
+    "    # Week 1 Assignment: 17_operators_q (Initial Attempt)\n",
+    "    \"total-points, 3.0, week1-readings,17_operators_q, 2024-12-27 20:55:23\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-1, 0, 0.5, 2024-12-27 20:55:23\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-2, 0, 0.5, 2024-12-27 20:55:23\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-3, 0.5, 0.5, 2024-12-27 20:55:23\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-4, 0, 0.5, 2024-12-27 20:55:23\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-5, 0, 1.0, 2024-12-27 20:55:23\",\n",
+    "    # Week 1 Assignment: 17_operators_q (Re-attempt)\n",
+    "    \"total-points, 3.0, week1-readings,17_operators_q, 2024-12-27 21:00:00\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-1, 0.5, 0.5, 2024-12-27 21:00:00\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-2, 0.5, 0.5, 2024-12-27 21:00:00\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-4, 0.5, 0.5, 2024-12-27 21:00:00\",\n",
+    "    # Week 1 Assignment: 18_challenging_q\n",
+    "    \"total-points, 5.0, week1-readings,18_challenging_q, 2024-12-27 21:05:00\",\n",
+    "    \"18_challenging_q, question-challenging-problem-1, 1.0, 1.0, 2024-12-27 21:05:00\",\n",
+    "    \"18_challenging_q, question-challenging-problem-2, 0.5, 1.0, 2024-12-27 21:05:00\",\n",
+    "    \"18_challenging_q, question-challenging-problem-3, 1.0, 1.0, 2024-12-27 21:05:00\",\n",
+    "    \"18_challenging_q, question-challenging-problem-4, 1.0, 1.0, 2024-12-27 21:05:00\",\n",
+    "    \"18_challenging_q, question-challenging-problem-5, 0, 1.0, 2024-12-27 21:05:00\",\n",
+    "]\n",
+    "\n",
+    "parser = LogParser(log_lines=log_lines, week_tag=\"week1-readings\")\n",
+    "parser.parse_logs()\n",
+    "parser.calculate_total_scores()\n",
+    "results = parser.get_results()\n",
+    "\n",
+    "results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "log_lines = [\n",
+    "    # Student Info\n",
+    "    \"Student Info, 660, jovyan3, 2024-12-27 20:55:12\",\n",
+    "    # Week 1 Assignment: skipped some questions\n",
+    "    \"total-points, 4.0, week1-readings,17_operators_q, 2024-12-27 20:55:23\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-1, 0.5, 0.5, 2024-12-27 20:55:23\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-3, 0.5, 0.5, 2024-12-27 20:55:23\",\n",
+    "    \"17_operators_q, question-operators-mario-dining-5, 1.0, 1.0, 2024-12-27 20:55:23\",\n",
+    "    \"total-points, 4.0, week1-readings,18_operators_q, 2024-12-27 20:55:23\",\n",
+    "    # Week 2 Assignment: all questions attempted\n",
+    "    \"total-points, 5.0, week2-math,20_math_q, 2024-12-28 20:55:23\",\n",
+    "    \"20_math_q, question-math-basic-1, 1.0, 1.0, 2024-12-28 20:55:23\",\n",
+    "    \"20_math_q, question-math-basic-2, 0.5, 1.0, 2024-12-28 20:55:23\",\n",
+    "    \"20_math_q, question-math-basic-3, 0.5, 1.0, 2024-12-28 20:55:23\",\n",
+    "    \"20_math_q, question-math-basic-4, 1.0, 1.0, 2024-12-28 20:55:23\",\n",
+    "    \"20_math_q, question-math-basic-5, 0.5, 1.0, 2024-12-28 20:55:23\",\n",
+    "    # Week 3 Assignment: some skipped, partial scores\n",
+    "    \"total-points, 4.0, week3-concepts,21_concepts_q, 2024-12-29 20:55:23\",\n",
+    "    \"21_concepts_q, question-concepts-basic-1, 0.5, 1.0, 2024-12-29 20:55:23\",\n",
+    "    \"21_concepts_q, question-concepts-basic-2, 0.5, 1.0, 2024-12-29 20:55:23\",\n",
+    "]\n",
+    "\n",
+    "parser = LogParser(log_lines=log_lines, week_tag=\"week1-readings\")\n",
+    "parser.parse_logs()\n",
+    "parser.calculate_total_scores()\n",
+    "results = parser.get_results()\n",
+    "\n",
+    "results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "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-0.1.14/src/pykubegrader/log_parser/parse.py

@@ -0,0 +1,184 @@
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+
+@dataclass
+class LogParser:
+    """
+    A class for parsing chronological logs and extracting information.
+    Handles both assignment info and question-level details.
+    """
+
+    log_lines: List[str]
+    week_tag: Optional[str] = None
+    student_info: Dict[str, str] = field(default_factory=dict)
+    assignments: Dict[str, Dict] = field(default_factory=dict)
+
+    def parse_logs(self):
+        """
+        Main method to parse logs and populate student_info and assignments.
+        """
+        unique_students = set()
+
+        self._find_all_questions()
+
+        for line in reversed(
+            self.log_lines
+        ):  # Process in reverse to get the most recent entries first
+            if self._is_student_info(line):
+                self._process_student_info(line, unique_students)
+            elif (
+                any(item in line for item in self.all_questions)
+                and "total-points" in line
+            ):
+                self._process_assignment_header(line)
+
+        # process assignment entries after all headers have been processed
+        for line in reversed(self.log_lines):
+            if (
+                any(item in line for item in self.all_questions)
+                and "total-points" not in line
+            ):
+                self._process_assignment_entry(line)
+
+    def _find_all_questions(self):
+        """
+        Finds all questions in the log_lines and returns a list of them.
+        """
+        questions = []
+        for line in self.log_lines:
+            if self.week_tag in line:
+                parts = line.split(",")
+                question_tag = parts[3].strip()
+                if question_tag not in questions:
+                    questions.append(question_tag)
+        self.all_questions = questions
+
+    def _is_student_info(self, line: str) -> bool:
+        """
+        Checks if the line contains student information.
+        """
+        return line.startswith("Student Info")
+
+    def _process_student_info(self, line: str, unique_students: set):
+        """
+        Processes a line containing student information.
+        Raises an error if multiple unique students are found.
+        """
+        parts = line.split(", ")
+        # Example: "Student Info, 790, jovyan, 2024-12-27 19:40:10"
+        student_name = parts[2].strip()
+        unique_students.add(student_name)
+
+        if len(unique_students) > 1:
+            raise ValueError(
+                f"Error: Multiple unique student names found: {unique_students}"
+            )
+
+        # Only set student_info once
+        if not self.student_info:
+            self.student_info = {
+                "student_id": parts[1].strip(),
+                "username": student_name,
+                "timestamp": parts[3].strip(),
+            }
+
+    def _process_assignment_header(self, line: str):
+        parts = line.split(",")
+        assignment_tag = parts[0].strip()
+        if assignment_tag.startswith("total-points"):
+            # Handle total-points lines as assignment info
+            total_points_value = self._extract_total_points(parts)
+            timestamp = parts[-1].strip()
+            notebook_name = parts[3].strip()
+
+            if notebook_name not in self.assignments:
+                self.assignments[notebook_name] = {
+                    "max_points": total_points_value,
+                    "notebook": notebook_name,
+                    "assignment": self.week_tag,
+                    "total_score": 0.0,
+                    "latest_timestamp": timestamp,
+                    "questions": {},  # Ensure 'questions' key is initialized
+                }
+            elif self.assignments[notebook_name]["latest_timestamp"] < timestamp:
+                self.assignments[notebook_name]["max_points"] = total_points_value
+                self.assignments[notebook_name]["latest_timestamp"] = timestamp
+
+    def _process_assignment_entry(self, line: str):
+        """
+        Processes a line containing an assignment entry.
+        Adds it to the assignments dictionary.
+        """
+        parts = line.split(",")
+        assignment_tag = parts[0].strip()
+        question_tag = parts[1].strip()
+        score_earned = float(parts[2].strip()) if len(parts) > 2 else 0.0
+        score_possible = float(parts[3].strip()) if len(parts) > 3 else 0.0
+        timestamp = parts[-1].strip()
+
+        # Ensure assignment entry exists
+        if assignment_tag not in self.assignments:
+            self.assignments[assignment_tag] = {
+                "questions": {},
+                "total_score": 0.0,
+                "latest_timestamp": timestamp,
+            }
+
+        # Add or update the question with the most recent timestamp
+        questions = self.assignments[assignment_tag]["questions"]
+        if (
+            question_tag not in questions
+            or timestamp > questions[question_tag]["timestamp"]
+        ):
+            questions[question_tag] = {
+                "score_earned": score_earned,
+                "score_possible": score_possible,
+                "timestamp": timestamp,
+            }
+
+        # Update the latest timestamp if this one is more recent
+        if timestamp > self.assignments[assignment_tag]["latest_timestamp"]:
+            self.assignments[assignment_tag]["latest_timestamp"] = timestamp
+
+    def _extract_total_points(self, parts: List[str]) -> Optional[float]:
+        """
+        Extracts the total-points value from the parts array of a total-points line.
+        """
+        try:
+            return float(parts[1].strip())
+        except (ValueError, IndexError):
+            return None
+
+    def calculate_total_scores(self):
+        """
+        Calculates total scores for each assignment by summing the 'score_earned'
+        of its questions, and sets 'total_points' if it was not specified.
+        """
+        for assignment, data in self.assignments.items():
+            # Sum of all question score_earned
+            total_score = sum(q["score_earned"] for q in data["questions"].values())
+            data["total_score"] = total_score
+
+    def get_results(self) -> Dict[str, Dict]:
+        """
+        Returns the parsed results as a hierarchical dictionary with three sections:
+        """
+        return {
+            "student_information": self.student_info,
+            "assignment_information": {
+                assignment: {
+                    "latest_timestamp": data["latest_timestamp"],
+                    "total_score": data["total_score"],
+                    "max_points": data.get("max_points", 0.0),
+                }
+                for assignment, data in self.assignments.items()
+            },
+            "assignment_scores": {
+                assignment: {
+                    "questions": data["questions"],
+                    "total_score": data["total_score"],
+                }
+                for assignment, data in self.assignments.items()
+            },
+        }

{pykubegrader-0.1.12 → pykubegrader-0.1.14}/src/pykubegrader/telemetry.py

@@ -11,8 +11,28 @@ from IPython.core.interactiveshell import ExecutionInfo
 from requests import Response
 from requests.auth import HTTPBasicAuth
 
-# Set logging config (`force` is important)
-logging.basicConfig(filename=".output.log", level=logging.INFO, force=True)
+# Logger for .output_code.log
+logger_code = logging.getLogger("code_logger")
+logger_code.setLevel(logging.INFO)
+
+file_handler_code = logging.FileHandler(".output_code.log")
+file_handler_code.setLevel(logging.INFO)
+
+# formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+# file_handler_code.setFormatter(formatter)
+
+logger_code.addHandler(file_handler_code)
+
+# Logger for .output_reduced.log
+logger_reduced = logging.getLogger("reduced_logger")
+logger_reduced.setLevel(logging.INFO)
+
+file_handler_reduced = logging.FileHandler(".output_reduced.log")
+file_handler_reduced.setLevel(logging.INFO)
+
+# file_handler_reduced.setFormatter(formatter)
+
+logger_reduced.addHandler(file_handler_reduced)
 
 #
 # Local functions
@@ -51,20 +71,30 @@ def ensure_responses() -> dict:
     return responses
 
 
-def log_encrypted(message: str) -> None:
+def log_encrypted(logger: logging.Logger, message: str) -> None:
+    """
+    Logs an encrypted version of the given message using the provided logger.
+
+    Args:
+        logger (object): The logger object used to log the encrypted message.
+        message (str): The message to be encrypted and logged.
+
+    Returns:
+        None
+    """
     encrypted_b64 = encrypt_to_b64(message)
-    logging.info(f"Encrypted Output: {encrypted_b64}")
+    logger.info(f"Encrypted Output: {encrypted_b64}")
 
 
-def log_variable(value, info_type) -> None:
+def log_variable(assignment_name, value, info_type) -> None:
     timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    message = f"{info_type}, {value}, {timestamp}"
-    log_encrypted(message)
+    message = f"{assignment_name}, {info_type}, {value}, {timestamp}"
+    log_encrypted(logger_reduced, message)
 
 
 def telemetry(info: ExecutionInfo) -> None:
     cell_content = info.raw_cell
-    log_encrypted(f"code run: {cell_content}")
+    log_encrypted(logger_code, f"code run: {cell_content}")
 
 
 def update_responses(key: str, value) -> dict:
@@ -119,7 +149,7 @@ def score_question(
     return res
 
 
-def submit_question_new(
+def submit_question(
     student_email: str,
     term: str,
     assignment: str,

{pykubegrader-0.1.12 → pykubegrader-0.1.14}/src/pykubegrader/validate.py

@@ -32,28 +32,7 @@ def validate_logfile(
     # Generate box from private and public keys
     key_box = generate_keys()
 
-    with open(filepath, "r") as logfile:
-        encrypted_lines = logfile.readlines()
-
-    decrypted_log: list[str] = []
-    for line in encrypted_lines:
-        if "Encrypted Output: " in line:
-            trimmed = line.split("Encrypted Output: ")[1].strip()
-            decoded = base64.b64decode(trimmed)
-            decrypted = key_box.decrypt(decoded).decode()
-            decrypted_log.append(decrypted)
-
-    # Decoding the log file
-    # data_: list[str] = drexel_jupyter_logger.decode_log_file(self.filepath, key=key)
-    # _loginfo = str(decrypted_log)
-
-    # Where possible, we should work with this reduced list of relevant entries
-    # Here we take only lines with student info or question scores
-    log_reduced = [
-        entry
-        for entry in decrypted_log
-        if re.match(r"info,", entry) or re.match(r"q\d+_\d+,", entry)
-    ]
+    decrypted_log, log_reduced = read_logfile(filepath, key_box)
 
     # For debugging; to be commented out
     # with open(".output_reduced.log", "w") as f:
@@ -246,6 +225,36 @@ def validate_logfile(
     submission_message(response)
 
 
+def read_logfile(filepath, key_box=None) -> tuple[list[str], list[str]]:
+    if key_box is None:
+        key_box = generate_keys()
+
+    with open(filepath, "r") as logfile:
+        encrypted_lines = logfile.readlines()
+
+    decrypted_log: list[str] = []
+    for line in encrypted_lines:
+        if "Encrypted Output: " in line:
+            trimmed = line.split("Encrypted Output: ")[1].strip()
+            decoded = base64.b64decode(trimmed)
+            decrypted = key_box.decrypt(decoded).decode()
+            decrypted_log.append(decrypted)
+
+    # Decoding the log file
+    # data_: list[str] = drexel_jupyter_logger.decode_log_file(self.filepath, key=key)
+    # _loginfo = str(decrypted_log)
+
+    # Where possible, we should work with this reduced list of relevant entries
+    # Here we take only lines with student info or question scores
+    log_reduced = [
+        entry
+        for entry in decrypted_log
+        if re.match(r"info,", entry) or re.match(r"q\d+_\d+,", entry)
+    ]
+
+    return decrypted_log, log_reduced
+
+
 #
 # Helper functions
 #

pykubegrader-0.1.12/src/pykubegrader/initialize.py

@@ -1,65 +0,0 @@
-import json
-import os
-from typing import Optional
-
-import panel as pn
-from IPython import get_ipython
-import requests
-from .telemetry import telemetry, update_responses, ensure_responses
-
-
-def initialize_assignment(
-    name: str,
-    verbose: Optional[bool] = False,
-    url: Optional[str] = "https://engr-131-api.eastus.cloudapp.azure.com/",
-) -> None:
-    ipython = get_ipython()
-    if ipython is None:
-        print("Setup unsuccessful. Are you in a Jupyter environment?")
-        return
-
-    try:
-        ipython.events.register("pre_run_cell", telemetry)
-    except TypeError as e:
-        print(f"Failed to register telemetry: {e}")
-        return
-
-    jhub_user = os.getenv("JUPYTERHUB_USER")
-    if jhub_user is None:
-        print("Setup unsuccessful. Are you on JupyterHub?")
-        return
-
-    try:
-        seed = hash(jhub_user) % 1000
-        update_responses(key="seed", value=seed)
-        update_responses(key="assignment", value=name)
-        update_responses(key="jhub_user", value=jhub_user)
-
-    except (TypeError, json.JSONDecodeError) as e:
-        print(f"Failed to initialize assignment: {e}")
-        return
-
-    # extract responses
-    responses = ensure_responses()
-
-    # TODO: Add more checks here??
-    assert isinstance(responses.get("seed"), int), "valid seed not found in responses"
-
-    pn.extension(silent=True)
-
-    if verbose:
-        print("Assignment successfully initialized")
-        print(f"Assignment: {name}")
-        print(f"Username: {jhub_user}")
-
-    # Checks connectivity to the API
-    params = {"jhub_user": responses["jhub_user"]}
-    response = requests.get(url, params=params)
-    if verbose:
-        print(f"status code: {response.status_code}")
-        data = response.json()
-        for k, v in data.items():
-            print(f"{k}: {v}")
-
-    print("Assignment successfully initialized")
-    return responses