PyKubeGrader 0.3.2__tar.gz → 0.3.4__tar.gz

{pykubegrader-0.3.2/src/PyKubeGrader.egg-info → pykubegrader-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyKubeGrader
-Version: 0.3.2
+Version: 0.3.4
 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.4/ruff.toml

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

{pykubegrader-0.3.2 → pykubegrader-0.3.4}/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.2 → pykubegrader-0.3.4/src/PyKubeGrader.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyKubeGrader
-Version: 0.3.2
+Version: 0.3.4
 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.2 → pykubegrader-0.3.4}/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.2 → pykubegrader-0.3.4}/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.2 → pykubegrader-0.3.4}/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.4/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.4/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

{pykubegrader-0.3.2 → pykubegrader-0.3.4}/src/pykubegrader/grading_tester.ipynb

@@ -1,5 +1,16 @@
 {
  "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from grade_reports.grade_reports import filter_assignments, get_student_grades\n",
+    "\n",
+    "get_student_grades"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -19,13 +30,13 @@
     "api_base_url = \"https://engr-131-api.eastus.cloudapp.azure.com/\"\n",
     "\n",
     "\n",
-    "def get_all_students():\n",
-    "    res = requests.get(\n",
-    "        url=api_base_url.rstrip(\"/\") + \"/get-all-submission-emails\",\n",
-    "        auth=HTTPBasicAuth(user(), password()),\n",
-    "    )\n",
+    "# def get_all_students():\n",
+    "#     res = requests.get(\n",
+    "#         url=api_base_url.rstrip(\"/\") + \"/get-all-submission-emails\",\n",
+    "#         auth=HTTPBasicAuth(user(), password()),\n",
+    "#     )\n",
     "\n",
-    "    return res.json()\n",
+    "#     return res.json()\n",
     "\n",
     "\n",
     "# def get_student_grades(student_id):\n",
@@ -41,47 +52,47 @@
     "#     return assignments, sub\n",
     "\n",
     "\n",
-    "def get_student(student):\n",
-    "    print(student)\n",
-    "    # Get assignments and submissions for the student (assumed functions)\n",
-    "    assignments, submissions = get_student_grades(student)\n",
+    "# def get_student(student):\n",
+    "#     print(student)\n",
+    "#     # Get assignments and submissions for the student (assumed functions)\n",
+    "#     assignments, submissions = get_student_grades(student)\n",
     "\n",
-    "    # Recalculate grades and get a grades dictionary\n",
-    "    grades_dict = recalculate_best_grades(assignments, submissions)\n",
+    "#     # Recalculate grades and get a grades dictionary\n",
+    "#     grades_dict = recalculate_best_grades(assignments, submissions)\n",
     "\n",
-    "    # Calculate averages and build a row for the student\n",
-    "    row = calculate_averages(grades_dict, student)\n",
+    "#     # Calculate averages and build a row for the student\n",
+    "#     row = calculate_averages(grades_dict, student)\n",
     "\n",
-    "    # Convert the row (a dictionary) into a DataFrame\n",
-    "    # row_df = pd.DataFrame([row])\n",
+    "#     # Convert the row (a dictionary) into a DataFrame\n",
+    "#     # row_df = pd.DataFrame([row])\n",
     "\n",
-    "    return row\n",
+    "#     return row\n",
     "\n",
     "\n",
-    "def get_all_student_grades():\n",
-    "    # Initialize an empty DataFrame to hold all student grades\n",
-    "    df = pd.DataFrame()\n",
+    "# def get_all_student_grades():\n",
+    "#     # Initialize an empty DataFrame to hold all student grades\n",
+    "#     df = pd.DataFrame()\n",
     "\n",
-    "    # Get all students (assuming get_all_students() is a defined function)\n",
-    "    students = get_all_students()\n",
+    "#     # Get all students (assuming get_all_students() is a defined function)\n",
+    "#     students = get_all_students()\n",
     "\n",
-    "    for student in students:\n",
-    "        row_df = get_student(student)\n",
+    "#     for student in students:\n",
+    "#         row_df = get_student(student)\n",
     "\n",
-    "        # Append the row to the DataFrame\n",
-    "        df = pd.concat([df, row_df], ignore_index=True)\n",
+    "#         # Append the row to the DataFrame\n",
+    "#         df = pd.concat([df, row_df], ignore_index=True)\n",
     "\n",
-    "    return df\n",
+    "#     return df\n",
     "\n",
     "\n",
-    "def get_max_deadline(assignments, assignment_name, week_number):\n",
-    "    matching_rows = assignments[\n",
-    "        (assignments[\"week_number\"] == week_number)\n",
-    "        & (assignments[\"assignment_name\"] == assignment_name)\n",
-    "    ]\n",
+    "# def get_max_deadline(assignments, assignment_name, week_number):\n",
+    "#     matching_rows = assignments[\n",
+    "#         (assignments[\"week_number\"] == week_number)\n",
+    "#         & (assignments[\"assignment_name\"] == assignment_name)\n",
+    "#     ]\n",
     "\n",
-    "    max_timestamp = matching_rows[\"due_date\"].max()\n",
-    "    return max_timestamp\n",
+    "#     max_timestamp = matching_rows[\"due_date\"].max()\n",
+    "#     return max_timestamp\n",
     "\n",
     "\n",
     "def calculate_averages(grades_dict, student_id):\n",
@@ -455,7 +466,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "engr131_dev",
+   "display_name": "engr131w25",
    "language": "python",
    "name": "python3"
   },
