Support define grader by input function

Author: Mr-Python-in-China

cyaron/compare.py

@@ -9,7 +9,7 @@
 from typing import List, Optional, Tuple, Union
 
 from cyaron.consts import *
-from cyaron.graders import CYaRonGraders
+from cyaron.graders import CYaRonGraders, GraderType
 from cyaron.utils import *
 
 from . import log
@@ -27,11 +27,14 @@ def __str__(self):
         return "In program: '{}'. {}".format(self.name, self.mismatch)
 
 
+PrgoramType = Optional[Union[str, Tuple[str, ...], List[str]]]
+
+
 class Compare:
 
     @staticmethod
     def __compare_two(name, content, std, grader):
-        (result, info) = CYaRonGraders.invoke(grader, content, std)
+        result, info = CYaRonGraders.invoke(grader, content, std)
         status = "Correct" if result else "!!!INCORRECT!!!"
         info = info if info is not None else ""
         log.debug("{}: {} {}".format(name, status, info))
@@ -85,8 +88,6 @@ def output(cls, *files, **kwargs):
         if (max_workers is None or max_workers >= 0) and job_pool is None:
             max_workers = cls.__normal_max_workers(max_workers)
             try:
-                from concurrent.futures import ThreadPoolExecutor
-
                 with ThreadPoolExecutor(max_workers=max_workers) as job_pool:
                     return cls.output(*files,
                                       std=std,
@@ -115,12 +116,12 @@ def do(file):
 
     @classmethod
     def program(cls,
-                *programs: Optional[Union[str, Tuple[str, ...], List[str]]],
+                *programs: Union[PrgoramType, Tuple[PrgoramType, float]],
                 input: Union[IO, str],
                 std: Optional[Union[str, IO]] = None,
                 std_program: Optional[Union[str, Tuple[str, ...],
                                             List[str]]] = None,
-                grader: Optional[str] = DEFAULT_GRADER,
+                grader: Union[str, GraderType] = DEFAULT_GRADER,
                 max_workers: int = -1,
                 job_pool: Optional[ThreadPoolExecutor] = None,
                 stop_on_incorrect=None):
@@ -212,13 +213,13 @@ def do(program_name):
                     )
                 else:
                     content = subprocess.check_output(
-                            program_name,
-                            shell=(not list_like(program_name)),
-                            stdin=input_file,
-                            universal_newlines=True,
-                            timeout=timeout,
-                            encoding="utf-8",
-                        )
+                        program_name,
+                        shell=(not list_like(program_name)),
+                        stdin=input_file,
+                        universal_newlines=True,
+                        timeout=timeout,
+                        encoding="utf-8",
+                    )
                 cls.__compare_two(program_name, content, std, grader)
 
             if job_pool is not None:

cyaron/graders/__init__.py

@@ -1,4 +1,4 @@
-from .graderregistry import CYaRonGraders
+from .graderregistry import CYaRonGraders, GraderType
 
 from .fulltext import fulltext
 from .noipstyle import noipstyle

cyaron/graders/graderregistry.py

@@ -1,18 +1,32 @@
+from typing import Callable, Tuple, Dict, Union
+
+__all__ = ['CYaRonGraders', 'GraderType']
+
+GraderType = Callable[[str, str], Tuple[bool, Union[str, None]]]
+
+
 class GraderRegistry:
-    _registry = dict()
+    """A registry for grader functions."""
+    _registry: Dict[str, GraderType] = {}
 
-    def grader(self, name):
+    def grader(self, name: str):
+        """A decorator to register a grader function."""
 
-        def wrapper(func):
+        def wrapper(func: GraderType):
             self._registry[name] = func
             return func
 
         return wrapper
 
-    def invoke(self, name, content, std):
-        return self._registry[name](content, std)
+    def invoke(self, grader: Union[str, GraderType], content: str, std: str):
+        """Invoke a grader function by name or function object."""
+        if isinstance(grader, str):
+            return self._registry[grader](content, std)
+        else:
+            return grader(content, std)
 
     def check(self, name):
+        """Check if a grader is registered."""
         return name in self._registry
 
 

cyaron/tests/compare_test.py

@@ -8,6 +8,7 @@
 from cyaron.output_capture import captured_output
 from cyaron.graders.mismatch import *
 from cyaron.compare import CompareMismatch
+from cyaron.graders import CYaRonGraders
 
 log.set_verbose()
 
@@ -176,3 +177,56 @@ def test_timeout(self):
                     pass
                 else:
                     self.assertTrue(False)
+
+    def test_custom_grader_by_name(self):
+
+        @CYaRonGraders.grader("CustomTestGrader")
+        def custom_test_grader(content: str, std: str):
+            if content == '1\n' and std == '2\n':
+                return True, None
+            return False, "CustomTestGrader failed"
+
+        io = IO()
+        io.output_writeln("2")
+
+        Compare.program("echo 1",
+                        std=io,
+                        input=IO(),
+                        grader="CustomTestGrader")
+
+        try:
+            Compare.program("echo 2",
+                            std=io,
+                            input=IO(),
+                            grader="CustomTestGrader")
+        except CompareMismatch as e:
+            self.assertEqual(e.name, 'echo 2')
+            self.assertEqual(e.mismatch, "CustomTestGrader failed")
+        else:
+            self.fail("Should raise CompareMismatch")
+
+    def test_custom_grader_by_function(self):
+
+        def custom_test_grader(content: str, std: str):
+            if content == '1\n' and std == '2\n':
+                return True, None
+            return False, "CustomTestGrader failed"
+
+        io = IO()
+        io.output_writeln("2")
+
+        Compare.program("echo 1",
+                        std=io,
+                        input=IO(),
+                        grader=custom_test_grader)
+
+        try:
+            Compare.program("echo 2",
+                            std=io,
+                            input=IO(),
+                            grader=custom_test_grader)
+        except CompareMismatch as e:
+            self.assertEqual(e.name, 'echo 2')
+            self.assertEqual(e.mismatch, "CustomTestGrader failed")
+        else:
+            self.fail("Should raise CompareMismatch")