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

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

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

{PyKubeGrader-0.3.5.dist-info → PyKubeGrader-0.3.7.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=320aFB1-6KLQt0OMmKD0FJtE17JKZaK5neA0mTD-Y8M,22960
-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=HDccW597shBhAd-jxvMUPpsiNj2S4DlKRGMDH_6U9nQ,87590
 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
@@ -16,9 +16,10 @@ pykubegrader/graders/late_assignments.py,sha256=_2-rA5RqO0BWY9WAQA_mbCxxPKTOiJOl
 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=cqVu7US8GVaCdJdaU2yjawlVBtAKP5XJc4oAvX5FeRU,2575
-pykubegrader/tokens/tokens.py,sha256=X9f3SzrGCrAJp_BXhr6VJn5f0LxtgQ7HLPBw7zEF2BY,1198
-pykubegrader/tokens/validate_token.py,sha256=MQtgz_USvSZ9JahJ48ybjp74F5aYz64lhtvuwVc4kQw,2712
+pykubegrader/submit/submit_assignment.py,sha256=Cx9hc2A--ts95dFLvn7Fw--ekRwPXqHKKVChnGFgw_Y,2670
+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
@@ -32,9 +33,9 @@ pykubegrader/widgets_base/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-
 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=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.7.dist-info/LICENSE.txt,sha256=YTp-Ewc8Kems8PJEE27KnBPFnZSxoWvSg7nnknzPyYw,1546
+PyKubeGrader-0.3.7.dist-info/METADATA,sha256=Ht8G9VvFfGBa9YD9PoBSbd_Cee6tuGZ2RTBjFN0Z5pk,2729
+PyKubeGrader-0.3.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+PyKubeGrader-0.3.7.dist-info/entry_points.txt,sha256=RR57KvzDRJrP4omy5heS5cZ3E7g56YxcxJhDnp57ZU0,253
+PyKubeGrader-0.3.7.dist-info/top_level.txt,sha256=e550Klfze6higFxER1V62fnGOcIgiKRbsrl9CC4UdtQ,13
+PyKubeGrader-0.3.7.dist-info/RECORD,,

pykubegrader/build/api_notebook_builder.py

@@ -17,12 +17,15 @@ class FastAPINotebookBuilder:
     temp_notebook: Optional[str] = None
     assignment_tag: Optional[str] = ""
     require_key: Optional[bool] = False
+    verbose: Optional[bool] = False
 
     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) -> None:
@@ -38,6 +41,9 @@ class FastAPINotebookBuilder:
         self.assertion_tests_dict = self.question_dict()
         self.add_api_code()
 
+        # add the point total to the end of the notebook
+        self.add_total_points_to_notebook()
+
     @staticmethod
     def conceal_tests(cell_source):
         """
@@ -76,28 +82,33 @@ class FastAPINotebookBuilder:
 
         return concealed_lines
 
-    def add_api_code(self):
     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"]:
@@ -135,18 +146,65 @@ 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 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 = sum(
-                    cell["points"]
-                    for cell in self.assertion_tests_dict.values()
-                    if cell["question"] == cell_dict["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
 
@@ -272,7 +330,7 @@ class FastAPINotebookBuilder:
         return original_list[:index] + insert_list + original_list[index:]
 
     @staticmethod
-    def add_import_statements_to_tests(cell_source: list[str]) -> list[str]:
+    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.
         """
@@ -293,6 +351,11 @@ class FastAPINotebookBuilder:
             "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

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):
@@ -572,23 +578,23 @@ class NotebookProcessor:
 
         if self.require_key:
             # Add an additional line for validate_token()
-            validate_token_line = "from pykubegrader.tokens.validate_token import validate_token\nvalidate_token()\n"
+            validate_token_line =f"from pykubegrader.tokens.validate_token import validate_token\nvalidate_token(assignment = '{self.assignment_tag}')\n"
 
             # Define the Code cell
             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
@@ -675,6 +681,7 @@ class NotebookProcessor:
                 self.week,
                 self.assignment_type,
                 require_key=self.require_key,
+                assignment_tag = self.assignment_tag,
             )
 
             NotebookProcessor.replace_temp_in_notebook(
@@ -705,6 +712,7 @@ class NotebookProcessor:
                 self.week,
                 self.assignment_type,
                 require_key=self.require_key,
+                assignment_tag = self.assignment_tag
             )
             NotebookProcessor.replace_temp_no_otter(
                 temp_notebook_path, temp_notebook_path
@@ -736,7 +744,7 @@ class NotebookProcessor:
             nbformat.write(notebook, f)
 
     @staticmethod
-    def add_validate_token_cell(notebook_path: str, require_key: bool) -> None:
+    def add_validate_token_cell(notebook_path: str, require_key: bool, **kwargs) -> None:
         """
         Adds a new code cell at the top of a Jupyter notebook if require_key is True.
 
@@ -750,16 +758,24 @@ class NotebookProcessor:
         if not require_key:
             print("require_key is False. No changes made to the notebook.")
             return
+        
+        NotebookProcessor.add_validate_block(notebook_path, require_key, assignment_tag = kwargs.get("assignment_tag", None))
 
         # Load the notebook
         with open(notebook_path, "r", encoding="utf-8") as f:
             notebook = nbformat.read(f, as_version=4)
 
         # Create the new code cell
-        new_cell = nbformat.v4.new_code_cell(
+        if kwargs.get("assignment_tag", None):
+            new_cell = nbformat.v4.new_code_cell(
+            "from pykubegrader.tokens.validate_token import validate_token\n"
+            f"validate_token('type the key provided by your instructor here', assignment = '{kwargs.get('assignment_tag')}')\n"
+            )
+        else:
+            new_cell = nbformat.v4.new_code_cell(
             "from pykubegrader.tokens.validate_token import validate_token\n"
             "validate_token('type the key provided by your instructor here')\n"
-        )
+            )
 
         # Add the new cell to the top of the notebook
         notebook.cells.insert(0, new_cell)
@@ -768,9 +784,42 @@ 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, **kwargs) -> 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
+        notebook_path, week, assignment_type, require_key=False, **kwargs,
     ):
         # finds the first code cell
         index, cell = find_first_code_cell(notebook_path)
@@ -782,7 +831,7 @@ class NotebookProcessor:
         replace_cell_source(notebook_path, index, cell)
 
         if require_key:
-            NotebookProcessor.add_validate_token_cell(notebook_path, require_key)
+            NotebookProcessor.add_validate_token_cell(notebook_path, require_key, assignment_tag = kwargs.get("assignment_tag", None))
 
     def multiple_choice_parser(self, temp_notebook_path, new_notebook_path):
         ### Parse the notebook for multiple choice questions

pykubegrader/submit/submit_assignment.py

@@ -42,6 +42,9 @@ def call_score_assignment(
         "assignment_title": assignment_title,
         "notebook_title": notebook_title,
     }
+    
+    if  os.environ["TOKEN"] is not None:
+        params["key_used"] = os.environ["TOKEN"]
 
     username, password = get_credentials().values()
 

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)