feat: version 0.1.4, fix bug by removing try-finally

Author: ryanlinjui

pyproject.toml

@@ -3,7 +3,7 @@ homepage = "https://github.com/ryanlinjui/cpGrader"
 
 [tool.poetry]
 name = "cpGrader"
-version = "0.1.3"
+version = "0.1.4"
 description = "A Python Package to Grade Programming Assignments Automatically."
 authors = ["ryanlinjui <ryanlinjui@gmail.com>"]
 readme = "README.md"

src/cpGrader/cpGrader.py

@@ -5,7 +5,8 @@
 from typing import (
     List,
     Callable,
-    Union
+    Union,
+    Optional
 )
 
 import toml
@@ -28,10 +29,7 @@
 )
 
 class Grader:
-    def __init__(
-        self,
-        config_file: Union[str, None] = DEFAULT_CONFIG_FILE
-    ):
+    def __init__(self, config_file: Optional[str] = DEFAULT_CONFIG_FILE):
         self.grade_report: List[List[str]] = []
 
         # Initialize Test Cases Configuration
@@ -41,7 +39,6 @@ def __init__(
             self.__read_config(config_file)
 
     def __read_config(self, config_file: str) -> None:
-        
         config = toml.load(config_file)
 
         # Global Test Cases Configuration
@@ -83,17 +80,12 @@ def __read_config(self, config_file: str) -> None:
                 )
             )
 
-    def setcase(
-        self,
-        match_case: Union[str, List[str]] = ALL_MATCH_CASE
-    ) -> Callable:
-        
+    def setcase(self, match_case: Union[str, List[str]] = ALL_MATCH_CASE) -> Callable:
         def wrapper(func: Callable) -> None:
             match_case_list = match_case if isinstance(match_case, list) else [match_case]
             for _case in self.case_list:
                 if any(fnmatch.fnmatchcase(_case.name, name) for name in match_case_list):
                     _case.verify_func = func