@@ -469,7 +480,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.7"
+   "version": "3.13.1"
   }
  },
  "nbformat": 4,

pykubegrader-0.3.4/src/pykubegrader/submit/submit_assignment.py

@@ -0,0 +1,88 @@
+import os
+
+import requests
+from requests.auth import HTTPBasicAuth
+
+
+def get_credentials():
+    """
+    Fetch the username and password from environment variables.
+    """
+    username = os.getenv("user_name_student")
+    password = os.getenv("keys_student")
+    if not username or not password:
+        raise ValueError(
+            "Environment variables 'user_name_student' or 'keys_student' are not set."
+        )
+    return {"username": username, "password": password}
+
+
+def call_score_assignment(
+    assignment_title: str, notebook_title: str, file_path: str = ".output_reduced.log"
+) -> dict[str, str]:
+    """
+    Submit an assignment to the scoring endpoint
+
+    Args:
+        assignment_title (str): Title of the assignment
+        notebook_title (str): Title of the notebook
+        file_path (str): Path to the log file to upload
+
+    Returns:
+        dict: JSON response from the server
+    """
+
+    base_url = os.getenv("DB_URL")
+    if not base_url:
+        raise ValueError("Environment variable 'DB_URL' not set")
+
+    url = base_url.rstrip("/") + "/score-assignment"
+
+    params = {
+        "assignment_title": assignment_title,
+        "notebook_title": notebook_title,
+    }
+
+    username, password = get_credentials().values()
+
+    try:
+        with open(file_path, "rb") as file:
+            res = requests.post(
+                url=url,
+                params=params,
+                auth=HTTPBasicAuth(username, password),
+                files={"log_file": file},
+            )
+            res.raise_for_status()
+
+            return res.json()
+
+    except FileNotFoundError:
+        raise FileNotFoundError(f"File {file_path} does not exist")
+    except requests.RequestException as err:
+        raise RuntimeError(f"An error occurred while requesting {url}: {err}")
+    except Exception as err:
+        raise RuntimeError(f"An unexpected error occurred: {err}")
+
+
+def submit_assignment(
+    assignment_title: str,
+    notebook_title: str,
+    file_path: str = ".output_reduced.log",
+) -> None:
+    """
+    Synchronous wrapper for the `call_score_assignment` function.
+
+    Args:
+        assignment_title (str): Title of the assignment.
+        file_path (str): Path to the log file to upload.
+    """
+
+    response = call_score_assignment(assignment_title, notebook_title, file_path)
+
+    print("Server Response:", response.get("message", "No message in response"))
+
+
+# Example usage (remove this section if only the function needs to be importable):
+if __name__ == "__main__":
+    submit_assignment("week1-readings", "path/to/your/log_file.txt")