PyKubeGrader 0.2.8__tar.gz → 0.2.22__tar.gz

{pykubegrader-0.2.8 → pykubegrader-0.2.22}/.gitignore

@@ -57,3 +57,4 @@ MANIFEST
 .ruff_cache/
 password.py
 passwords.py
+src/pykubegrader/tokens/token_test.ipynb

{pykubegrader-0.2.8/src/PyKubeGrader.egg-info → pykubegrader-0.2.22}/PKG-INFO

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

{pykubegrader-0.2.8 → pykubegrader-0.2.22/src/PyKubeGrader.egg-info}/PKG-INFO

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

{pykubegrader-0.2.8 → pykubegrader-0.2.22}/src/PyKubeGrader.egg-info/SOURCES.txt

@@ -47,6 +47,8 @@ src/pykubegrader/log_parser/__init__.py
 src/pykubegrader/log_parser/parse.ipynb
 src/pykubegrader/log_parser/parse.py
 src/pykubegrader/submit/submit_assignment.py
+src/pykubegrader/tokens/tokens.py
+src/pykubegrader/tokens/validate_token.py
 src/pykubegrader/widgets/__init__.py
 src/pykubegrader/widgets/multiple_choice.py
 src/pykubegrader/widgets/reading_question.py

{pykubegrader-0.2.8 → pykubegrader-0.2.22}/src/pykubegrader/build/api_notebook_builder.py

@@ -14,6 +14,7 @@ class FastAPINotebookBuilder:
     notebook_path: str
     temp_notebook: Optional[str] = None
     assignment_tag: Optional[str] = ""
+    require_key: Optional[bool] = False
 
     def __post_init__(self):
         self.root_path, self.filename = FastAPINotebookBuilder.get_filename_and_root(
@@ -119,6 +120,11 @@ class FastAPINotebookBuilder:
             f"os.environ['TOTAL_POINTS_FREE_RESPONSE'] = str({self.total_points})\n"
         )
 
+        if self.require_key:
+            first_cell_header.append(
+                "from pykubegrader.tokens.validate_token import validate_token\nvalidate_token()\n"
+            )
+
         short_filename = self.filename.split(".")[0].replace("_temp", "")
         first_cell_header.extend(
             [

{pykubegrader-0.2.8 → pykubegrader-0.2.22}/src/pykubegrader/build/build_folder.py

@@ -1,7 +1,6 @@
 ### Note
 
 
-
 import argparse
 import importlib.util
 import json
@@ -28,6 +27,20 @@ import nbformat
 from .api_notebook_builder import FastAPINotebookBuilder
 from typing import Optional
 
+
+import os
+
+os.environ["JUPYTERHUB_USER"] = "jca92"
+os.environ["TOKEN"] = "token"
+os.environ["DB_URL"] = "https://engr-131-api.eastus.cloudapp.azure.com/"
+os.environ["keys_student"] = "capture"
+os.environ["user_name_student"] = "student"
+
+from pykubegrader.tokens.tokens import add_token
+
+add_token("token", duration=20)
+
+
 @dataclass
 class NotebookProcessor:
     """
@@ -46,6 +59,7 @@ class NotebookProcessor:
     solutions_folder: str = field(init=False)
     verbose: bool = False
     log: bool = True
+    require_key: bool = False
 
     def __post_init__(self):
         """
@@ -160,22 +174,21 @@ class NotebookProcessor:
 
         if self.check_if_file_in_folder("assignment_config.yaml"):
             self.add_assignment()
-            
+
         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(
-                    notebook_path = os.path.join(self.root_folder, key + '.ipynb'),
-                    assignment_points= value,
-                    assignment_tag = assignment_tag,
-                )
-                
-        
+                notebook_path=os.path.join(self.root_folder, key + ".ipynb"),
+                assignment_points=value,
+                assignment_tag=assignment_tag,
+            )
+
     def build_payload(self, yaml_content):
         """
         Reads YAML content for an assignment and returns Python variables.
@@ -216,6 +229,69 @@ class NotebookProcessor:
             "max_score": int(self.assignment_total_points),
         }
 
+    def build_payload_notebook(self, yaml_content, notebook_title, total_points):
+        # Parse the YAML content
+        with open(yaml_content, "r") as file:
+            data = yaml.safe_load(file)
+
+        # Extract assignment details
+        assignment = data.get("assignment", {})
+
+        week_num = self.week_num
+        assignment_type = self.assignment_type
+        due_date_str = assignment.get("due_date")
+
+        # Convert due_date to a datetime object if available
+        due_date = None
+        if due_date_str:
+            try:
+                due_date = parser.parse(due_date_str)  # Automatically handles timezones
+            except ValueError as e:
+                print(f"Error parsing due_date: {e}")
+
+        return {
+            "title": notebook_title,
+            "week_number": week_num,
+            "assignment_type": assignment_type,
+            "due_date": due_date,
+            "max_score": total_points,
+        }
+
+    def add_notebook(self, notebook_title, total_points):
+        """
+        Sends a POST request to add a notebook.
+        """
+        # Define the URL
+        url = "https://engr-131-api.eastus.cloudapp.azure.com/notebook"
+
+        # Build the payload
+        payload = self.build_payload_notebook(
+            yaml_content=f"{self.root_folder}/assignment_config.yaml",
+            notebook_title=notebook_title,
+            total_points=total_points,
+        )
+
+        # 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, default=self.json_serial)
+
+        # 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}")
+
     def add_assignment(self):
         """
         Sends a POST request to add an assignment.
@@ -437,10 +513,95 @@ class NotebookProcessor:
             + self.otter_total_points
         )
 
