PyKubeGrader 0.1.9__py3-none-any.whl → 0.1.10__py3-none-any.whl

{PyKubeGrader-0.1.9.dist-info → PyKubeGrader-0.1.10.dist-info}/METADATA

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

{PyKubeGrader-0.1.9.dist-info → PyKubeGrader-0.1.10.dist-info}/RECORD

@@ -1,9 +1,10 @@
 pykubegrader/__init__.py,sha256=AoAkdfIjDDZGWLlsIRENNq06L9h46kDGBIE8vRmsCfg,311
-pykubegrader/initialize.py,sha256=xvaN4mepZn25x37YZhQj3UgqGq1PBc7yDGt9LBKgzAY,1105
-pykubegrader/telemetry.py,sha256=uuC4ZPLHYrAmKFBu3dJ3LGoEvQlT1LtOJjUldnfISEE,3343
+pykubegrader/initialize.py,sha256=SREGdFK8kqnk8RYTtaTO5LKZiK2Y4YxBNjrALl5jaNo,1956
+pykubegrader/telemetry.py,sha256=Zkap_ml7hWz7akBVzE-zqri_K-AkBSTEhv0IE3VM9iY,3943
 pykubegrader/utils.py,sha256=dKw6SyRYU3DWRgD3xER7wq-C9e1daWPkqr901LpcwiQ,642
-pykubegrader/validate.py,sha256=A6FxQrC76ulneRvC7PBHawTSBck6xe1qBGMgqhBXd9c,10682
-pykubegrader/build/build_folder.py,sha256=YQz11Jpb6huUMrVoi6aupGOMDmIy3e2impCuELUKtG8,58886
+pykubegrader/validate.py,sha256=PeT6Gx4ZOQYyogG4nb3TD9YfEkAmf__fR1aOOB3ZBWo,10705
+pykubegrader/build/api_notebook_builder.py,sha256=vtRA9lDCc-PXN-y56wEXS-h_aKXDU_ChS-1_ooiKCOk,18975
+pykubegrader/build/build_folder.py,sha256=HkyzQAPUJBB4VkRLllllyy1eqbe2EMa-NREVy8qbSeg,63417
 pykubegrader/widgets/__init__.py,sha256=s3ky3eJDa1RedFVdpKxmqv6mHBYpOSL9Z6qThSH9cbs,303
 pykubegrader/widgets/multiple_choice.py,sha256=NjD3-uXSnibpUQ0mO3hRp_O-rynFyl0Dz6IXE4tnCRI,2078
 pykubegrader/widgets/reading_question.py,sha256=y30_swHwzH8LrT8deWTnxctAAmR8BSxTlXAqMgUrAT4,3031
@@ -16,9 +17,9 @@ pykubegrader/widgets_base/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-
 pykubegrader/widgets_base/multi_select.py,sha256=u50IOhYxC_S_gq31VnFPLdbNajk_SUWhaqlMSJxhqVQ,3439
 pykubegrader/widgets_base/reading.py,sha256=4uTLmlPzCwxVzufFhPjM7W19uMGguRb6y4eAV3x-zAc,5314
 pykubegrader/widgets_base/select.py,sha256=h1S5StcbX8S-Wiyga4fVDhPbVvRxffwaqyVbiiuInRs,2743
-PyKubeGrader-0.1.9.dist-info/LICENSE.txt,sha256=YTp-Ewc8Kems8PJEE27KnBPFnZSxoWvSg7nnknzPyYw,1546
-PyKubeGrader-0.1.9.dist-info/METADATA,sha256=O3VMp6EJd-6QAC9L9aHyf54mySq5OiwpFG0x22Vd0p0,2664
-PyKubeGrader-0.1.9.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-PyKubeGrader-0.1.9.dist-info/entry_points.txt,sha256=Kd4Bh-i3hc4qlnLU1p0nc8yPw9cC5AQGOtkk2eLGnQw,78
-PyKubeGrader-0.1.9.dist-info/top_level.txt,sha256=e550Klfze6higFxER1V62fnGOcIgiKRbsrl9CC4UdtQ,13
-PyKubeGrader-0.1.9.dist-info/RECORD,,
+PyKubeGrader-0.1.10.dist-info/LICENSE.txt,sha256=YTp-Ewc8Kems8PJEE27KnBPFnZSxoWvSg7nnknzPyYw,1546
+PyKubeGrader-0.1.10.dist-info/METADATA,sha256=3lNx_8olR4Gf2iX_Sy8jzbx-xZzrgv_YmhB-eqo9CXU,2665
+PyKubeGrader-0.1.10.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+PyKubeGrader-0.1.10.dist-info/entry_points.txt,sha256=Kd4Bh-i3hc4qlnLU1p0nc8yPw9cC5AQGOtkk2eLGnQw,78
+PyKubeGrader-0.1.10.dist-info/top_level.txt,sha256=e550Klfze6higFxER1V62fnGOcIgiKRbsrl9CC4UdtQ,13
+PyKubeGrader-0.1.10.dist-info/RECORD,,

pykubegrader/build/api_notebook_builder.py

