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

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

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

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

@@ -1,12 +1,12 @@
 pykubegrader/__init__.py,sha256=AoAkdfIjDDZGWLlsIRENNq06L9h46kDGBIE8vRmsCfg,311
 pykubegrader/grading_tester.ipynb,sha256=wwT9jyhpR6GGM8r4todaGfrsUxS6JxM0qIqMcDYKM7w,18839
 pykubegrader/initialize.py,sha256=Bwu1q18l18FB9lGppvt-L41D5gzr3S8t6zC0_UbrASw,3994
-pykubegrader/telemetry.py,sha256=ooLK-dY_hJQ7t4r83hWyO8wx6F_7TfWJS7tCp_nH7r8,13049
+pykubegrader/telemetry.py,sha256=vZK9p3XqnqacwtiVyZgjI2mcIr5ZcxRRwW5sAZsrJkE,16631
 pykubegrader/utils.py,sha256=jlJklKvRhY3O7Hz2aaU1m0y3p_n9eMAXNnAF7LUEaPY,1275
 pykubegrader/validate.py,sha256=OKnItGyd-L8QPKcsE0KRuwBI_IxKiJzMLJKZiA2j3II,11184
 pykubegrader/build/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pykubegrader/build/api_notebook_builder.py,sha256=dlcVrGgsvxnt6GlAUN3e-FrpsPNJKXSHni1fstRCBik,20311
-pykubegrader/build/build_folder.py,sha256=Asc-VdhXgxQfOfFIWJShhXrF2EITJOIZQ5Dz_2y-P2I,85358
+pykubegrader/build/api_notebook_builder.py,sha256=EZG4Ow4YATzOWPPNLkdQEdWt7hkpbaI5ZD1Bf2KEWeY,25622
+pykubegrader/build/build_folder.py,sha256=9aewc4dcYKS5kNaDS3gTwCnzRTmHT6Ooio5TF258q_8,86963
 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
@@ -17,8 +17,9 @@ pykubegrader/log_parser/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YB
 pykubegrader/log_parser/parse.ipynb,sha256=5e-9dzUbJk2M8kPP55lVeksm86lSY5ocKfWOP2RSWH0,11921
 pykubegrader/log_parser/parse.py,sha256=dXzTEOTI6VTRNoHFDAjg6hZUhvB3kHtMb10_KW3NPrw,7641
 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/tokens/token_panel.py,sha256=NNA5ZV3Q9jB_lz2aSwMyViXV0ESu6V_7T92Qji7UpSQ,1377
+pykubegrader/tokens/tokens.py,sha256=qcYMFgNPimbfeS7lXOtbgquGgeJCgOGx5hvXewIs0oQ,1474
+pykubegrader/tokens/validate_token.py,sha256=kvHX0NJBm21xzb2p67j7vq1La6J1XbmobEJQ3fTMdZA,3289
 pykubegrader/widgets/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 pykubegrader/widgets/multiple_choice.py,sha256=ag6W-HN7isHkIUmB4BxtK8T1JhuV3FBLUBAhcV6rN80,2729
 pykubegrader/widgets/question_processor.py,sha256=fFH2ffMPYAJHsDn1RweEBnibfoZlSvTANUxYT3EPb5w,1375
