PyKubeGrader 0.2.25__tar.gz → 0.2.27__tar.gz

{pykubegrader-0.2.25/src/PyKubeGrader.egg-info → pykubegrader-0.2.27}/PKG-INFO

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

{pykubegrader-0.2.25 → pykubegrader-0.2.27/src/PyKubeGrader.egg-info}/PKG-INFO

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

{pykubegrader-0.2.25 → pykubegrader-0.2.27}/src/pykubegrader/build/api_notebook_builder.py

@@ -65,9 +65,6 @@ class FastAPINotebookBuilder:
             updated_cell_source.extend(
                 FastAPINotebookBuilder.construct_question_info(cell_dict)
             )
-            updated_cell_source.extend(
-                FastAPINotebookBuilder.construct_update_responses(cell_dict)
-            )
 
             updated_cell_source.extend(cell_source[last_import_line_ind + 1 :])
             updated_cell_source.extend(["\n"])
@@ -91,6 +88,10 @@ class FastAPINotebookBuilder:
                 ["os.environ['EARNED_POINTS'] = str(earned_points)\n"]
             )
 
+            updated_cell_source.extend(
+                FastAPINotebookBuilder.construct_update_responses(cell_dict)
+            )
+
             self.replace_cell_source(cell_index, updated_cell_source)
 
     def compute_max_points_free_response(self):
@@ -142,7 +143,7 @@ class FastAPINotebookBuilder:
 
         for logging_variable in logging_variables:
             update_responses.append(
-                f"responses = update_responses(question_id, {logging_variable})\n"
+                f"responses = update_responses(question_id, str({logging_variable}))\n"
             )
 
         return update_responses
@@ -189,7 +190,7 @@ class FastAPINotebookBuilder:
         question_id = cell_dict["question"] + "-" + str(cell_dict["test_number"])
 
         question_info.append(f'question_id = "{question_id}"' + "\n")
-        question_info.append(f'max_score = {cell_dict["points"]}\n')
+        question_info.append(f"max_score = {cell_dict['points']}\n")
         question_info.append("score = 0\n")
 
         return question_info

{pykubegrader-0.2.25 → pykubegrader-0.2.27}/src/pykubegrader/build/build_folder.py

@@ -22,13 +22,11 @@ try:
 except:  # noqa: E722
     print("Passwords not found, cannot access database")
 
-import nbformat
-
-from .api_notebook_builder import FastAPINotebookBuilder
 from typing import Optional
 
+import nbformat
 
-import os
+from .api_notebook_builder import FastAPINotebookBuilder
 
 os.environ["JUPYTERHUB_USER"] = "jca92"
 os.environ["TOKEN"] = "token"
@@ -180,9 +178,7 @@ class NotebookProcessor:
         self.update_initialize_function()
 
     def update_initialize_function(self):
-
         for key, value in self.total_point_log.items():