@@ -0,0 +1,492 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+import json
+import nbformat
+import json
+import re
+import shutil
+
+
+@dataclass
+class FastAPINotebookBuilder:
+    notebook_path: str
+    temp_notebook: Optional[str] = None
+
+    def __post_init__(self):
+        self.root_path, self.filename = FastAPINotebookBuilder.get_filename_and_root(
+            self.notebook_path
+        )
+        self.run()
+
+    def run(self):
+
+        # here for easy debugging
+        if self.temp_notebook is not None:
+            shutil.copy(
+                self.notebook_path, self.notebook_path.replace(".ipynb", "_temp.ipynb")
+            )
+            self.temp_notebook = self.notebook_path.replace(".ipynb", "_temp.ipynb")
+        else:
+            self.temp_notebook = self.notebook_path
+
+        self.assertion_tests_dict = self.question_dict()
+        self.add_api_code()
+
+    def add_api_code(self):
+
+        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)}"
+            )
+
+            cell = self.get_cell(cell_index)
+            cell_source = FastAPINotebookBuilder.add_import_statements_to_tests(
+                cell["source"]
+            )
+
+            last_import_line_ind = FastAPINotebookBuilder.find_last_import_line(
+                cell_source
+            )
+
+            # header, body = FastAPINotebookBuilder.split_list_at_marker(cell_source)
+
+            updated_cell_source = []
+            updated_cell_source.extend(cell_source[: last_import_line_ind + 1])
+            if cell_dict["is_first"]:
+                updated_cell_source.extend(
+                    self.construct_first_cell_question_header(cell_dict)
+                )
+            updated_cell_source.extend(["\n"])
+            updated_cell_source.extend(
+                FastAPINotebookBuilder.construct_question_info(cell_dict)
+            )
+            updated_cell_source.extend(
+                FastAPINotebookBuilder.construct_update_responses(cell_dict)
+            )
+
+            updated_cell_source.extend(cell_source[last_import_line_ind + 1 :])
+            updated_cell_source.extend(["\n"])
+
+            updated_cell_source.extend(
+                FastAPINotebookBuilder.construct_graders(cell_dict)
+            )
+            updated_cell_source.extend(["\n"])
+            updated_cell_source.extend(
+                ["earned_points = float(os.environ.get('EARNED_POINTS', 0))\n"]
+            )
+            updated_cell_source.extend(["earned_points += score\n"])
+            updated_cell_source.extend(
+                [f'log_variable(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 construct_first_cell_question_header(self, cell_dict):
+        max_question_points = sum(
+            cell["points"]
+            for cell in self.assertion_tests_dict.values()
+            if cell["question"] == cell_dict["question"]
+        )
+
+        first_cell_header = ["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")
+
+        return first_cell_header
+
+    @staticmethod
+    def construct_update_responses(cell_dict):
+        update_responses = []
+        question_id = cell_dict["question"] + "-" + str(cell_dict["test_number"]) + "\n"
+
+        logging_variables = cell_dict["logging_variables"]
+
+        for logging_variable in logging_variables:
+            update_responses.append(
+                f"responses = update_responses(question_id, {logging_variable})\n"
+            )
+
+        return update_responses
+
+    @staticmethod
+    def split_list_at_marker(input_list, marker="""# END TEST CONFIG"""):
+        """
+        Splits a list into two parts at the specified marker string.
+
+        Args:
+            input_list (list): The list to split.
+            marker (str): The string at which to split the list.
+
+        Returns:
+            tuple: A tuple containing two lists. The first list contains the elements
+                before the marker, and the second list contains the elements after
+                the marker (excluding the marker itself).
+        """
+        if marker in input_list:
+            index = input_list.index(marker)
+            return input_list[: index + 1], input_list[index + 2 :]
+        else:
+            return (
+                input_list,
+                [],
+            )  # If the marker is not in the list, return the original list and an empty list
+
+    @staticmethod
+    def construct_graders(cell_dict):
+
+        # Generate Python code
+        added_code = [
+            "if "
+            + " and ".join(f"({test})" for test in cell_dict["assertions"])
+            + ":\n"
+        ]
+        added_code.append(f"    score = {cell_dict['points']}\n")
+
+        return added_code
+
+    @staticmethod
+    def construct_question_info(cell_dict):
+        question_info = []
+
+        question_id = cell_dict["question"] + "-" + str(cell_dict["test_number"])
+
+        question_info.append(f'question_id = "{question_id}"' + "\n")
+        question_info.append(f'max_score = {cell_dict["points"]}\n')
+        question_info.append("score = 0\n")
+
+        return question_info
+
+    @staticmethod
+    def insert_list_at_index(
+        original_list, insert_list, index, line_break=True, inplace_line_break=True
+    ):
+        """
+        Inserts a list into another list at a specific index.
+
+        Args:
+            original_list (list): The original list.
+            insert_list (list): The list to insert.
+            index (int): The position at which to insert the new list.
+
+        Returns:
+            list: A single combined list with the second list inserted at the specified index.
+        """
+
+        if inplace_line_break:
+            insert_list = [s + "\n" for s in insert_list]
+
+        if line_break:
+            if inplace_line_break:
+                insert_list = ["\n"] + insert_list
+            else:
+                insert_list = ["\n"] + insert_list + ["\n"]
+
+        return original_list[:index] + insert_list + original_list[index:]
+
+    @staticmethod
+    def add_import_statements_to_tests(cell_source):
+        """
+        Adds the necessary import statements to the first cell of the notebook.
+        """
+
+        end_test_config_line = "# END TEST CONFIG"
+
+        # Imports to add
+        imports = [
+            "from pykubegrader.telemetry import (\n",
+            "    ensure_responses,\n",
+            "    log_variable,\n",
+            "    score_question,\n",
+            "    submit_question_new,\n",
+            "    telemetry,\n",
+            "    update_responses,\n",
+            ")\n",
+            "import os\n",
+        ]
+
+        for i, line in enumerate(cell_source):
+            if end_test_config_line in line:
+                # Insert the imports immediately after the current line
+                cell_source[i + 1 : i + 1] = [
+                    "\n"
+                ] + imports  # Add a blank line for readability
+                return cell_source  # Exit the loop once the imports are inserted
+
+    def extract_first_cell(self):
+        with open(self.temp_notebook, "r", encoding="utf-8") as f:
+            notebook = json.load(f)
+        if "cells" in notebook and len(notebook["cells"]) > 0:
+            return notebook["cells"][0]
+        else:
+            return None
+
+    @staticmethod
+    def get_filename_and_root(path):
+        path_obj = Path(path).resolve()  # Resolve the path to get an absolute path
+        root_path = path_obj.parent  # Get the parent directory
+        filename = path_obj.name  # Get the filename
+        return root_path, filename
+
+    def get_cell(self, cell_index):
+        with open(self.temp_notebook, "r", encoding="utf-8") as f:
+            notebook = json.load(f)
+        if "cells" in notebook and len(notebook["cells"]) > cell_index:
+            return notebook["cells"][cell_index]
+        else:
+            return None
+
+    def replace_cell_source(self, cell_index, new_source):
+        """
+        Replace the source code of a specific Jupyter notebook cell.
+
+        Args:
+            cell_index (int): Index of the cell to be modified (0-based).
+            new_source (str): New source code to replace the cell's content.
+        """
+        # Load the notebook
+        with open(self.temp_notebook, "r", encoding="utf-8") as f:
+            notebook = nbformat.read(f, as_version=4)
+
+        # Check if the cell index is valid
+        if cell_index >= len(notebook.cells) or cell_index < 0:
+            raise IndexError(
+                f"Cell index {cell_index} is out of range for this notebook."
+            )
+
+        # Replace the source code of the specified cell
+        notebook.cells[cell_index]["source"] = new_source
+
+        # Save the notebook
+        with open(self.temp_notebook, "w", encoding="utf-8") as f:
+            nbformat.write(notebook, f)
+        print(f"Updated notebook saved to {self.temp_notebook}")
+
+    @staticmethod
+    def find_last_import_line(cell_source):
+        """
+        Finds the index of the last line with an import statement in a list of code lines,
+        including multiline import statements.
+
+        Args:
+            cell_source (list): List of strings representing the code lines.
+
+        Returns:
+            int: The index of the last line with an import statement, or -1 if no import is found.
+        """
+        last_import_index = -1
+        is_multiline_import = False  # Flag to track if we're inside a multiline import
+        
+        for i, line in enumerate(cell_source):
+            stripped_line = line.strip()
+
+            if is_multiline_import:
+                # Continue tracking multiline import
+                if stripped_line.endswith("\\") or (
+                    stripped_line and not stripped_line.endswith(")")
+                ):
+                    last_import_index = i  # Update to current line
+                    continue
+                else:
+                    is_multiline_import = False  # End of multiline import
+                    last_import_index = i  # Update to current line
+
+            # Check for single-line or start of multiline imports
+            if stripped_line.startswith("import") or stripped_line.startswith("from"):
+                last_import_index = i
+                # Check if it's a multiline import
+                if stripped_line.endswith("\\") or "(" in stripped_line:
+                    is_multiline_import = True
+
+        return last_import_index
+
+    @staticmethod
+    def extract_log_variables(cell):
+        """Extracts log variables from the first cell."""
+        if "source" in cell:
+            for line in cell["source"]:
+                # Look for the log_variables pattern
+                match = re.search(r"log_variables:\s*\[(.*?)\]", line)
+                if match:
+                    # Split the variables by comma and strip whitespace
+                    log_variables = [var.strip() for var in match.group(1).split(",")]
+                    return log_variables
+        return []
+
+    def tag_questions(cells_dict):
+        """
+        Adds 'is_first' and 'is_last' boolean flags to the cells based on their position
+        within the group of the same question. All cells will have both flags.
+
+        Args:
+            cells_dict (dict): A dictionary where keys are cell IDs and values are cell details.
+
+        Returns:
+            dict: The modified dictionary with 'is_first' and 'is_last' flags added.
+        """
+        if not isinstance(cells_dict, dict):
+            raise ValueError("Input must be a dictionary.")
+
+        # Ensure all cells have the expected structure
+        for key, cell in cells_dict.items():
+            if not isinstance(cell, dict):
+                raise ValueError(f"Cell {key} is not a dictionary.")
+            if "question" not in cell:
+                raise KeyError(f"Cell {key} is missing the 'question' key.")
+
+        # Group the keys by question name
+        question_groups = {}
+        for key, cell in cells_dict.items():
+            question = cell.get(
+                "question"
+            )  # Use .get() to avoid errors if key is missing
+            if question not in question_groups:
+                question_groups[question] = []
+            question_groups[question].append(key)
+
+        # Add 'is_first' and 'is_last' flags to all cells
+        for question, keys in question_groups.items():
+            test_number = 1
+            for i, key in enumerate(keys):
+                cells_dict[key]["is_first"] = i == 0
+                cells_dict[key]["is_last"] = i == len(keys) - 1
+                cells_dict[key]["test_number"] = test_number
+                test_number += 1
+
+        return cells_dict
+
+    def question_dict(self):
+
+        notebook_path = Path(self.temp_notebook)
+        if not notebook_path.exists():
+            raise FileNotFoundError(f"The file {notebook_path} does not exist.")
+
+        with open(notebook_path, "r", encoding="utf-8") as f:
+            notebook = json.load(f)
+
+        results_dict = {}
+
+        for cell_index, cell in enumerate(notebook.get("cells", [])):
+            if cell.get("cell_type") == "raw":
+                source = "".join(cell.get("source", ""))
+                if source.strip().startswith("# BEGIN QUESTION"):
+                    question_name = re.search(r"name:\s*(.*)", source)
+                    question_name = (
+                        question_name.group(1).strip() if question_name else None
+                    )
+
+            elif cell.get("cell_type") == "code":
+                source = "".join(cell.get("source", ""))
+
+                if source.strip().startswith('""" # BEGIN TEST CONFIG'):
+                    logging_variables = FastAPINotebookBuilder.extract_log_variables(
+                        cell
+                    )
+
+                    # Extract assert statements using a more robust approach
+                    assertions = []
+                    comments = []
+
+                    # Split the source into lines for processing
+                    lines = source.split("\n")
+                    i = 0
+                    while i < len(lines):
+                        line = lines[i].strip()
+                        if line.startswith("assert"):
+                            # Initialize assertion collection
+                            assertion_lines = []
+                            comment = None
+
+                            # Handle the first line
+                            first_line = line[6:].strip()  # Remove 'assert' keyword
+                            assertion_lines.append(first_line)
+
+                            # Stack to track parentheses
+                            paren_stack = []
+                            for char in first_line:
+                                if char == "(":
+                                    paren_stack.append(char)
+                                elif char == ")":
+                                    if paren_stack:
+                                        paren_stack.pop()
+
+                            # Continue collecting lines while we have unclosed parentheses
+                            current_line = i + 1
+                            while paren_stack and current_line < len(lines):
+                                next_line = lines[current_line].strip()
+                                assertion_lines.append(next_line)
+
+                                for char in next_line:
+                                    if char == "(":
+                                        paren_stack.append(char)
+                                    elif char == ")":
+                                        if paren_stack:
+                                            paren_stack.pop()
+
+                                current_line += 1
+
+                            # Join the assertion lines and clean up
+                            full_assertion = " ".join(assertion_lines)
+
+                            # Extract the comment if it exists (handling both f-strings and regular strings)
+                            comment_match = re.search(
+                                r',\s*(?:f?["\'])(.*?)(?:["\'])\s*(?:\)|$)',
+                                full_assertion,
+                            )
+                            if comment_match:
+                                comment = comment_match.group(1).strip()
+                                # Remove the comment from the assertion
+                                full_assertion = full_assertion[
+                                    : comment_match.start()
+                                ].strip()
+
+                            # Ensure proper parentheses closure
+                            open_count = full_assertion.count("(")
+                            close_count = full_assertion.count(")")
+                            if open_count > close_count:
+                                full_assertion += ")" * (open_count - close_count)
+
+                            # Clean up the assertion
+                            if full_assertion.startswith(
+                                "("
+                            ) and not full_assertion.endswith(")"):
+                                full_assertion += ")"
+
+                            assertions.append(full_assertion)
+                            comments.append(comment)
+
+                            # Update the line counter
+                            i = current_line
+                        else:
+                            i += 1
+
+                    # Extract points value
+                    points_line = next(
+                        (line for line in source.split("\n") if "points:" in line), None
+                    )
+                    points_value = None
+                    if points_line:
+                        try:
+                            points_value = float(points_line.split(":")[-1].strip())
+                        except ValueError:
+                            points_value = None
+
+                    # Add to results dictionary
+                    results_dict[cell_index] = {
+                        "assertions": assertions,
+                        "comments": comments,
+                        "question": question_name,
+                        "points": points_value,
+                        "logging_variables": logging_variables,
+                    }
+
+                    results_dict = FastAPINotebookBuilder.tag_questions(results_dict)
+
+        return results_dict

pykubegrader/build/build_folder.py

@@ -8,8 +8,8 @@ import shutil
 import subprocess
 import sys
 from dataclasses import dataclass, field
-
 import nbformat
+from .api_notebook_builder import FastAPINotebookBuilder
 
 
 @dataclass
@@ -166,6 +166,8 @@ class NotebookProcessor:
         Returns:
             None
         """
+        
+        print(f"Processing notebook: {notebook_path}")
 
         logging.info(f"Processing notebook: {notebook_path}")
         notebook_name = os.path.splitext(os.path.basename(notebook_path))[0]
@@ -196,6 +198,149 @@ class NotebookProcessor:
         else:
             self._print_and_log(f"Notebook already in destination: {new_notebook_path}")
 
+        solution_path_1, question_path = self.multiple_choice_parser(
+            temp_notebook_path, new_notebook_path
+        )
+        solution_path_2, question_path = self.true_false_parser(
+            temp_notebook_path, new_notebook_path
+        )
+        solution_path_3, question_path = self.select_many_parser(
+            temp_notebook_path, new_notebook_path
+        )
+
+        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(
+            temp_notebook_path, notebook_subfolder, notebook_name
+        )
+
+        # If Otter does not run, move the student file to the main directory
+        if student_notebook is None:
+            path_ = shutil.copy(temp_notebook_path, self.root_folder)
+            self._print_and_log(
+                f"Copied and cleaned student notebook: {path_} -> {self.root_folder}"
+            )
+
+        # Move the solution file to the autograder folder
+        if solution_path is not None:
+            # gets importable file name
+            importable_file_name = sanitize_string(
+                os.path.splitext(os.path.basename(solution_path))[0]
+            )
+
+            # Move the solution file to the autograder folder
+            os.rename(
+                solution_path,
+                os.path.join(autograder_path, f"{importable_file_name}.py"),
+            )
+
+        if question_path is not None:
+            shutil.move(question_path, student_path)
+
+        # Remove the temp copy of the notebook
+        os.remove(temp_notebook_path)
+
+        # Remove all postfix from filenames in dist
+        NotebookProcessor.remove_postfix(autograder_path, "_solutions")
+        NotebookProcessor.remove_postfix(student_path, "_questions")
+        NotebookProcessor.remove_postfix(self.root_folder, "_temp")
+
+        ### CODE TO ENSURE THAT STUDENT NOTEBOOK IS IMPORTABLE
+        if question_path is not None:
+            # question_root_path = os.path.dirname(question_path)
+            question_file_name = os.path.basename(question_path)
+            question_file_name_sanitized = sanitize_string(
+                question_file_name.replace("_questions", "")
+            )
+            if question_file_name_sanitized.endswith("_py"):
+                question_file_name_sanitized = question_file_name_sanitized[:-3] + ".py"
+
+            # Rename the file
+            os.rename(
+                os.path.join(
+                    student_path, question_file_name.replace("_questions", "")
+                ),
+                os.path.join(student_path, question_file_name_sanitized),
+            )
+
+            # Ensure the "questions" folder exists
+            questions_folder_jbook = os.path.join(self.root_folder, "questions")
+            os.makedirs(questions_folder_jbook, exist_ok=True)
+
+            # Copy the renamed file to the "questions" folder
+            shutil.copy(
+                os.path.join(student_path, question_file_name_sanitized),
+                os.path.join(questions_folder_jbook, question_file_name_sanitized),
+            )
+
+    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(
+                notebook_subfolder,
+                "client_private_key.bin",
+            )
+            server_public_key = os.path.join(
+                notebook_subfolder,
+                "server_public_key.bin",
+            )
+
+            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)
+
+            self.run_otter_assign(
+                temp_notebook_path, os.path.join(notebook_subfolder, "dist")
+            )
+
+            student_notebook = os.path.join(
+                notebook_subfolder, "dist", "student", f"{notebook_name}.ipynb"
+            )
+
+            NotebookProcessor.add_initialization_code(student_notebook)
+
+            self.clean_notebook(student_notebook)
+
+            NotebookProcessor.replace_temp_in_notebook(
+                student_notebook, student_notebook
+            )
+            autograder_notebook = os.path.join(
+                notebook_subfolder, "dist", "autograder", f"{notebook_name}.ipynb"
+            )
+            NotebookProcessor.replace_temp_in_notebook(
+                autograder_notebook, autograder_notebook
+            )
+            shutil.copy(student_notebook, self.root_folder)
+            self._print_and_log(
+                f"Copied and cleaned student notebook: {student_notebook} -> {self.root_folder}"
+            )
+
+            # Remove the keys
+            os.remove(client_private_key)
+            os.remove(server_public_key)
+
+            return student_notebook
+        else:
+            NotebookProcessor.add_initialization_code(temp_notebook_path)
+            return None
+
+    @staticmethod
+    def add_initialization_code(notebook_path):
+        # finds the first code cell
+        index, cell = find_first_code_cell(notebook_path)
+        cell = cell['source']
+        import_text = "from pykubegrader.initialize import initialize_assignment\n"
+        cell = f"{import_text}\n" + cell
+        cell += f'\nresponses = initialize_assignment("{os.path.splitext(os.path.basename(notebook_path))[0]}")\n'
+        replace_cell_source(notebook_path, index, cell)
+
+    def multiple_choice_parser(self, temp_notebook_path, new_notebook_path):
+
         ### Parse the notebook for multiple choice questions
         if self.has_assignment(temp_notebook_path, "# BEGIN MULTIPLE CHOICE"):
             self._print_and_log(
@@ -229,6 +374,11 @@ class NotebookProcessor:
                 data, markers, temp_notebook_path, temp_notebook_path
             )
 
+            return solution_path, question_path
+        else:
+            return None, None
+
+    def true_false_parser(self, temp_notebook_path, new_notebook_path):
         ### Parse the notebook for TF questions
         if self.has_assignment(temp_notebook_path, "# BEGIN TF"):
             markers = ("# BEGIN TF", "# END TF")
@@ -260,6 +410,11 @@ class NotebookProcessor:
                 data, markers, temp_notebook_path, temp_notebook_path
             )
 
+            return solution_path, question_path
+        else:
+            return None, None
+
+    def select_many_parser(self, temp_notebook_path, new_notebook_path):
         ### Parse the notebook for select_many questions
         if self.has_assignment(temp_notebook_path, "# BEGIN SELECT MANY"):
             markers = ("# BEGIN SELECT MANY", "# END SELECT MANY")
@@ -291,86 +446,9 @@ class NotebookProcessor:
                 data, markers, temp_notebook_path, temp_notebook_path
             )
 
-        if self.has_assignment(temp_notebook_path, "# ASSIGNMENT CONFIG"):
-            self.run_otter_assign(
-                temp_notebook_path, os.path.join(notebook_subfolder, "dist")
-            )
-            student_notebook = os.path.join(
-                notebook_subfolder, "dist", "student", f"{notebook_name}.ipynb"
-            )
-            self.clean_notebook(student_notebook)
-            NotebookProcessor.replace_temp_in_notebook(
-                student_notebook, student_notebook
-            )
-            autograder_notebook = os.path.join(
-                notebook_subfolder, "dist", "autograder", f"{notebook_name}.ipynb"
-            )
-            NotebookProcessor.replace_temp_in_notebook(
-                autograder_notebook, autograder_notebook
-            )
-            shutil.copy(student_notebook, self.root_folder)
-            self._print_and_log(
-                f"Copied and cleaned student notebook: {student_notebook} -> {self.root_folder}"
-            )
-
-        # If Otter does not run, move the student file to the main directory
-        if "student_notebook" not in locals():
-            path_ = shutil.copy(temp_notebook_path, self.root_folder)
-            self._print_and_log(
-                f"Copied and cleaned student notebook: {path_} -> {self.root_folder}"
-            )
-
-        # Move the solution file to the autograder folder
-        if "solution_path" in locals():
-            # gets importable file name
-            importable_file_name = sanitize_string(
-                os.path.splitext(os.path.basename(solution_path))[0]
-            )
-
-            # Move the solution file to the autograder folder
-            os.rename(
-                solution_path,
-                os.path.join(autograder_path, f"{importable_file_name}.py"),
-            )
-
-        if "question_path" in locals():
-            shutil.move(question_path, student_path)
-
-        # Remove the temp copy of the notebook
-        os.remove(temp_notebook_path)
-
-        # Remove all postfix from filenames in dist
-        NotebookProcessor.remove_postfix(autograder_path, "_solutions")
-        NotebookProcessor.remove_postfix(student_path, "_questions")
-        NotebookProcessor.remove_postfix(self.root_folder, "_temp")
-
-        ### CODE TO ENSURE THAT STUDENT NOTEBOOK IS IMPORTABLE
-        if "question_path" in locals():
-            # question_root_path = os.path.dirname(question_path)
-            question_file_name = os.path.basename(question_path)
-            question_file_name_sanitized = sanitize_string(
-                question_file_name.replace("_questions", "")
-            )
-            if question_file_name_sanitized.endswith("_py"):
-                question_file_name_sanitized = question_file_name_sanitized[:-3] + ".py"
-
-            # Rename the file
-            os.rename(
-                os.path.join(
-                    student_path, question_file_name.replace("_questions", "")
-                ),
-                os.path.join(student_path, question_file_name_sanitized),
-            )
-
-            # Ensure the "questions" folder exists
-            questions_folder_jbook = os.path.join(self.root_folder, "questions")
-            os.makedirs(questions_folder_jbook, exist_ok=True)
-
-            # Copy the renamed file to the "questions" folder
-            shutil.copy(
-                os.path.join(student_path, question_file_name_sanitized),
-                os.path.join(questions_folder_jbook, question_file_name_sanitized),
-            )
+            return solution_path, question_path
+        else:
+            return None, None
 
     @staticmethod
     def replace_temp_in_notebook(input_file, output_file):
@@ -1475,6 +1553,54 @@ def sanitize_string(input_string):
     return sanitized
 
 
+def find_first_code_cell(notebook_path):
+    """
+    Finds the first Python code cell in a Jupyter notebook and its index.
+
+    Args:
+        notebook_path (str): Path to the Jupyter notebook file.
+
+    Returns:
+        tuple: A tuple containing the index of the first code cell and the cell dictionary,
+            or (None, None) if no code cell is found.
+    """
+    # Load the notebook
+    with open(notebook_path, "r", encoding="utf-8") as f:
+        notebook = nbformat.read(f, as_version=4)
+
+    # Iterate through the cells to find the first code cell
+    for index, cell in enumerate(notebook.get("cells", [])):
+        if cell.get("cell_type") == "code":
+            return index, cell  # Return the index and the first code cell
+
+    return None, None  # No code cell found
+
+
+def replace_cell_source(notebook_path, cell_index, new_source):
+        """
+        Replace the source code of a specific Jupyter notebook cell.
+
+        Args:
+            cell_index (int): Index of the cell to be modified (0-based).
+            new_source (str): New source code to replace the cell's content.
+        """
+        # Load the notebook
+        with open(notebook_path, "r", encoding="utf-8") as f:
+            notebook = nbformat.read(f, as_version=4)
+
+        # Check if the cell index is valid
+        if cell_index >= len(notebook.cells) or cell_index < 0:
+            raise IndexError(
+                f"Cell index {cell_index} is out of range for this notebook."
+            )
+
+        # Replace the source code of the specified cell
+        notebook.cells[cell_index]["source"] = new_source
+
+        # Save the notebook
+        with open(notebook_path, "w", encoding="utf-8") as f:
+            nbformat.write(notebook, f)
+
 def main():
     parser = argparse.ArgumentParser(
         description="Recursively process Jupyter notebooks with '# ASSIGNMENT CONFIG', move them to a solutions folder, and run otter assign."

pykubegrader/initialize.py

@@ -1,13 +1,18 @@
 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
 
-from .telemetry import telemetry, update_responses
 
 
-def initialize_assignment(name: str) -> None:
+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?")
@@ -25,17 +30,39 @@ def initialize_assignment(name: str) -> None:
         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)
 
-        seed = hash(jhub_user) % 1000
-        update_responses(key="seed", value=seed)
     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")
-    print(f"Assignment: {name}")
-    print(f"Username: {jhub_user}")
+    return responses

pykubegrader/telemetry.py

@@ -3,6 +3,7 @@ import datetime
 import json
 import logging
 import os
+from typing import Optional
 
 import nacl.public
 import requests
@@ -35,19 +36,20 @@ def encrypt_to_b64(message: str) -> str:
 
 
 def ensure_responses() -> dict:
+
     with open(".responses.json", "a") as _:
         pass
 
-    data = {}
+    responses = {}
 
     try:
         with open(".responses.json", "r") as f:
-            data = json.load(f)
+            responses = json.load(f)
     except json.JSONDecodeError:
         with open(".responses.json", "w") as f:
-            json.dump(data, f)
-
-    return data
+            json.dump(responses, f)
+    
+    return responses
 
 
 def log_encrypted(message: str) -> None:
@@ -94,12 +96,13 @@ def update_responses(key: str, value) -> dict:
 #
 
 
+# If we instead call this with **responses
 def score_question(
     student_email: str,
-    term: str,
     assignment: str,
     question: str,
     submission: str,
+    term: str = "winter_2025",
     base_url: str = "https://engr-131-api.eastus.cloudapp.azure.com/",
 ) -> Response:
     url = base_url + "/live-scorer"
@@ -140,3 +143,20 @@ def submit_question_new(
     res = requests.post(url, json=payload, auth=HTTPBasicAuth("student", "capture"))
 
     return res
+
+
+# TODO: refine function
+def verify_server(
+    jhub_user: Optional[str] = None,
+    url: str = "https://engr-131-api.eastus.cloudapp.azure.com/",
+) -> str:
+    params = {"jhub_user": jhub_user} if jhub_user else {}
+    res = requests.get(url, params=params)
+    message = f"status code: {res.status_code}"
+    return message
+
+
+# TODO: implement function; or maybe not?
+# At least improve other one
+def score_question_improved(question_name: str, responses: dict) -> dict:
+    return {}

pykubegrader/validate.py

@@ -10,6 +10,10 @@ import numpy as np
 import requests
 from requests.auth import HTTPBasicAuth
 
+#
+# Primary function
+#
+
 
 def validate_logfile(
     filepath: str,
@@ -18,59 +22,54 @@ def validate_logfile(
     free_response_questions=0,
     username="student",
     password="capture",
-    post_url="https://engr-131-api.eastus.cloudapp.azure.com/upload-score",
-    login_url="https://engr-131-api.eastus.cloudapp.azure.com/login",
+    base_url="https://engr-131-api.eastus.cloudapp.azure.com",
 ) -> None:
     login_data = {
         "username": username,
         "password": password,
     }
 
-    with open("server_private_key.bin", "rb") as priv_file:
-        server_private_key_bytes = priv_file.read()
-    server_priv_key = nacl.public.PrivateKey(server_private_key_bytes)
-
-    with open("client_public_key.bin", "rb") as pub_file:
-        client_public_key_bytes = pub_file.read()
-    client_pub_key = nacl.public.PublicKey(client_public_key_bytes)
-
-    box = nacl.public.Box(server_priv_key, client_pub_key)
+    # Generate box from private and public keys
+    key_box = generate_keys()
 
     with open(filepath, "r") as logfile:
         encrypted_lines = logfile.readlines()
 
-    data_: list[str] = []
+    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 = box.decrypt(decoded).decode()
-            data_.append(decrypted)
+            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(data_)
+    # _loginfo = str(decrypted_log)
 
     # Where possible, we should work with this reduced list of relevant entries
-    data_reduced = [
+    # Here we take only lines with student info or question scores
+    log_reduced = [
         entry
-        for entry in data_
+        for entry in decrypted_log
         if re.match(r"info,", entry) or re.match(r"q\d+_\d+,", entry)
     ]
 
     # For debugging; to be commented out
-    with open(".output_reduced.log", "w") as f:
-        f.writelines(f"{item}\n" for item in data_reduced)
+    # with open(".output_reduced.log", "w") as f:
+    #     f.writelines(f"{item}\n" for item in log_reduced)
 
-    # Initialize the question scores and max scores
-    question_max_scores = question_max_scores
+    # Initialize question scores based on max scores
     question_scores = {key: 0 for key in question_max_scores}
 
-    # Parsing the data to find the last entries for required fields
+    # Iterate over log to find the last entries for student info fields
     # This gets the student name etc.
     last_entries: dict[str, str | float] = {}
-    for entry in data_reduced:
+    for entry in log_reduced:
+        # Split on commas and strip whitespace
         parts = [part.strip() for part in entry.split(",")]
+
+        # This just overwrites, so the last iteration sticks
         if parts[0] == "info" and len(parts) == 4:
             field_name = parts[1]
             field_value = parts[2]
@@ -85,35 +84,29 @@ def validate_logfile(
             "Your log file is not for the correct assignment. Please submit the correct log file."
         )
 
+    # TODO: Revisit this; we may no longer require as much info
     required_student_info = ["drexel_id", "first_name", "last_name", "drexel_email"]
-
     for field in required_student_info:
         if last_entries.get(field) is None:
-            sys.exit(
-                "You must submit your student information before you start the exam. Please submit your information and try again."
-            )
+            sys.exit("Missing required student information")
 
     # Initialize code and data lists
-    code: list[str] = []
-    data: list[str] = []
+    log_execution: list[str] = []
+    log_data: list[str] = []
 
     # Splitting the data into code and responses
-    for entry in data_:
+    for entry in decrypted_log:
         # Splitting the data into code and responses
         if "code run:" in entry:
-            code.append(entry)
+            log_execution.append(entry)
         else:
-            data.append(entry)
-
-    # Checks to see if the drexel_jupyter_logger is in the code
-    # If it is, the student might have tried to look at the solutions
-    # Commenting this out, since we're switching to asymmetric encryption
-    # flag = any("drexel_jupyter_logger" in item for item in code)
+            log_data.append(entry)
 
     # Extracting timestamps and converting them to datetime objects
+    # TODO: Check why we're using log_reduced instead of decrypted_log
     timestamps = [
         datetime.strptime(row.split(",")[-1].strip(), "%Y-%m-%d %H:%M:%S")
-        for row in data_reduced
+        for row in log_reduced
     ]
 
     # Getting the earliest and latest times
@@ -122,51 +115,20 @@ def validate_logfile(
     delta = max(timestamps) - min(timestamps)
     minutes_rounded = round(delta.total_seconds() / 60, 2)
     last_entries["elapsed_minutes"] = minutes_rounded
-    # last_entries["flag"] = flag
 
     # Collect student info dict
-    student_information = {key.upper(): value for key, value in last_entries.items()}
+    student_info = {key.upper(): value for key, value in last_entries.items()}
 
     # Write info dict to info.json
+    # TODO: Try/except block here?
     with open("info.json", "w") as file:
-        print("Writing to info.json")
-        json.dump(student_information, file)
-
-    def get_last_entry(data: list[str], field_name: str) -> str:
-        for entry in data[::-1]:
-            parts = [part.strip() for part in entry.split(",")]
-            if parts[0] == field_name:
-                return entry
-        return ""
-
-    def get_entries_len(data: list[str], question_number: int) -> int:
-        """function to get the unique entries by length
-
-        Args:
-            data (list): list of all the data records
-            question_number (int): question number to evaluate
-
-        Returns:
-            int: length of the unique entries
-        """
-
-        # Set for unique qN_* values
-        unique_qN_values = set()
-
-        for entry in data:
-            if entry.startswith(f"q{question_number}_"):
-                # Split the string by commas and get the value part
-                parts = [part.strip() for part in entry.split(",")]
-                # The value is the third element after splitting (?)
-                value = parts[0].split("_")[1]
-                unique_qN_values.add(value)
-
-        return len(unique_qN_values) + 1
+        # print("Writing to info.json")
+        json.dump(student_info, file)
 
     # Modified list comprehension to filter as per the criteria
     free_response = [
         entry
-        for entry in data_
+        for entry in log_reduced
         if entry.startswith("q")
         and entry.split("_")[0][1:].isdigit()
         and int(entry.split("_")[0][1:]) > free_response_questions
@@ -180,8 +142,8 @@ def validate_logfile(
         # Collect entries for each question in a list.
         entries = [
             entry
-            for j in range(1, get_entries_len(data, i))
-            if (entry := get_last_entry(data, f"q{i}_{j}")) != ""
+            for j in range(1, get_entries_len(log_data, i))
+            if (entry := get_last_entry(log_data, f"q{i}_{j}")) != ""
         ]
 
         # Store the list of entries in the dictionary, keyed by question number.
@@ -246,6 +208,7 @@ def validate_logfile(
         print("Writing to results.json")
         json.dump(result_structure, file, indent=4)
 
+    login_url = f"{base_url}/login"
     verify_login(login_data, login_url)
 
     # The file to be uploaded. Ensure the path is correct.
@@ -269,6 +232,8 @@ def validate_logfile(
         "file": (file_path, open(file_path, "rb")),
     }
 
+    post_url = f"{base_url}/upload-score"
+
     # Make the POST request with data and files
     response = requests.post(
         url=post_url,
@@ -286,6 +251,53 @@ def validate_logfile(
 #
 
 
+def generate_keys() -> nacl.public.Box:
+    with open("server_private_key.bin", "rb") as priv_file:
+        server_private_key_bytes = priv_file.read()
+    server_priv_key = nacl.public.PrivateKey(server_private_key_bytes)
+
+    with open("client_public_key.bin", "rb") as pub_file:
+        client_public_key_bytes = pub_file.read()
+    client_pub_key = nacl.public.PublicKey(client_public_key_bytes)
+
+    box = nacl.public.Box(server_priv_key, client_pub_key)
+
+    return box
+
+
+def get_entries_len(data: list[str], question_number: int) -> int:
+    """function to get the unique entries by length
+
+    Args:
+        data (list): list of all the data records
+        question_number (int): question number to evaluate
+
+    Returns:
+        int: length of the unique entries
+    """
+
+    # Set for unique qN_* values
+    unique_qN_values = set()
+
+    for entry in data:
+        if entry.startswith(f"q{question_number}_"):
+            # Split the string by commas and get the value part
+            parts = [part.strip() for part in entry.split(",")]
+            # The value is the third element after splitting (?)
+            value = parts[0].split("_")[1]
+            unique_qN_values.add(value)
+
+    return len(unique_qN_values) + 1
+
+
+def get_last_entry(data: list[str], field_name: str) -> str:
+    for entry in data[::-1]:
+        parts = [part.strip() for part in entry.split(",")]
+        if parts[0] == field_name:
+            return entry
+    return ""
+
+
 def submission_message(response) -> None:
     if response.status_code == 200:
         print("Data successfully uploaded to the server")