@@ -29,12 +30,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.4.dist-info/LICENSE.txt,sha256=YTp-Ewc8Kems8PJEE27KnBPFnZSxoWvSg7nnknzPyYw,1546
-PyKubeGrader-0.3.4.dist-info/METADATA,sha256=6aq3PWnDPR8lNxPMmWvDkbd2GvZNfLkpYNcpOLSbHqc,2729
-PyKubeGrader-0.3.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-PyKubeGrader-0.3.4.dist-info/entry_points.txt,sha256=RR57KvzDRJrP4omy5heS5cZ3E7g56YxcxJhDnp57ZU0,253
-PyKubeGrader-0.3.4.dist-info/top_level.txt,sha256=e550Klfze6higFxER1V62fnGOcIgiKRbsrl9CC4UdtQ,13
-PyKubeGrader-0.3.4.dist-info/RECORD,,
+pykubegrader/widgets_base/select.py,sha256=uMncmVIqjvJkffMQY1L_PokrFCidK1PeVITX0i70fho,2750
+PyKubeGrader-0.3.6.dist-info/LICENSE.txt,sha256=YTp-Ewc8Kems8PJEE27KnBPFnZSxoWvSg7nnknzPyYw,1546
+PyKubeGrader-0.3.6.dist-info/METADATA,sha256=RVMHbbz9895jEBhpogU7TM5keqyf-kUKhKJhJ1Hk168,2729
+PyKubeGrader-0.3.6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+PyKubeGrader-0.3.6.dist-info/entry_points.txt,sha256=RR57KvzDRJrP4omy5heS5cZ3E7g56YxcxJhDnp57ZU0,253
+PyKubeGrader-0.3.6.dist-info/top_level.txt,sha256=e550Klfze6higFxER1V62fnGOcIgiKRbsrl9CC4UdtQ,13
+PyKubeGrader-0.3.6.dist-info/RECORD,,

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
 
@@ -15,15 +17,18 @@ class FastAPINotebookBuilder:
     temp_notebook: Optional[str] = None
     assignment_tag: Optional[str] = ""
     require_key: Optional[bool] = False
+    verbose: 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.max_question_points = {}
         self.run()
 
-    def run(self):
+    def run(self) -> None:
         # here for easy debugging
         if self.temp_notebook is not None:
             shutil.copy(
@@ -36,25 +41,74 @@ class FastAPINotebookBuilder:
         self.assertion_tests_dict = self.question_dict()
         self.add_api_code()
 
-    def add_api_code(self):
+        # add the point total to the end of the notebook
+        self.add_total_points_to_notebook()
+
+    @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) -> None:
         self.compute_max_points_free_response()
+        for i, question in enumerate(self.max_question_points.keys()):
+            index, source = self.find_question_description(question)
+            try:
+                modified_source  = FastAPINotebookBuilder.add_text_after_double_hash(source, f"Question {i+1} (Points: {self.max_question_points[question]}):")
+                self.replace_cell_source(index, modified_source)
+            except:
+                pass
 
         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)}"
-            )
+            if self.verbose: 
+                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"]
+                cell["source"], require_key=self.require_key,
             )
 
+            cell_source = FastAPINotebookBuilder.conceal_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"]:
@@ -92,22 +146,69 @@ class FastAPINotebookBuilder:
                 FastAPINotebookBuilder.construct_update_responses(cell_dict)
             )
 
-            self.replace_cell_source(cell_index, updated_cell_source)
+            self.replace_cell_source(cell_index, updated_cell_source)   
 
-    def compute_max_points_free_response(self):
-        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"]:
-                # get the max points for the question
-                max_question_points = sum(
+    def find_question_description(self, search_string):
+        with open(self.temp_notebook, 'r', encoding='utf-8') as f:
+            nb_data = json.load(f)
+
+        found_raw = False
+
+        for idx, cell in enumerate(nb_data.get("cells", [])):
+            if cell["cell_type"] == "raw" and any("# BEGIN QUESTION" in line for line in cell.get("source", [])) and any(search_string in line for line in cell.get("source", [])):
+                found_raw = True
+            elif found_raw and cell["cell_type"] == "markdown":
+                return idx, cell.get("source", [])  # Return the index of the first matching markdown cell
+
+        return None, None  # Return None if no such markdown cell is found 
+
+    def add_total_points_to_notebook(self) -> None:
+        self.max_question_points.keys()
+
+    def get_max_question_points(self, cell_dict) -> float:
+        return sum(
                     cell["points"]
                     for cell in self.assertion_tests_dict.values()
                     if cell["question"] == cell_dict["question"]
                 )
 
+    @staticmethod
+    def add_text_after_double_hash(markdown_source, insert_text):
+        """
+        Adds insert_text immediately after the first '##' in the first line that starts with '##'.
+        
+        Args:
+        - markdown_source (list of str): The list of lines in the markdown cell.
+        - insert_text (str): The text to be inserted.
+        
+        Returns:
+        - list of str: The modified markdown cell content.
+        """
+        modified_source = []
+        inserted = False
+
+        for line in markdown_source:
+            if not inserted and line.startswith("## "):
+                modified_source.append(f"## {insert_text} {line[3:]}")  # Insert text after '##'
+                inserted = True  # Ensure it only happens once
+            else:
+                modified_source.append(line)
+
+        return modified_source
+
+    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"]:
+                # get the max points for the question
+                max_question_points = self.get_max_question_points(cell_dict)
+
+                # store the max points for the question
+                self.max_question_points[f"{cell_dict["question"]}"] = max_question_points
+
                 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 +237,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 +250,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 +275,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 +287,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 +300,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 +330,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], require_key:bool = False) -> list[str]:
         """
         Adds the necessary import statements to the first cell of the notebook.
         """