+        # creates the assignment record in the database
+        self.add_notebook(notebook_name, total_points)
+
         self.assignment_total_points += total_points
 
         self.total_point_log.update({notebook_name: total_points})
 
+        student_file_path = os.path.join(self.root_folder, notebook_name + ".ipynb")
+        self.add_submission_cells(student_file_path, student_file_path)
+        NotebookProcessor.remove_empty_cells(student_file_path)
+
+    @staticmethod
+    def remove_empty_cells(notebook_path, output_path=None):
+        """
+        Removes empty cells from a Jupyter Notebook and saves the updated notebook.
+
+        Parameters:
+            notebook_path (str): Path to the input Jupyter Notebook.
+            output_path (str): Path to save the updated Jupyter Notebook. If None, it overwrites the original file.
+        """
+        try:
+            # Load the notebook
+            with open(notebook_path, "r") as nb_file:
+                notebook = nbformat.read(nb_file, as_version=4)
+
+            # Filter out empty cells
+            non_empty_cells = [cell for cell in notebook.cells if cell.source.strip()]
+
+            # Update the notebook cells
+            notebook.cells = non_empty_cells
+
+            # Save the updated notebook
+            save_path = output_path if output_path else notebook_path
+            with open(save_path, "w") as nb_file:
+                nbformat.write(notebook, nb_file)
+
+            print(f"Empty cells removed. Updated notebook saved at: {save_path}")
+
+        except Exception as e:
+            print(f"An error occurred: {e}")
+
+    def add_submission_cells(self, notebook_path: str, output_path: str) -> None:
+        """
+        Adds submission cells to the end of a Jupyter notebook.
+
+        Args:
+            notebook_path (str): Path to the input notebook.
+            output_path (str): Path to save the modified notebook.
+        """
+        # Load the notebook
+        with open(notebook_path, "r", encoding="utf-8") as f:
+            notebook = nbformat.read(f, as_version=4)
+
+        # Define the Markdown cell
+        markdown_cell = nbformat.v4.new_markdown_cell(
+            "## Submitting Assignment\n\n"
+            "Please run the following block of code using `shift + enter` to submit your assignment, "
+            "you should see your score."
+        )
+
+        if self.require_key:
+            # Add an additional line for validate_token()
+            validate_token_line = "from pykubegrader.submit.submit_assignment import validate_token\nvalidate_token()\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", "")}")'
+            )
+        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", "")}")'
+            )
+
+        # Make the code cell non-editable and non-deletable
+        code_cell.metadata = {"editable": False, "deletable": False}
+        code_cell.metadata["tags"] = ["skip-execution"]
+
+        # Add the cells to the notebook
+        notebook.cells.append(markdown_cell)
+        notebook.cells.append(code_cell)
+
+        # Save the modified notebook
+        with open(output_path, "w", encoding="utf-8") as f:
+            nbformat.write(notebook, f)
+
     def free_response_parser(
         self, temp_notebook_path, notebook_subfolder, notebook_name
     ):