-
             assignment_tag = f"week{self.week_num}-{self.assignment_type}"
 
             update_initialize_assignment(
@@ -724,6 +720,7 @@ class NotebookProcessor:
         with open(notebook_path, "w", encoding="utf-8") as f:
             nbformat.write(notebook, f)
 
+    @staticmethod
     def add_validate_token_cell(notebook_path: str, require_key: bool) -> None:
         """
         Adds a new code cell at the top of a Jupyter notebook if require_key is True.
@@ -794,7 +791,7 @@ class NotebookProcessor:
                 data, output_file=solution_path
             )
 
-            question_path = f"{new_notebook_path.replace(".ipynb", "")}_questions.py"
+            question_path = f"{new_notebook_path.replace('.ipynb', '')}_questions.py"
 
             generate_mcq_file(data, output_file=question_path)
 
@@ -834,7 +831,7 @@ class NotebookProcessor:
                 data, output_file=solution_path
             )
 
-            question_path = f"{new_notebook_path.replace(".ipynb", "")}_questions.py"
+            question_path = f"{new_notebook_path.replace('.ipynb', '')}_questions.py"
 
             generate_tf_file(data, output_file=question_path)
 
@@ -872,7 +869,7 @@ class NotebookProcessor:
                 data, output_file=solution_path
             )
 
-            question_path = f"{new_notebook_path.replace(".ipynb", "")}_questions.py"
+            question_path = f"{new_notebook_path.replace('.ipynb', '')}_questions.py"
 
             generate_select_many_file(data, output_file=question_path)
 
@@ -1812,9 +1809,7 @@ def generate_mcq_file(data_dict, output_file="mc_questions.py"):
                     )
                     f.write("    def __init__(self):\n")
                     f.write("        super().__init__(\n")
-                    f.write(
-                        f'            title=f"Question{q_value['question number']}: {q_value['title']}",\n'
-                    )
+                    f.write(f'            title=f"{q_value["title"]}",\n')
                     f.write("            style=MCQ,\n")
                     f.write(
                         f"            question_number={q_value['question number']},\n"
@@ -1885,9 +1880,7 @@ def generate_select_many_file(data_dict, output_file="select_many_questions.py")
                     )
                     f.write("    def __init__(self):\n")
                     f.write("        super().__init__(\n")
-                    f.write(
-                        f'            title=f"Question{q_value['question number']}: {q_value['title']}",\n'
-                    )
+                    f.write(f'            title=f"{q_value["title"]}",\n')
                     f.write("            style=MultiSelect,\n")
                     f.write(
                         f"            question_number={q_value['question number']},\n"
@@ -1964,9 +1957,7 @@ def generate_tf_file(data_dict, output_file="tf_questions.py"):
                     )
                     f.write("    def __init__(self):\n")
                     f.write("        super().__init__(\n")
-                    f.write(
-                        f'            title=f"Question{q_value['question number']}: {q_value['title']}",\n'
-                    )
+                    f.write(f'            title=f"{q_value["title"]}",\n')
                     f.write("            style=TFStyle,\n")
                     f.write(
                         f"            question_number={q_value['question number']},\n"

{pykubegrader-0.2.25 → pykubegrader-0.2.27}/src/pykubegrader/initialize.py

@@ -2,14 +2,16 @@ import hashlib
 import os
 import shutil
 from pathlib import Path
+from typing import Optional
 
 import panel as pn
 import requests
 from IPython import get_ipython
-from typing import Optional
+
 from .telemetry import ensure_responses, log_variable, telemetry, update_responses
 
-#TODO: could cleanup to remove redundant imports
+
+# TODO: could cleanup to remove redundant imports
 def initialize_assignment(
     name: str,
     week: str,
@@ -33,7 +35,7 @@ def initialize_assignment(
     Raises:
         Exception: If the environment is unsupported or initialization fails.
     """
-    
+
     if assignment_tag is None:
         assignment_tag = f"{week}-{assignment_type}"
 

{pykubegrader-0.2.25 → pykubegrader-0.2.27}/src/pykubegrader/log_parser/parse.ipynb

@@ -6,17 +6,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "# ruff: noqa\n",
+    "\n",
     "# Get the public/private keypair for decryption\n",
     "key_box = get_keybox()"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -151,7 +146,7 @@
     "parser = LogParser(log_lines=log_lines, week_tag=\"week1-readings\")\n",
     "parser.parse_logs()\n",
     "parser.calculate_total_scores()\n",
-    "results = parser.get_results() \n",
+    "results = parser.get_results()\n",
     "\n",
     "results"
    ]
@@ -192,13 +187,6 @@
     "results"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -218,7 +206,7 @@
     "time_stamp = results[\"student_information\"][\"timestamp\"]\n",
     "\n",
     "week_num = results[\"week_num\"]\n",
-    "assignment_type = results['assignment_type']\n",
+    "assignment_type = results[\"assignment_type\"]\n",
     "\n",
     "assignments_graded = results[\"assignment_information\"].keys()\n",
     "total_score = 0\n",