@@ -241,8 +348,14 @@ class FastAPINotebookBuilder:
             "    update_responses,\n",
             ")\n",
             "import os\n",
+            "import base64\n",
         ]
 
+        if require_key:
+            imports.append(
+                "from pykubegrader.tokens.validate_token import validate_token\nvalidate_token()\n"
+            )
+
         for i, line in enumerate(cell_source):
             if end_test_config_line in line:
                 # Insert the imports immediately after the current line
@@ -251,7 +364,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 +378,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 +395,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 +404,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 +424,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 +462,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 +478,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 +501,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 +521,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 +532,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/build_folder.py

@@ -77,15 +77,21 @@ class NotebookProcessor:
                 data = yaml.safe_load(file)
                 # Extract assignment details
                 assignment = data.get("assignment", {})
-                week_num = assignment.get("week")
+                self.week_num = assignment.get("week")
                 self.assignment_type = assignment.get("assignment_type")
                 self.bonus_points = assignment.get("bonus_points", 0)
+                self.require_key = assignment.get("require_key", False)
+                self.assignment_tag = assignment.get(
+                    "assignment_tag",
+                    f"week{assignment.get("week")}-{self.assignment_type}",
+                )
         else:
             self.assignment_type = self.assignment_tag.split("-")[0].lower()
-            week_num = self.assignment_tag.split("-")[-1]
+            self.week_num = self.assignment_tag.split("-")[-1]
+            self.assignment_tag = f"week{self.week_num}-{self.assignment_type}"
 
-        self.week_num = week_num
-        self.week = f"week_{week_num}"
+        # self.week_num = week_num
+        self.week = f"week_{self.week_num}"
 
         # Define the folder to store solutions and ensure it exists
         self.solutions_folder = os.path.join(self.root_folder, "_solutions")
@@ -179,12 +185,12 @@ class NotebookProcessor:
 
     def update_initialize_function(self):
         for key, value in self.total_point_log.items():
-            assignment_tag = f"week{self.week_num}-{self.assignment_type}"
+            # assignment_tag = f"week{self.week_num}-{self.assignment_type}"
 
             update_initialize_assignment(
                 notebook_path=os.path.join(self.root_folder, key + ".ipynb"),
                 assignment_points=value,
-                assignment_tag=assignment_tag,
+                assignment_tag=self.assignment_tag,
             )
 
     def build_payload(self, yaml_content):
@@ -578,17 +584,17 @@ class NotebookProcessor:
             code_cell = nbformat.v4.new_code_cell(
                 f"{validate_token_line}\n\n"  # Add the validate_token() line
                 "from pykubegrader.submit.submit_assignment import submit_assignment\n\n"
-                f'submit_assignment("week{self.week_num}-{self.assignment_type}", "{os.path.basename(notebook_path).replace(".ipynb", "")}")'
+                f'submit_assignment("{self.assignment_tag}", "{os.path.basename(notebook_path).replace(".ipynb", "")}")'
             )
         else:
             # Define the Code cell without validate_token()
             code_cell = nbformat.v4.new_code_cell(
                 "from pykubegrader.submit.submit_assignment import submit_assignment\n\n"
-                f'submit_assignment("week{self.week_num}-{self.assignment_type}", "{os.path.basename(notebook_path).replace(".ipynb", "")}")'
+                f'submit_assignment("{self.assignment_tag}", "{os.path.basename(notebook_path).replace(".ipynb", "")}")'
             )
 
         # Make the code cell non-editable and non-deletable
