PyKubeGrader 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

{PyKubeGrader-0.3.3.dist-info → PyKubeGrader-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyKubeGrader
-Version: 0.3.3
+Version: 0.3.5
 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.3.dist-info → PyKubeGrader-0.3.5.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=2xNo2r4uhjNBIWfZBHviARgxE81t_tL4yaVMEZJoPyQ,7928
+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/api_notebook_builder.py,sha256=320aFB1-6KLQt0OMmKD0FJtE17JKZaK5neA0mTD-Y8M,22960
 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
@@ -28,12 +29,12 @@ pykubegrader/widgets/style.py,sha256=fVBMYy_a6Yoz21avNpiORWC3f5FD-OrVpaZ3npmunvs
 pykubegrader/widgets/true_false.py,sha256=QllIhHuJstJft_RuShkxI_fFFTaDAlzNZOFNs00HLIM,2842
 pykubegrader/widgets/types_question.py,sha256=kZdRRXyFzOtYTmGdC7XWb_2oaxqg1WSuLcQn_sTj6Qc,2300
 pykubegrader/widgets_base/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pykubegrader/widgets_base/multi_select.py,sha256=JgjhHQJL8Pf0-1T_wdZCecAK1IgVJrZBCbR6b3jvDtk,4181
+pykubegrader/widgets_base/multi_select.py,sha256=KtfAP0PyEbcjWlKNpI5_5-PLMtcUbbNX0Es_-w-H34Q,4226
 pykubegrader/widgets_base/reading.py,sha256=ChUS3NOTa_HLtNpxR8hGX80LPKMvYMypnR6dFknfxus,5430
-pykubegrader/widgets_base/select.py,sha256=tEDg7GEjsZnz1646YTthTeamujVRS5jDJWMsXhmOQbI,2705
-PyKubeGrader-0.3.3.dist-info/LICENSE.txt,sha256=YTp-Ewc8Kems8PJEE27KnBPFnZSxoWvSg7nnknzPyYw,1546
-PyKubeGrader-0.3.3.dist-info/METADATA,sha256=7d5qLOoTobGzMNyp0D8s2uKq1gRrL0bQowsGcOqFJSg,2806
-PyKubeGrader-0.3.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-PyKubeGrader-0.3.3.dist-info/entry_points.txt,sha256=BbLXpFZObpOXA8e3p3GcFkL-sHdUnDLUcnYmc6zx3NI,201
-PyKubeGrader-0.3.3.dist-info/top_level.txt,sha256=e550Klfze6higFxER1V62fnGOcIgiKRbsrl9CC4UdtQ,13
-PyKubeGrader-0.3.3.dist-info/RECORD,,
+pykubegrader/widgets_base/select.py,sha256=uMncmVIqjvJkffMQY1L_PokrFCidK1PeVITX0i70fho,2750
+PyKubeGrader-0.3.5.dist-info/LICENSE.txt,sha256=YTp-Ewc8Kems8PJEE27KnBPFnZSxoWvSg7nnknzPyYw,1546
+PyKubeGrader-0.3.5.dist-info/METADATA,sha256=a5vrrGdf4XTTSfKPAuQ-2HaHISFczwu6uSy6KkrrQv4,2729
+PyKubeGrader-0.3.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+PyKubeGrader-0.3.5.dist-info/entry_points.txt,sha256=RR57KvzDRJrP4omy5heS5cZ3E7g56YxcxJhDnp57ZU0,253
+PyKubeGrader-0.3.5.dist-info/top_level.txt,sha256=e550Klfze6higFxER1V62fnGOcIgiKRbsrl9CC4UdtQ,13
+PyKubeGrader-0.3.5.dist-info/RECORD,,

{PyKubeGrader-0.3.3.dist-info → PyKubeGrader-0.3.5.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/api_notebook_builder.py

@@ -5,6 +5,8 @@ import shutil
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional
+import base64
+from typing import Any, Optional
 
 import nbformat
 
@@ -16,14 +18,14 @@ class FastAPINotebookBuilder:
     assignment_tag: Optional[str] = ""
     require_key: Optional[bool] = False
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         self.root_path, self.filename = FastAPINotebookBuilder.get_filename_and_root(
             self.notebook_path
         )
         self.total_points = 0
         self.run()
 
-    def run(self):
+    def run(self) -> None:
         # here for easy debugging
         if self.temp_notebook is not None:
             shutil.copy(
@@ -36,7 +38,46 @@ class FastAPINotebookBuilder:
         self.assertion_tests_dict = self.question_dict()
         self.add_api_code()
 
+    @staticmethod
+    def conceal_tests(cell_source):
+        """
+        Takes a list of code lines, detects blocks between `# BEGIN HIDE` and `# END HIDE`,
+        encodes them in Base64, and replaces them with an `exec()` statement.
+
+        Returns a new list of lines with the concealed blocks.
+        """
+
+        concealed_lines = []
+        hide_mode = False
+        hidden_code = []
+
+        for line in cell_source:
+            if "# BEGIN HIDE" in line:
+                hide_mode = True
+                hidden_code = []  # Start a new hidden block
+                concealed_lines.append(line)  # Keep the marker for clarity
+                continue
+            elif "# END HIDE" in line:
+                hide_mode = False
+                # Encode the entire block
+                encoded_block = base64.b64encode(
+                    "\n".join(hidden_code).encode()
+                ).decode()
+                concealed_lines.append(
+                    f'exec(base64.b64decode("{encoded_block}").decode())  # Obfuscated\n'
+                )
+                concealed_lines.append(line)  # Keep the marker for clarity
+                continue
+
+            if hide_mode:
+                hidden_code.append(line.strip())  # Collect hidden code
+            else:
+                concealed_lines.append(line)
+
+        return concealed_lines
+
     def add_api_code(self):
+    def add_api_code(self) -> None:
         self.compute_max_points_free_response()
 
         for i, (cell_index, cell_dict) in enumerate(self.assertion_tests_dict.items()):
@@ -48,6 +89,8 @@ class FastAPINotebookBuilder:
             cell_source = FastAPINotebookBuilder.add_import_statements_to_tests(
                 cell["source"]
             )
+            
+            cell_source = FastAPINotebookBuilder.conceal_tests(cell_source)
 
             last_import_line_ind = FastAPINotebookBuilder.find_last_import_line(
                 cell_source
@@ -94,7 +137,7 @@ class FastAPINotebookBuilder:
 
             self.replace_cell_source(cell_index, updated_cell_source)
 
-    def compute_max_points_free_response(self):
+    def compute_max_points_free_response(self) -> None:
         for cell_dict in self.assertion_tests_dict.values():
             # gets the question name from the first cell to not double count
             if cell_dict["is_first"]:
@@ -107,7 +150,7 @@ class FastAPINotebookBuilder:
 
                 self.total_points += max_question_points
 
-    def construct_first_cell_question_header(self, cell_dict):
+    def construct_first_cell_question_header(self, cell_dict: dict) -> list[str]:
         max_question_points = sum(
             cell["points"]
             for cell in self.assertion_tests_dict.values()
@@ -136,7 +179,7 @@ class FastAPINotebookBuilder:
         return first_cell_header
 
     @staticmethod
-    def construct_update_responses(cell_dict):
+    def construct_update_responses(cell_dict: dict) -> list[str]:
         update_responses = []
 
         logging_variables = cell_dict["logging_variables"]
@@ -149,7 +192,9 @@ class FastAPINotebookBuilder:
         return update_responses
 
     @staticmethod
-    def split_list_at_marker(input_list, marker="""# END TEST CONFIG"""):
+    def split_list_at_marker(
+        input_list: list[str], marker: str = """# END TEST CONFIG"""
+    ) -> tuple[list[str], list[str]]:
         """
         Splits a list into two parts at the specified marker string.
 
@@ -172,7 +217,7 @@ class FastAPINotebookBuilder:
             )  # If the marker is not in the list, return the original list and an empty list
 
     @staticmethod
-    def construct_graders(cell_dict):
+    def construct_graders(cell_dict: dict) -> list[str]:
         # Generate Python code
         added_code = [
             "if "
@@ -184,7 +229,7 @@ class FastAPINotebookBuilder:
         return added_code
 
     @staticmethod
-    def construct_question_info(cell_dict):
+    def construct_question_info(cell_dict: dict) -> list[str]:
         question_info = []
 
         question_id = cell_dict["question"] + "-" + str(cell_dict["test_number"])
@@ -197,8 +242,12 @@ class FastAPINotebookBuilder:
 
     @staticmethod
     def insert_list_at_index(
-        original_list, insert_list, index, line_break=True, inplace_line_break=True
-    ):
+        original_list: list[str],
+        insert_list: list[str],
+        index: int,
+        line_break: bool = True,
+        inplace_line_break: bool = True,
+    ) -> list[str]:
         """
         Inserts a list into another list at a specific index.
 
@@ -223,7 +272,7 @@ class FastAPINotebookBuilder:
         return original_list[:index] + insert_list + original_list[index:]
 
     @staticmethod
-    def add_import_statements_to_tests(cell_source):
+    def add_import_statements_to_tests(cell_source: list[str]) -> list[str]:
         """
         Adds the necessary import statements to the first cell of the notebook.
         """
@@ -241,6 +290,7 @@ class FastAPINotebookBuilder:
             "    update_responses,\n",
             ")\n",
             "import os\n",
+            "import base64\n",
         ]
 
         for i, line in enumerate(cell_source):
@@ -251,7 +301,12 @@ class FastAPINotebookBuilder:
                 ] + imports  # Add a blank line for readability
                 return cell_source  # Exit the loop once the imports are inserted
 
-    def extract_first_cell(self):
+        raise ValueError("End of test configuration not found")
+
+    # TODO: `Any` return not good; would be better to specify return type(s)
+    def extract_first_cell(self) -> Any:
+        if not self.temp_notebook:
+            raise ValueError("No temporary notebook file path provided")
         with open(self.temp_notebook, "r", encoding="utf-8") as f:
             notebook = json.load(f)
         if "cells" in notebook and len(notebook["cells"]) > 0:
@@ -260,13 +315,16 @@ class FastAPINotebookBuilder:
             return None
 
     @staticmethod
-    def get_filename_and_root(path):
+    def get_filename_and_root(path: str) -> tuple[Path, str]:
         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):
+    # TODO: `Any` return not good; would be better to specify return type(s)
+    def get_cell(self, cell_index: int) -> Any:
+        if not self.temp_notebook:
+            raise ValueError("No temporary notebook file path provided")
         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:
@@ -274,7 +332,7 @@ class FastAPINotebookBuilder:
         else:
             return None
 
-    def replace_cell_source(self, cell_index, new_source):
+    def replace_cell_source(self, cell_index: int, new_source: str | list[str]) -> None:
         """
         Replace the source code of a specific Jupyter notebook cell.
 
@@ -283,6 +341,8 @@ class FastAPINotebookBuilder:
             new_source (str): New source code to replace the cell's content.
         """
         # Load the notebook
+        if not self.temp_notebook:
+            raise ValueError("No temporary notebook file path provided")
         with open(self.temp_notebook, "r", encoding="utf-8") as f:
             notebook = nbformat.read(f, as_version=4)
 
@@ -301,7 +361,7 @@ class FastAPINotebookBuilder:
         print(f"Updated notebook saved to {self.temp_notebook}")
 
     @staticmethod
-    def find_last_import_line(cell_source):
+    def find_last_import_line(cell_source: list[str]) -> int:
         """
         Finds the index of the last line with an import statement in a list of code lines,
         including multiline import statements.
@@ -339,7 +399,7 @@ class FastAPINotebookBuilder:
         return last_import_index
 
     @staticmethod
-    def extract_log_variables(cell):
+    def extract_log_variables(cell: dict) -> list[str]:
         """Extracts log variables from the first cell."""
         if "source" in cell:
             for line in cell["source"]:
@@ -355,7 +415,8 @@ class FastAPINotebookBuilder:
                         pass
         return []
 
-    def tag_questions(cells_dict):
+    @staticmethod
+    def tag_questions(cells_dict: dict) -> 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.
@@ -377,7 +438,7 @@ class FastAPINotebookBuilder:
                 raise KeyError(f"Cell {key} is missing the 'question' key.")
 
         # Group the keys by question name
-        question_groups = {}
+        question_groups: dict = {}
         for key, cell in cells_dict.items():
             question = cell.get(
                 "question"
@@ -397,7 +458,9 @@ class FastAPINotebookBuilder:
 
         return cells_dict
 
-    def question_dict(self):
+    def question_dict(self) -> dict:
+        if not self.temp_notebook:
+            raise ValueError("No temporary notebook file path provided")
         notebook_path = Path(self.temp_notebook)
         if not notebook_path.exists():
             raise FileNotFoundError(f"The file {notebook_path} does not exist.")
@@ -406,15 +469,14 @@ class FastAPINotebookBuilder:
             notebook = json.load(f)
 
         results_dict = {}
+        question_name = None  # At least define the variable up front
 
         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
-                    )
+                    name_match = re.search(r"name:\s*(.*)", source)
+                    question_name = name_match.group(1).strip() if name_match else None
 
             elif cell.get("cell_type") == "code":
                 source = "".join(cell.get("source", ""))

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

@@ -10,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
 
 #
@@ -206,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:
@@ -283,3 +289,142 @@ def upload_execution_log() -> None:
     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

pykubegrader/widgets_base/multi_select.py

@@ -2,6 +2,7 @@ import time
 from typing import Callable, Optional, Tuple
 
 import panel as pn
+import numpy as np
 
 from ..telemetry import ensure_responses, score_question, update_responses
 from ..utils import shuffle_options, shuffle_questions
@@ -70,7 +71,7 @@ class MultiSelectQuestion:
 
         # Panel layout
         question_header = pn.pane.HTML(
-            f"<h2>Question {self.question_number}: {title}</h2>"
+            f"<h2>Question {self.question_number} (Points {np.sum(points)}): {title}</h2>"
         )
 
         question_body = pn.Column(

pykubegrader/widgets_base/select.py

@@ -2,6 +2,7 @@ import time
 from typing import Callable, Optional, Tuple
 
 import panel as pn
+import numpy as np
 
 from ..telemetry import ensure_responses, score_question, update_responses
 from ..utils import shuffle_options, shuffle_questions
@@ -57,7 +58,7 @@ class SelectQuestion:
         widget_pairs = shuffle_questions(desc_widgets, self.widgets, seed)
 
         self.layout = pn.Column(
-            f"# Question {self.question_number}: {title}",
+            f"# Question {self.question_number} (Points {np.sum(points)}): {title}",
             *(
                 pn.Column(desc_widget, pn.Row(dropdown))
                 for desc_widget, dropdown in widget_pairs