@@ -253,13 +241,6 @@
    "source": [
     "student_email"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

{pykubegrader-0.2.25 → pykubegrader-0.2.27}/src/pykubegrader/log_parser/parse.py

@@ -1,5 +1,14 @@
 from dataclasses import dataclass, field
-from typing import Optional
+from typing import Any, Optional, TypedDict
+
+
+class LogParserResults(TypedDict):
+    student_information: dict[str, str]
+    week: Optional[str]
+    week_num: Optional[int]
+    assignment_type: Optional[str]
+    assignment_information: dict[str, Any]
+    assignment_scores: dict[str, Any]
 
 
 @dataclass
@@ -160,7 +169,7 @@ class LogParser:
             total_score = sum(q["score_earned"] for q in data["questions"].values())
             data["total_score"] = total_score
 
-    def get_results(self) -> dict[str, dict]:
+    def get_results(self) -> LogParserResults:
         """
         Returns the parsed results as a hierarchical dictionary with three sections:
         """

{pykubegrader-0.2.25 → pykubegrader-0.2.27}/src/pykubegrader/submit/submit_assignment.py

@@ -1,8 +1,9 @@
-import os
-import httpx
 import asyncio
-import nest_asyncio
 import base64
+import os
+
+import httpx
+import nest_asyncio  # type: ignore
 
 # Apply nest_asyncio for environments like Jupyter
 nest_asyncio.apply()
@@ -43,7 +44,7 @@ async def call_score_assignment(
     # Get credentials
     credentials = get_credentials()
     username = credentials["username"]
-    password = credentials["password"] 
+    password = credentials["password"]
 
     # Encode credentials for Basic Authentication
     auth_header = (

{pykubegrader-0.2.25 → pykubegrader-0.2.27}/src/pykubegrader/telemetry.py

@@ -134,11 +134,11 @@ def score_question(
     responses = ensure_responses()
 
     payload: dict[str, Any] = {
-        "student_email": f'{responses["jhub_user"]}@drexel.edu',
+        "student_email": f"{responses['jhub_user']}@drexel.edu",
         "term": term,
         "week": responses["week"],
         "assignment": responses["assignment_type"],
-        "question": f'_{responses["assignment"]}',
+        "question": f"_{responses['assignment']}",
         "responses": responses,
     }
 

pykubegrader-0.2.27/src/pykubegrader/tokens/tokens.py

@@ -0,0 +1,42 @@
+import os
+
+import requests
+from requests.auth import HTTPBasicAuth
+
+
+def build_token_payload(token: str, duration: int) -> dict:
+    jhub_user = os.getenv("JUPYTERHUB_USER")
+    if jhub_user is None:
+        raise ValueError("JupyterHub user not found")
+
+    return {
+        "value": token,
+        "duration": duration,
+        "requester": jhub_user,
+    }
+
+
+def add_token(token: str, duration: int = 20) -> None:
+    """
+    Sends a POST request to mint a token
+    """
+
+    url = "https://engr-131-api.eastus.cloudapp.azure.com/tokens"
+
+    payload = build_token_payload(token=token, duration=duration)
+
+    # Dummy credentials for HTTP Basic Auth
+    auth = HTTPBasicAuth("user", "password")
+
+    # Add a custom header, for potential use in authorization
+    headers = {"x-jhub-user": payload["requester"]}
+
+    response = requests.post(url=url, json=payload, headers=headers, auth=auth)
+
+    # Print response
+    print(f"Status code: {response.status_code}")
+
+    try:
+        print(f"Response: {response.json()}")
+    except ValueError:
+        print(f"Response: {response.text}")

{pykubegrader-0.2.25 → pykubegrader-0.2.27}/src/pykubegrader/tokens/validate_token.py

@@ -1,8 +1,9 @@
+import asyncio
 import os
-import base64
+from typing import Optional
+
 import httpx
-import asyncio
-import nest_asyncio
+import nest_asyncio  # type: ignore
 
 # Apply nest_asyncio for environments like Jupyter
 nest_asyncio.apply()
@@ -13,33 +14,37 @@ class TokenValidationError(Exception):
     Custom exception raised when the token validation fails.
     """
 
-    def __init__(self, message=None):
+    def __init__(self, message: Optional[str] = None):
         """
         Initialize the exception with an optional message.
 
         Args:
             message (str, optional): The error message to display. Defaults to None.
         """
+
         super().__init__(message)
 
 
-def get_credentials():
+def get_credentials() -> dict[str, str]:
     """
     Fetch the username and password from environment variables.
 
     Returns:
         dict: A dictionary containing 'username' and 'password'.
     """
+
     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."
+            "Environment variable 'user_name_student' or 'keys_student' not set"
         )
+
     return {"username": username, "password": password}
 
 
-async def async_validate_token(token: str = None) -> None:
+async def async_validate_token(token: Optional[str] = None) -> None:
     """
     Asynchronously validate a token by making a GET request to the validation endpoint.
 
@@ -53,19 +58,22 @@ async def async_validate_token(token: str = None) -> None:
         None: If the token is valid, the function will pass silently.
     """
 
+    # First, check if token is provided as an argument
     if token is not None:
         os.environ["TOKEN"] = token
 
+    # Next, check if token is available in environment variables
     if token is None:
         token = os.getenv("TOKEN", None)
 
+    # Otherwise, raise an error
     if token is None:
         raise TokenValidationError("No token provided")
 
     # Fetch the endpoint URL
     base_url = os.getenv("DB_URL")
     if not base_url:
-        raise ValueError("Environment variable 'DB_URL' is not set.")
+        raise ValueError("Environment variable 'DB_URL' not set")
     endpoint = f"{base_url}validate-token/{token}"
 
     # Get credentials
@@ -73,17 +81,12 @@ async def async_validate_token(token: str = None) -> None:
     username = credentials["username"]
     password = credentials["password"]
 
-    # Encode credentials for Basic Authentication
-    auth_header = (
-        f"Basic {base64.b64encode(f'{username}:{password}'.encode()).decode()}"
-    )
+    basic_auth = httpx.BasicAuth(username=username, password=password)
 
-    # Make the GET request
+    # Make GET request
     async with httpx.AsyncClient() as client:
         try:
-            response = await client.get(
-                endpoint, headers={"Authorization": auth_header}, timeout=10
-            )
+            response = await client.get(url=endpoint, auth=basic_auth, timeout=10)
 
             if response.status_code == 200:
                 # If the response is 200, the token is valid
@@ -103,7 +106,7 @@ async def async_validate_token(token: str = None) -> None:
             raise TokenValidationError(f"An unexpected error occurred: {e}")
 
 
-def validate_token(token: str = None) -> None:
+def validate_token(token: Optional[str] = None) -> None:
     """
     Synchronous wrapper for the `async_validate_token` function.
 
@@ -131,8 +134,9 @@ def validate_token(token: str = None) -> None:
 # Example usage
 if __name__ == "__main__":
     token = "test"
+
     try:
         validate_token(token)
-        print("Token is valid.")
+        print("Token is valid")
     except TokenValidationError as e:
         print(f"Token validation failed: {e}")

{pykubegrader-0.2.25 → pykubegrader-0.2.27}/src/pykubegrader/widgets_base/reading.py

@@ -23,7 +23,7 @@ class ReadingPython:
 
         # Dynamically assign attributes based on keys, with default values from responses
         for num in range(len(options["lines_to_comment"]) + options["n_rows"]):
-            key = f"q{question_number}_{num+1}"
+            key = f"q{question_number}_{num + 1}"
 
             # Dynamically assign the value from the responses file for persistence
             if num < len(options["lines_to_comment"]):
@@ -57,7 +57,7 @@ class ReadingPython:
             line: pn.widgets.Select(
                 options=shuffle_options(options["comments_options"], seed),
                 name=f"Line {line}:",
-                value=getattr(self, f"q{question_number}_{i_comments+1}"),
+                value=getattr(self, f"q{question_number}_{i_comments + 1}"),
                 width=600,
             )
             for i_comments, line in enumerate(options["lines_to_comment"])
@@ -97,13 +97,13 @@ class ReadingPython:
         # Function to create a row with dropdowns
         def create_row(step: int) -> pn.Row:
             widgets_list = [
-                pn.pane.HTML(f"Step {step+1}", width=150)
+                pn.pane.HTML(f"Step {step + 1}", width=150)
                 if i == 0
                 else pn.widgets.Select(
                     options=dropdown_options[i - 1],
                     value=getattr(
                         self,
-                        f'q{question_number}_{len(options["lines_to_comment"])+step+1}',
+                        f"q{question_number}_{len(options['lines_to_comment']) + step + 1}",
                     )[i - 1],
                     width=150,
                 )

pykubegrader-0.2.25/src/pykubegrader/tokens/tokens.py

@@ -1,47 +0,0 @@
-import requests
-import os
-import json
-
-
-def build_token_payload(token: str, duration: int) -> dict:
-
-    if os.getenv("JUPYTERHUB_USER", None) is None:
-        raise ValueError("JupyterHub user not found")
-
-    # Return the extracted details as a dictionary
-    return {
-        "value": token,
-        "requester": os.getenv("JUPYTERHUB_USER", None),
-        "duration": duration,
-    }
-
-
-# Need to do for add token as well
-def add_token(token, duration=20):
-    """
-    Sends a POST request to add a notebook.
-    """
-    # Define the URL
-    url = "https://engr-131-api.eastus.cloudapp.azure.com/tokens"
-
-    # Build the payload
-    payload = build_token_payload(token=token, duration=duration)
-
-    # Define HTTP Basic Authentication
-    auth = ("user", "password")
-
-    # Define headers
-    headers = {"Content-Type": "application/json"}
-
-    # Serialize the payload with the custom JSON encoder
-    serialized_payload = json.dumps(payload)
-
-    # Send the POST request
-    response = requests.post(url, data=serialized_payload, headers=headers, auth=auth)
-
-    # Print the response
-    print(f"Status Code: {response.status_code}")
-    try:
-        print(f"Response: {response.json()}")
-    except ValueError:
-        print(f"Response: {response.text}")