-        code_cell.metadata = {"editable": False, "deletable": False}
+        code_cell.metadata = {"editable": True, "deletable": False}
         code_cell.metadata["tags"] = ["skip-execution"]
 
         # Add the cells to the notebook
@@ -751,6 +757,8 @@ class NotebookProcessor:
             print("require_key is False. No changes made to the notebook.")
             return
 
+        NotebookProcessor.add_validate_block(notebook_path, require_key)
+
         # Load the notebook
         with open(notebook_path, "r", encoding="utf-8") as f:
             notebook = nbformat.read(f, as_version=4)
@@ -768,6 +776,39 @@ class NotebookProcessor:
         with open(notebook_path, "w", encoding="utf-8") as f:
             nbformat.write(notebook, f)
 
+    @staticmethod
+    def add_validate_block(notebook_path: str, require_key: bool) -> None:
+        """
+        Modifies the first code cell of a Jupyter notebook to add the validate_token call if require_key is True.
+
+        Args:
+            notebook_path (str): The path to the notebook file to modify.
+            require_key (bool): Whether to add the validate_token cell.
+
+        Returns:
+            None
+        """
+        if not require_key:
+            return
+
+        # Load the notebook
+        with open(notebook_path, "r", encoding="utf-8") as f:
+            notebook = nbformat.read(f, as_version=4)
+
+        # Prepare the validation code
+        validation_code = "validate_token()\n"
+
+        # Modify the first cell if it's a code cell, otherwise insert a new one
+        if notebook.cells and notebook.cells[0].cell_type == "code":
+            notebook.cells[0].source = validation_code + "\n" + notebook.cells[0].source
+        else:
+            new_cell = nbformat.v4.new_code_cell(validation_code)
+            notebook.cells.insert(0, new_cell)
+
+        # Save the modified notebook
+        with open(notebook_path, "w", encoding="utf-8") as f:
+            nbformat.write(notebook, f)
+
     @staticmethod
     def add_initialization_code(
         notebook_path, week, assignment_type, require_key=False

pykubegrader/telemetry.py

@@ -303,7 +303,7 @@ def get_assignments_submissions():
     from_env = os.getenv("JUPYTERHUB_USER")
     if from_hostname != from_env:
         raise ValueError("Problem with JupyterHub username")
-
+    print(from_env)
     params = {"username": from_env}
     # get submission information
     res = requests.get(
@@ -319,21 +319,33 @@ def setup_grades_df(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 = pd.DataFrame(restruct_grades,dtype=float)
+    new_weekly_grades["inds"] = inds
     new_weekly_grades.set_index("inds", inplace=True)
     return new_weekly_grades
 
 
+def skipped_assignment_mask(assignments):
+    existing_assignment_mask = setup_grades_df(assignments).astype(bool)
+    for assignment in assignments:
+        # existing_assignment_mask[assignment["assignment_type"]].iloc[assignment["week_number"]-1] = True
+        existing_assignment_mask.loc[f'week{assignment["week_number"]}', assignment["assignment_type"]] = True
+    return existing_assignment_mask.astype(bool)
+
 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"]
-        ]
+        subs = [ sub for sub in student_subs if (sub['assignment_type']==assignment['assignment_type']) and (sub['week_number']==assignment['week_number']) ]
+        # print(assignment, subs)
+        # print(assignment)
+        # print(student_subs[:5])
+        if assignment["assignment_type"] == "lecture":
+            if sum([sub["raw_score"] for sub in subs]) > 0: # TODO: good way to check for completion?
+                new_weekly_grades.loc[f"week{assignment['week_number']}", "lecture"] = 1.0
+        if assignment["assignment_type"] == "final":
+            continue
+        if assignment["assignment_type"] == "midterm":
+            continue
         if len(subs) == 0:
             # print(assignment['title'], 0, assignment['max_score'])
             continue
@@ -363,22 +375,18 @@ def fill_grades_df(new_weekly_grades, assignments, student_subs):
             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
+    # 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["practicemidterm"] = new_weekly_grades[["practicemidterm", "PracticeMidterm"]].max(axis=1)
+    new_weekly_grades.drop(
+        ["attendance", "practice-quiz", "test", "PracticeMidterm"],
+        axis=1,
+        inplace=True,
+        errors="ignore",
+    )
 
+    return new_weekly_grades
 
 def get_current_week(start_date):
     # Calculate the current week (1-based indexing)
@@ -388,13 +396,36 @@ def get_current_week(start_date):
     return days_since_start // 7 + 1
 
 
+def get_average_weighted_grade(assignments, current_week, new_weekly_grades, weights):
+    # Get average until current week
+    skip_weeks = skipped_assignment_mask(assignments)
+    for col in new_weekly_grades.columns:
+        new_weekly_grades.loc["Running Avg", col] = new_weekly_grades.loc[skip_weeks[col]==True, col].mean()
+    # for col in new_weekly_grades.columns:
+    #     skip_weeks = skipped_assignment_mask(assignments)
+    #     skip_weeks_series = pd.Series(skip_weeks)
+    #     # new_weekly_grades.iloc[-1,col] = new_weekly_grades.iloc[skip_weeks_series[col],-1].mean()
+    #     new_weekly_grades
+
+    # make new dataframe with the midterm, final, and running average
+    total = 0
+    avg_grades_dict = {}
+    for k, v in weights.items():
+        grade = new_weekly_grades.get(k, pd.Series([0])).iloc[-1]
+        total += grade * v
+        avg_grades_dict[k] = grade
+    avg_grades_dict['Total'] = total  # excluded midterm and final
+    
+    return avg_grades_dict
+
+
 # This function currently has many undefined variables and other problems!
-def get_my_grades_testing(start_date="2025-01-06"):
+def get_my_grades_testing(start_date="2025-01-06", verbose=True):
     """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,
@@ -408,23 +439,71 @@ def get_my_grades_testing(start_date="2025-01-06"):
     }
 
     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)
+    
+    avg_grades_dict = get_average_weighted_grade(assignments, current_week, new_weekly_grades, weights)
+    
+    if verbose:
+        max_key_length = max(len(k) for k in weights.keys())
+        for k, v in avg_grades_dict.items():
+            print(f'{k:<{max_key_length}}:\t {v:.2f}')
 
-    # Get average until current week
-    new_weekly_grades.iloc[-1] = new_weekly_grades.iloc[: current_week - 1].mean()
+    return new_weekly_grades  # get rid of test and running avg columns
+def get_all_students(admin_user, admin_pw):
+    res = requests.get(
+        url=api_base_url.rstrip("/") + "/students",
+        auth=HTTPBasicAuth(admin_user, admin_pw),
+    )
+    res.raise_for_status()
 
-    # 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
+    # Input: List of players
+    return [student['email'].split('@')[0] for student in res.json()]
 
-    return new_weekly_grades  # get rid of test and running avg columns
+
+# def all_student_grades_testing(admin_user, admin_pw, 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,
+#     }
+
+#     student_usernames = get_student_usernames(admin_user, admin_pw)
+    
+#     assignments, student_subs = get_assignments_submissions(admin_user, admin_pw)
+
+#     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/tokens/token_panel.py

@@ -0,0 +1,53 @@
+import panel as pn
+import requests
+from requests.auth import HTTPBasicAuth
+import os
+
+from ..utils import api_base_url
+
+# Dummy credentials for HTTP Basic Auth
+AUTH = HTTPBasicAuth("user", "password")
+
+# Panel configuration
+pn.extension()
+
+
+def get_jhub_user():
+    """
+    Fetches the JupyterHub user from the environment.
+    """
+    jhub_user = os.getenv("JUPYTERHUB_USER")
+    if jhub_user is None:
+        raise ValueError("JupyterHub user not found")
+    return jhub_user
+
+
+def get_students():
+
+    # Make the request
+    response = requests.get(
+        f"{api_base_url}students",
+        auth=HTTPBasicAuth("user", "pass"),  # Basic Auth
+        params={"requester": get_jhub_user()},  # Query parameter
+    )
+
+    # Print response
+    if response.status_code == 200:
+        return [student["email"].split("@")[0] for student in response.json()]
+    else:
+        print(f"Error {response.status_code}: {response.text}")
+
+
+def get_assignments():
+    # Make the request
+    response = requests.get(
+        f"{api_base_url}assignments",
+        auth=HTTPBasicAuth("user", "pass"),  # Basic Auth
+        params={"requester": get_jhub_user()},  # Query parameter
+    )
+
+    # Print response
+    if response.status_code == 200:
+        return [assignment["title"] for assignment in response.json()]
+    else:
+        print(f"Error {response.status_code}: {response.text}")

pykubegrader/tokens/tokens.py

@@ -6,19 +6,30 @@ from requests.auth import HTTPBasicAuth
 from ..utils import api_base_url
 
 
-def build_token_payload(token: str, duration: int) -> dict:
+def build_token_payload(token: str, duration: int, **kwargs) -> dict:
+
+    student_id = kwargs.get("student_id", None)
+    assignment = kwargs.get("assignment", None)
+
     jhub_user = os.getenv("JUPYTERHUB_USER")
     if jhub_user is None:
         raise ValueError("JupyterHub user not found")
 
-    return {
+    payload = {
         "value": token,
         "duration": duration,
         "requester": jhub_user,
     }
 
+    if student_id:
+        payload["student_id"] = student_id
+    if assignment:
+        payload["assignment"] = assignment
+
+    return payload
+
 
-def add_token(token: str, duration: int = 20) -> None:
+def add_token(token: str, duration: int = 20, **kwargs) -> None:
     """
     Sends a POST request to mint a token
     """
@@ -27,7 +38,7 @@ def add_token(token: str, duration: int = 20) -> None:
         raise ValueError("Environment variable for API URL not set")
     url = api_base_url.rstrip("/") + "/tokens"
 
-    payload = build_token_payload(token=token, duration=duration)
+    payload = build_token_payload(token=token, duration=duration, **kwargs)
 
     # Dummy credentials for HTTP Basic Auth
     auth = HTTPBasicAuth("user", "password")

pykubegrader/tokens/validate_token.py

@@ -6,6 +6,16 @@ import requests
 from requests.auth import HTTPBasicAuth
 
 
+def get_jhub_user():
+    """
+    Fetches the JupyterHub user from the environment.
+    """
+    jhub_user = os.getenv("JUPYTERHUB_USER")
+    if jhub_user is None:
+        raise ValueError("JupyterHub user not found")
+    return jhub_user
+
+
 class TokenValidationError(Exception):
     """
     Custom exception raised when the token validation fails.
@@ -41,7 +51,10 @@ def get_credentials() -> dict[str, str]:
     return {"username": username, "password": password}
 
 
-def validate_token(token: Optional[str] = None) -> None:
+def validate_token(
+    token: Optional[str] = None,
+    assignment: Optional[str] = None,
+) -> None:
     if token:
         os.environ["TOKEN"] = token  # If token passed, set env var
     else:
@@ -55,8 +68,17 @@ def validate_token(token: Optional[str] = None) -> None:
     if not base_url:
         print("Error: Environment variable 'DB_URL' not set", file=sys.stderr)
         sys.exit(1)
+
+    # Construct endpoint with optional parameters
     endpoint = f"{base_url.rstrip('/')}/validate-token/{token}"
 
+    # Build query parameters
+    params = {}
+    if assignment:
+        params["assignment"] = assignment
+
+    params["student_id"] = get_jhub_user()
+
     # Get credentials
     try:
         credentials = get_credentials()
@@ -69,7 +91,10 @@ def validate_token(token: Optional[str] = None) -> None:
     basic_auth = HTTPBasicAuth(username, password)
 
     try:
-        response = requests.get(url=endpoint, auth=basic_auth, timeout=10)
+        # Send request with optional query parameters
+        response = requests.get(
+            url=endpoint, auth=basic_auth, timeout=10, params=params
+        )
         response.raise_for_status()
 
         detail = response.json().get("detail", response.text)

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