@@ -471,7 +632,9 @@ class NotebookProcessor:
             shutil.copy("./keys/.server_public_key.bin", server_public_key)
 
             out = FastAPINotebookBuilder(
-                notebook_path=temp_notebook_path, assignment_tag=self.assignment_tag
+                notebook_path=temp_notebook_path,
+                assignment_tag=self.assignment_tag,
+                require_key=self.require_key,
             )
 
             debug_notebook = os.path.join(
@@ -496,7 +659,10 @@ class NotebookProcessor:
             )
 
             NotebookProcessor.add_initialization_code(
-                student_notebook, self.week, self.assignment_type
+                student_notebook,
+                self.week,
+                self.assignment_type,
+                require_key=self.require_key,
             )
 
             NotebookProcessor.replace_temp_in_notebook(
@@ -523,7 +689,10 @@ class NotebookProcessor:
             return student_notebook, out.total_points
         else:
             NotebookProcessor.add_initialization_code(
-                temp_notebook_path, self.week, self.assignment_type
+                temp_notebook_path,
+                self.week,
+                self.assignment_type,
+                require_key=self.require_key,
             )
             NotebookProcessor.replace_temp_no_otter(
                 temp_notebook_path, temp_notebook_path
@@ -555,11 +724,19 @@ class NotebookProcessor:
             nbformat.write(notebook, f)
 
     @staticmethod
-    def add_initialization_code(notebook_path, week, assignment_type):
+    def add_initialization_code(
+        notebook_path, week, assignment_type, require_key=False
+    ):
         # finds the first code cell
         index, cell = find_first_code_cell(notebook_path)
         cell = cell["source"]
-        import_text = "from pykubegrader.initialize import initialize_assignment\n"
+        import_text = "# You must make sure to run all cells in sequence using shift + enter or you might encounter errors\n"
+        import_text += "from pykubegrader.initialize import initialize_assignment\n"
+        if require_key:
+            import_text += (
+                "from pykubegrader.token.validate_token import validate_token\n"
+            )
+            import_text += "validate_token('type the key provided by your TA here')\n"
         import_text += f'\nresponses = initialize_assignment("{os.path.splitext(os.path.basename(notebook_path))[0]}", "{week}", "{assignment_type}" )\n'
         cell = f"{import_text}\n" + cell
         replace_cell_source(notebook_path, index, cell)
@@ -675,7 +852,7 @@ class NotebookProcessor:
             return solution_path, question_path
         else:
             return None, None
-        
+
     @staticmethod
     def replace_temp_no_otter(input_file, output_file):
         # Load the notebook
@@ -685,8 +862,8 @@ class NotebookProcessor:
         # Iterate through the cells and modify `cell.source`
         for cell in notebook.cells:
             if cell.cell_type == "code":  # Only process code cells
-                if 'responses = initialize_assignment(' in cell.source:
-                    cell.source = cell.source.replace('_temp', '')
+                if "responses = initialize_assignment(" in cell.source:
+                    cell.source = cell.source.replace("_temp", "")
 
         # Save the modified notebook
         with open(output_file, "w", encoding="utf-8") as f:
@@ -715,7 +892,6 @@ class NotebookProcessor:
                 cell["source"] = [
                     line.replace("_temp.ipynb", ".ipynb") for line in cell["source"]
                 ]
-            
 
         # Write the updated notebook to the output file
         with open(output_file, "w", encoding="utf-8") as f:
@@ -1400,6 +1576,7 @@ def extract_MCQ(ipynb_file):
         print("Invalid JSON in notebook file.")
         return []
 
+
 def check_for_heading(notebook_path, search_strings):
     """
     Checks if a Jupyter notebook contains a heading cell whose source matches any of the given strings.
@@ -1439,8 +1616,6 @@ def clean_notebook(notebook_path):
                     cell.metadata["editable"] = cell.metadata.get("editable", False)
                     cell.metadata["deletable"] = cell.metadata.get("deletable", False)
                 if cell.cell_type == "code":
-                    if "grader.check(" in cell.source:
-                        continue
                     cell.metadata["tags"] = cell.metadata.get("tags", [])
                     if "skip-execution" not in cell.metadata["tags"]:
                         cell.metadata["tags"].append("skip-execution")
@@ -1606,7 +1781,9 @@ 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"{q_value['question_text']}",\n')
+                    f.write(
+                        f'            title=f"Question{q_value['question number']}: {q_value['title']}",\n'
+                    )
                     f.write("            style=MCQ,\n")
                     f.write(
                         f"            question_number={q_value['question number']},\n"
@@ -1677,7 +1854,9 @@ 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'{q_value['question_text']}',\n")
+                    f.write(
+                        f'            title=f"Question{q_value['question number']}: {q_value['title']}",\n'
+                    )
                     f.write("            style=MultiSelect,\n")
                     f.write(
                         f"            question_number={q_value['question number']},\n"
@@ -1754,7 +1933,9 @@ 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'{q_value['question_text']}',\n")
+                    f.write(
+                        f'            title=f"Question{q_value['question number']}: {q_value['title']}",\n'
+                    )
                     f.write("            style=TFStyle,\n")
                     f.write(
                         f"            question_number={q_value['question number']},\n"
@@ -1845,7 +2026,8 @@ def replace_cell_source(notebook_path, cell_index, new_source):
     # Save the notebook
     with open(notebook_path, "w", encoding="utf-8") as f:
         nbformat.write(notebook, f)
-        
+
+
 def update_initialize_assignment(
     notebook_path: str,
     assignment_points: Optional[float] = None,
@@ -1893,11 +2075,11 @@ def update_initialize_assignment(
                     existing_args = match.group(1).strip()
                     # Replace with the updated line
                     if additional_variables_str:
+                        updated_line = f"responses = initialize_assignment({existing_args}, {additional_variables_str})\n"
+                    else:
                         updated_line = (
-                            f"responses = initialize_assignment({existing_args}, {additional_variables_str})\n"
+                            f"responses = initialize_assignment({existing_args})\n"
                         )
-                    else:
-                        updated_line = f"responses = initialize_assignment({existing_args})\n"
                     source_code[i] = updated_line
                     updated = True
 
@@ -1925,9 +2107,18 @@ def main():
         default="Reading-Week-X",
     )
 
+    parser.add_argument(
+        "--require-key",
+        type=bool,
+        help="Require a key to be generated for the assignment",
+        default=False,
+    )
+
     args = parser.parse_args()
     processor = NotebookProcessor(
-        root_folder=args.root_folder, assignment_tag=args.assignment_tag
+        root_folder=args.root_folder,
+        assignment_tag=args.assignment_tag,
+        require_key=args.require_key,
     )
     processor.process_notebooks()
 

{pykubegrader-0.2.8 → pykubegrader-0.2.22}/src/pykubegrader/initialize.py

@@ -9,7 +9,7 @@ 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
 def initialize_assignment(
     name: str,
     week: str,
@@ -33,6 +33,9 @@ def initialize_assignment(
     Raises:
         Exception: If the environment is unsupported or initialization fails.
     """
+    
+    if assignment_tag is None:
+        assignment_tag = f"{week}-{assignment_type}"
 
     ipython = get_ipython()
     if ipython is None:

{pykubegrader-0.2.8 → pykubegrader-0.2.22}/src/pykubegrader/submit/submit_assignment.py

@@ -1,9 +1,10 @@
 import os
 import httpx
 import asyncio
-
 import nest_asyncio
+import base64
 
+# Apply nest_asyncio for environments like Jupyter
 nest_asyncio.apply()
 
 
@@ -21,7 +22,7 @@ def get_credentials():
 
 
 async def call_score_assignment(
-    assignment_title: str, file_path: str = ".output_reduced.log"
+    assignment_title: str, notebook_title: str, file_path: str = ".output_reduced.log"
 ) -> dict:
     """
     Submit an assignment to the scoring endpoint.
@@ -37,10 +38,17 @@ async def call_score_assignment(
     base_url = os.getenv("DB_URL")
     if not base_url:
         raise ValueError("Environment variable 'DB_URL' is not set.")
-    url = f"{base_url}score-assignment"
+    url = f"{base_url}score-assignment?assignment_title={assignment_title}&notebook_title={notebook_title}"
 
     # Get credentials
     credentials = get_credentials()
+    username = credentials["username"]
+    password = credentials["password"] 
+
+    # Encode credentials for Basic Authentication
+    auth_header = (
+        f"Basic {base64.b64encode(f'{username}:{password}'.encode()).decode()}"
+    )
 
     # Send the POST request
     async with httpx.AsyncClient() as client:
@@ -48,8 +56,8 @@ async def call_score_assignment(
             with open(file_path, "rb") as file:
                 response = await client.post(
                     url,
-                    data={"cred": credentials, "assignment_title": assignment_title},
-                    files={"log_file": file},
+                    headers={"Authorization": auth_header},  # Add Authorization header
+                    files={"log_file": file},  # Upload log file
                 )
 
                 # Handle the response
@@ -64,9 +72,10 @@ async def call_score_assignment(
             raise RuntimeError(f"An unexpected error occurred: {e}")
 
 
-# Importable function
 def submit_assignment(
-    assignment_title: str, file_path: str = ".output_reduced.log"
+    assignment_title: str,
+    notebook_title: str,
+    file_path: str = ".output_reduced.log",
 ) -> None:
     """
     Synchronous wrapper for the `call_score_assignment` function.
@@ -75,10 +84,20 @@ def submit_assignment(
         assignment_title (str): Title of the assignment.
         file_path (str): Path to the log file to upload.
     """
-    response = asyncio.run(call_score_assignment(assignment_title, file_path))
+    # Get the current event loop or create one
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+    # Run the async function in the event loop
+    response = loop.run_until_complete(
+        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("Week 1 Assignment", "path/to/your/log_file.txt")
+    submit_assignment("week1-readings", "path/to/your/log_file.txt")

pykubegrader-0.2.22/src/pykubegrader/tokens/tokens.py

@@ -0,0 +1,47 @@
+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}")

pykubegrader-0.2.22/src/pykubegrader/tokens/validate_token.py

@@ -0,0 +1,138 @@
+import os
+import base64
+import httpx
+import asyncio
+import nest_asyncio
+
+# Apply nest_asyncio for environments like Jupyter
+nest_asyncio.apply()
+
+
+class TokenValidationError(Exception):
+    """
+    Custom exception raised when the token validation fails.
+    """
+
+    def __init__(self, message=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():
+    """
+    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."
+        )
+    return {"username": username, "password": password}
+
+
+async def async_validate_token(token: str = None) -> None:
+    """
+    Asynchronously validate a token by making a GET request to the validation endpoint.
+
+    Args:
+        token (str): The token to validate.
+
+    Raises:
+        TokenValidationError: If the token is invalid or if there is an error in the validation process.
+
+    Returns:
+        None: If the token is valid, the function will pass silently.
+    """
+
+    if token is not None:
+        os.environ["TOKEN"] = token
+
+    if token is None:
+        token = os.getenv("TOKEN", None)
+
+    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.")
+    endpoint = f"{base_url}validate-token/{token}"
+
+    # Get credentials
+    credentials = get_credentials()
+    username = credentials["username"]
+    password = credentials["password"]
+
+    # Encode credentials for Basic Authentication
+    auth_header = (
+        f"Basic {base64.b64encode(f'{username}:{password}'.encode()).decode()}"
+    )
+
+    # Make the GET request
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.get(
+                endpoint, headers={"Authorization": auth_header}, timeout=10
+            )
+
+            if response.status_code == 200:
+                # If the response is 200, the token is valid
+                return  # Pass silently
+            elif response.status_code == 404:
+                # If the response is 404, the token is invalid
+                detail = response.json().get("detail", "Token not found")
+                raise TokenValidationError(detail)
+            else:
+                # Handle unexpected status codes
+                raise TokenValidationError(
+                    f"Unexpected response code: {response.status_code}"
+                )
+        except httpx.RequestError as e:
+            raise TokenValidationError(f"Request failed: {e}")
+        except Exception as e:
+            raise TokenValidationError(f"An unexpected error occurred: {e}")
+
+
+def validate_token(token: str = None) -> None:
+    """
+    Synchronous wrapper for the `async_validate_token` function.
+
+    Args:
+        token (str): The token to validate.
+
+    Raises:
+        TokenValidationError: If the token is invalid or if there is an error in the validation process.
+
+    Returns:
+        None: If the token is valid, the function will pass silently.
+    """
+
+    # Get the current event loop or create one
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+    # Run the async function in the event loop
+    loop.run_until_complete(async_validate_token(token))
+
+
+# Example usage
+if __name__ == "__main__":
+    token = "test"
+    try:
+        validate_token(token)
+        print("Token is valid.")
+    except TokenValidationError as e:
+        print(f"Token validation failed: {e}")