PyKubeGrader 0.3.3__tar.gz → 0.3.5__tar.gz

{pykubegrader-0.3.3/src/PyKubeGrader.egg-info → pykubegrader-0.3.5}/PKG-INFO

@@ -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.5/ruff.toml

@@ -0,0 +1,2 @@
+[lint.per-file-ignores]
+"*.ipynb" = ["F811", "F821", "F841"]

{pykubegrader-0.3.3 → pykubegrader-0.3.5}/setup.cfg

@@ -22,12 +22,10 @@ include_package_data = True
 package_dir = 
 	=src
 install_requires = 
-	httpx
 	importlib-metadata; python_version<"3.8"
 	ipython
 	mypy
 	nbformat
-	nest_asyncio
 	numpy
 	pandas-stubs
 	panel
@@ -38,7 +36,6 @@ install_requires =
 	setuptools
 	sphinx
 	types-python-dateutil
-	types-pyyaml
 	types-requests
 	types-setuptools
 
@@ -59,6 +56,7 @@ console_scripts =
 	otter-folder-builder = pykubegrader.build.build_folder:main
 	otter-folder-cleaner = pykubegrader.build.clean_folder:main
 	markdown-question = pykubegrader.build.markdown_questions:main
+	collate-questions = pykubegrader.build.collate:main
 
 [tool:pytest]
 addopts = 

{pykubegrader-0.3.3 → pykubegrader-0.3.5/src/PyKubeGrader.egg-info}/PKG-INFO

@@ -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 → pykubegrader-0.3.5}/src/PyKubeGrader.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ pyproject.toml
 ruff.toml
 setup.cfg
 setup.py
+test.ipynb
 tox.ini
 .github/workflows/main.yml
 docs/Makefile
@@ -43,6 +44,7 @@ src/pykubegrader/build/__init__.py
 src/pykubegrader/build/api_notebook_builder.py
 src/pykubegrader/build/build_folder.py
 src/pykubegrader/build/clean_folder.py
+src/pykubegrader/build/collate.py
 src/pykubegrader/build/markdown_questions.py
 src/pykubegrader/grade_reports/grade_reports.py
 src/pykubegrader/graders/__init__.py

{pykubegrader-0.3.3 → pykubegrader-0.3.5}/src/PyKubeGrader.egg-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-0.3.3 → pykubegrader-0.3.5}/src/PyKubeGrader.egg-info/requires.txt

@@ -1,8 +1,6 @@
-httpx
 ipython
 mypy
 nbformat
-nest_asyncio
 numpy
 pandas-stubs
 panel
@@ -13,7 +11,6 @@ ruff
 setuptools
 sphinx
 types-python-dateutil
-types-pyyaml
 types-requests
 types-setuptools
 

{pykubegrader-0.3.3 → pykubegrader-0.3.5}/src/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-0.3.5/src/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-0.3.5/src/pykubegrader/grade_reports/grade_reports.py

@@ -0,0 +1,76 @@
+import os
+
+import pandas as pd
+import requests
+from requests.auth import HTTPBasicAuth
+
+
+def format_assignment_table(assignments):
+    # Create DataFrame
+    df = pd.DataFrame(assignments)
+
+    # Replacements for normalization
+    replacements = {
+        "practicequiz": "practice quiz",
+        "practice-quiz": "practice quiz",
+        "attend": "attendance",
+        "attendance": "attendance",
+    }
+
+    # Remove assignments of type 'test'
+    remove_assignments = ["test"]
+
+    # Apply replacements
+    df["assignment_name"] = df["assignment_type"].replace(replacements)
+
+    # Filter out specific assignment types
+    df = df[~df["assignment_type"].isin(remove_assignments)]
+
+    # Sort by week number and assignment name
+    df = df.sort_values(by=["assignment_name", "week_number"]).reset_index(drop=True)
+
+    return df
+
+
+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(student_user, student_pw),
+    )
+    [assignments, sub] = res.json()
+
+    assignments_df = format_assignment_table(assignments)
+
+    return assignments_df, pd.DataFrame(sub)
+
+
+def filter_assignments(df, max_week=None, exclude_types=None):
+    """
+    Remove assignments with week_number greater than max_week
+    or with specific assignment types.
+
+    :param df: DataFrame containing assignments.
+    :param max_week: Maximum allowed week_number (int).
+    :param exclude_types: A single assignment type or a list of assignment types to exclude.
+    :return: Filtered DataFrame.
+    """
+    if max_week is not None:
+        df = df[df["week_number"] <= max_week]
+
+    if exclude_types is not None:
+        # Ensure exclude_types is a list
+        if not isinstance(exclude_types, (list, tuple, set)):
+            exclude_types = [exclude_types]
+        df = df[~df["assignment_type"].isin(exclude_types)]
+
+    return df