-
         return wrapper
 
     def run(
@@ -128,7 +120,9 @@ def run(
 
             # Build Student File
             logging.info(f"Building {student_id}: {not disable_build}")
-            if disable_build: continue
+            if disable_build: 
+                continue
+            
             build(folder=student_dir, copy_file=self.support_files)
 
             # Execute and Verify Student File
@@ -140,15 +134,14 @@ def run(
                     exception_signal = _case.execute(student_dir=student_dir)
 
                 logging.info(f"Verifying: {student_id}: {not disable_verify}, case: {_case.name}, exception: {exception_signal}")
-                if exception_signal == ExecuteException.NoFile: break
-                elif disable_verify or exception_signal != None: continue
+                if exception_signal == ExecuteException.NoFile: 
+                    break
+                elif disable_verify or exception_signal != None: 
+                    continue
 
                 _case.verify()
 
             logging.info(f"Grading Complete: {student_id}, grade report: {self.grade_report[-1]}")
 
         logging.info(f"Generating Grade Report: {save_path}")
-        grade(
-            grade_report=self.grade_report,
-            save_path=save_path
-        )
+        grade(grade_report=self.grade_report, save_path=save_path)

src/cpGrader/testcase.py

@@ -6,7 +6,8 @@
 from typing import (
     List,
     Callable,
-    Union
+    Union,
+    Optional
 )
 
 from .utils import (
@@ -23,25 +24,24 @@ class Case:
     def __init__(
         self,
         name: str,
-        case_file: Union[str, None],
-        command: Union[str, None],
+        case_file: Optional[str],
+        command: Optional[str],
         pts: Union[int, float],
-        correct_file: Union[str, None],
-        verify_func: Union[Callable, None]
+        correct_file: Optional[str],
+        verify_func: Optional[Callable]
     ):
         self.name: str = name
-        self.case_file: Union[str, None] = case_file
-        self.command: Union[str, None] = command
+        self.case_file: Optional[str] = case_file
+        self.command: Optional[str] = command
         self.pts: Union[int, float] = pts
-        self.correct_file: Union[str, None] = correct_file
-        self.verify_func: Union[Callable, None] = verify_func
+        self.correct_file: Optional[str] = correct_file
+        self.verify_func: Optional[Callable] = verify_func
 
         self.case_data: List[str] = []
         self.student_output: str = ""
         self.correct_output: str = ""
 
     def __correct_setup(self) -> None:
-
         # No correct file
         if self.correct_file == None:
             logging.debug(f"No correct file")
@@ -61,12 +61,8 @@ def __correct_setup(self) -> None:
 
         if correct_file.endswith(".c"):  # C correct program
             logging.debug(f"C correct program runnning")
-            
             logging.debug(f"Buidling: {correct_dir}, support_files: {support_files}")
-            build(
-                folder=correct_dir,
-                copy_file=support_files
-            )
+            build(folder=correct_dir, copy_file=support_files)
 
             command = f"./{correct_file}".replace(".c", "")
             logging.debug(f"Execute: {correct_dir}, command: {command}")
@@ -79,23 +75,21 @@ def __correct_setup(self) -> None:
 
         elif correct_file.endswith(".py"): # Python correct program
             logging.debug(f"Python correct program running")
-
             command = f"{executable} {correct_file}"
             logging.debug(f"Excute: {correct_dir}, command: {command}")
             self.correct_output = execute(
                 folder=correct_dir,
                 command=command,
                 stdin_list=self.case_data
             )
-
             logging.debug(f"Python correct program finished")
 
         output_filepath = os.path.join(correct_dir, f"{self.name}.txt")
         logging.debug(f"Write correct output: {output_filepath}")
         with open(output_filepath, "w+") as f:
             f.write(self.correct_output)
 
-    def execute(self, student_dir: str) -> Union[None, ExecuteException]:
+    def execute(self, student_dir: str) -> Optional[ExecuteException]:
         # setup case data and build/execute correct file
         if self.case_file != None:
             self.case_data = [line.strip() for line in open(self.case_file, "r").readlines()]
@@ -130,23 +124,25 @@ def execute(self, student_dir: str) -> Union[None, ExecuteException]:
                 comment = f"{self.name}: {comment}"
             exception_signal = ExecuteException.ProgramError
 
-        finally:
-            if len(output) > MAX_OUTPUT_SIZE:
-                logging.warning(f"In {student_dir}, {self.name}: outputs are truncated to {MAX_OUTPUT_SIZE} characters")
-                output = output[:MAX_OUTPUT_SIZE]
-
-            output_filepath = os.path.join(student_dir, f"{self.name}.txt")
-            logging.debug(f"Write student output: {output_filepath}")
-            with open(output_filepath, "w+") as f:
-                f.write(output)
-            self.student_output = output
-    
-            # Append to grade report
-            logging.debug(f"Exception Signal: {exception_signal}")
-            if exception_signal:
-                (lambda x: (x[1].append(0), x[2].append(comment), x))(currentframe().f_back.f_locals["self"].grade_report[-1])
-            
-            return exception_signal
+        except Exception as e:
+            logging.error(f"Exception: {str(e)}")
+
+        if len(output) > MAX_OUTPUT_SIZE:
+            logging.warning(f"In {student_dir}, {self.name}: outputs are truncated to {MAX_OUTPUT_SIZE} characters")
+            output = output[:MAX_OUTPUT_SIZE]
+
+        output_filepath = os.path.join(student_dir, f"{self.name}.txt")
+        logging.debug(f"Write student output: {output_filepath}")
+        with open(output_filepath, "w+") as f:
+            f.write(output)
+        self.student_output = output
+
+        # Append to grade report
+        logging.debug(f"Exception Signal: {exception_signal}")
+        if exception_signal:
+            (lambda x: (x[1].append(0), x[2].append(comment), x))(currentframe().f_back.f_locals["self"].grade_report[-1])
+        
+        return exception_signal
 
     def verify(self) -> None:
         if self.verify_func == None:

src/cpGrader/utils.py

@@ -17,7 +17,6 @@ def extract(src_folder:str, dest_folder:str) -> list:
     target_key = ["*akefile", "hw0*0*.c", "README*", "bonus*", "*.pdf"]
     filter_dir = ["__MACOSX", ".vscode"]
     exclude_folder_name = ["NTU", "NTUST"]
-
     student_list = []
 
     root = os.getcwd()
@@ -166,11 +165,7 @@ def execute(folder:str, command:str, stdin_list:list=[]) -> str:
 
     return output
 
-def grade(
-    grade_report: List[Tuple[str, List[Union[int, str]], List[str]]],
-    save_path: str
-) -> None:
-
+def grade(grade_report: List[Tuple[str, List[Union[int, str]], List[str]]], save_path: str) -> None:
     for student in grade_report:
         student[1] = sum(student[1])
         student[2] = "\n".join(student[2])