Added time limit for io

Author: AlfredChester

cyaron/compare.py

@@ -17,7 +17,7 @@ def __init__(self, name, mismatch):
         self.mismatch = mismatch
 
     def __str__(self):
-        return "In program: '{}'. {}".format(self.name, self.mismatch)
+        return 'In program: \'{}\'. {}'.format(self.name,self.mismatch)
 
 
 class Compare:
@@ -37,7 +37,7 @@ def __process_file(file):
             file.output_file.seek(0)
             return file.output_filename, file.output_file.read()
         else:
-            with open(file, "r", newline="\n") as f:
+            with open(file, "r", newline='\n') as f:
                 return file, f.read()
 
     @staticmethod
@@ -50,43 +50,26 @@ def __normal_max_workers(workers):
 
     @classmethod
     def output(cls, *files, **kwargs):
-        kwargs = unpack_kwargs(
-            "output",
-            kwargs,
-            (
-                "std",
-                ("grader", DEFAULT_GRADER),
-                ("max_workers", -1),
-                ("job_pool", None),
-                ("stop_on_incorrect", None),
-            ),
-        )
-        std = kwargs["std"]
-        grader = kwargs["grader"]
-        max_workers = kwargs["max_workers"]
-        job_pool = kwargs["job_pool"]
-        if kwargs["stop_on_incorrect"] is not None:
+        kwargs = unpack_kwargs('output', kwargs, ('std', ('grader', DEFAULT_GRADER), ('max_workers', -1),
+                                                  ('job_pool', None), ('stop_on_incorrect', None)))
+        std = kwargs['std']
+        grader = kwargs['grader']
+        max_workers = kwargs['max_workers']
+        job_pool = kwargs['job_pool']
+        if kwargs['stop_on_incorrect'] is not None:
             log.warn("parameter stop_on_incorrect is deprecated and has no effect.")
 
         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,
-                        grader=grader,
-                        max_workers=max_workers,
-                        job_pool=job_pool
-                    )
+                    return cls.output(*files, std=std, grader=grader, max_workers=max_workers, job_pool=job_pool)
             except ImportError:
                 pass
 
         def get_std():
             return cls.__process_file(std)[1]
-
         if job_pool is not None:
             std = job_pool.submit(get_std).result()
         else:
@@ -103,121 +86,61 @@ def do(file):
 
     @classmethod
     def program(cls, *programs, **kwargs):
-        kwargs = unpack_kwargs(
-            "program",
-            kwargs,
-            (
-                "input",
-                ("std", None),
-                ("std_program", None),
-                ("grader", DEFAULT_GRADER),
-                ("max_workers", -1),
-                ("job_pool", None),
-                ("stop_on_incorrect", None),
-            ),
-        )
-        input = kwargs["input"]
-        std = kwargs["std"]
-        std_program = kwargs["std_program"]
-        grader = kwargs["grader"]
-        max_workers = kwargs["max_workers"]
-        job_pool = kwargs["job_pool"]
-        time_limit = kwargs["time_limit"]
-        memory_limit = kwargs["memory_limit"]
-
-        if kwargs["stop_on_incorrect"] is not None:
+        kwargs = unpack_kwargs('program', kwargs, ('input', ('std', None), ('std_program', None),
+                                                   ('grader', DEFAULT_GRADER), ('max_workers', -1),
+                                                   ('job_pool', None), ('stop_on_incorrect', None)))
+        input = kwargs['input']
+        std = kwargs['std']
+        std_program = kwargs['std_program']
+        grader = kwargs['grader']
+        max_workers = kwargs['max_workers']
+        job_pool = kwargs['job_pool']
+        if kwargs['stop_on_incorrect'] is not None:
             log.warn("parameter stop_on_incorrect is deprecated and has no effect.")
 
         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.program(
-                        *programs,
-                        input=input,
-                        std=std,
-                        std_program=std_program,
-                        grader=grader,
-                        max_workers=max_workers,
-                        job_pool=job_pool
-                    )
+                    return cls.program(*programs, input=input, std=std, std_program=std_program, grader=grader, max_workers=max_workers, job_pool=job_pool)
             except ImportError:
                 pass
 
         if not isinstance(input, IO):
-            raise TypeError(
-                "expect {}, got {}".format(type(IO).__name__, type(input).__name__)
-            )
+            raise TypeError("expect {}, got {}".format(type(IO).__name__, type(input).__name__))
         input.flush_buffer()
         input.input_file.seek(0)
 
         if std_program is not None:
-
             def get_std():
-                with open(
-                    os.dup(input.input_file.fileno()), "r", newline="\n"
-                ) as input_file:
-                    content = make_unicode(
-                        subprocess.check_output(
-                            std_program,
-                            shell=(not list_like(std_program)),
-                            stdin=input.input_file,
-                            universal_newlines=True,
-                        )
-                    )
+                with open(os.dup(input.input_file.fileno()), 'r', newline='\n') as input_file:
+                    content = make_unicode(subprocess.check_output(std_program, shell=(not list_like(std_program)), stdin=input.input_file, universal_newlines=True))
                     input_file.seek(0)
                 return content
-
             if job_pool is not None:
                 std = job_pool.submit(get_std).result()
             else:
                 std = get_std()
         elif std is not None:
-
             def get_std():
                 return cls.__process_file(std)[1]
-
             if job_pool is not None:
                 std = job_pool.submit(get_std).result()
             else:
                 std = get_std()
         else:
-            raise TypeError(
-                "program() missing 1 required non-None keyword-only argument: 'std' or 'std_program'"
-            )
+            raise TypeError('program() missing 1 required non-None keyword-only argument: \'std\' or \'std_program\'')
 
         def do(program_name):
             timeout = None
-            if (
-                list_like(program_name)
-                and len(program_name) == 2
-                and int_like(program_name[-1])
-            ):
+            if list_like(program_name) and len(program_name) == 2 and int_like(program_name[-1]):
                 program_name, timeout = program_name
-            with open(
-                os.dup(input.input_file.fileno()), "r", newline="\n"
-            ) as input_file:
+            with open(os.dup(input.input_file.fileno()), 'r', newline='\n') as input_file:
                 if timeout is None:
-                    content = make_unicode(
-                        subprocess.check_output(
-                            program_name,
-                            shell=(not list_like(program_name)),
-                            stdin=input_file,
-                            universal_newlines=True,
-                        )
-                    )
+                    content = make_unicode(subprocess.check_output(program_name, shell=(not list_like(program_name)), stdin=input_file, universal_newlines=True))
                 else:
-                    content = make_unicode(
-                        subprocess.check_output(
-                            program_name,
-                            shell=(not list_like(program_name)),
-                            stdin=input_file,
-                            universal_newlines=True,
-                            timeout=timeout,
-                        )
-                    )
+                    content = make_unicode(subprocess.check_output(program_name, shell=(not list_like(program_name)), stdin=input_file, universal_newlines=True, timeout=timeout))
                 input_file.seek(0)
             cls.__compare_two(program_name, content, std, grader)
 

cyaron/consts.py

@@ -18,7 +18,7 @@
 ALPHABET_CAPITAL = string.ascii_uppercase
 ALPHABET = ALPHABET_SMALL + ALPHABET_CAPITAL
 NUMBERS = string.digits
-SENTENCE_SEPARATORS = ",,,,,,,;;:"  # 70% ',' 20% ';' 10% ':'
-SENTENCE_TERMINATORS = "....!"  # 80% '.' 20% '!'
+SENTENCE_SEPARATORS = ',,,,,,,;;:' # 70% ',' 20% ';' 10% ':'
+SENTENCE_TERMINATORS = '....!' # 80% '.' 20% '!'
 
 DEFAULT_GRADER = "NOIPStyle"

cyaron/graders/fulltext.py

@@ -2,13 +2,9 @@
 from .graderregistry import CYaRonGraders
 from .mismatch import HashMismatch
 
-
 @CYaRonGraders.grader("FullText")
 def fulltext(content, std):
-    content_hash = hashlib.sha256(content.encode("utf-8")).hexdigest()
-    std_hash = hashlib.sha256(std.encode("utf-8")).hexdigest()
-    return (
-        (True, None)
-        if content_hash == std_hash
-        else (False, HashMismatch(content, std, content_hash, std_hash))
-    )
+    content_hash = hashlib.sha256(content.encode('utf-8')).hexdigest()
+    std_hash = hashlib.sha256(std.encode('utf-8')).hexdigest()
+    return (True, None) if content_hash == std_hash else (False, HashMismatch(content, std, content_hash, std_hash))
+

cyaron/graders/graderregistry.py

@@ -15,4 +15,4 @@ def check(self, name):
         return name in self._registry
 
 
-CYaRonGraders = GraderRegistry()
+CYaRonGraders = GraderRegistry()

cyaron/graders/mismatch.py

@@ -1,6 +1,5 @@
 class Mismatch(ValueError):
     """exception for content mismatch"""
-
     def __init__(self, content, std, *args):
         """
         content -> content got
@@ -10,10 +9,8 @@ def __init__(self, content, std, *args):
         self.content = content
         self.std = std
 
-
 class HashMismatch(Mismatch):
     """exception for hash mismatch"""
-
     def __init__(self, content, std, content_hash, std_hash):
         """
         content -> content got
@@ -26,25 +23,11 @@ def __init__(self, content, std, content_hash, std_hash):
         self.std_hash = std_hash
 
     def __str__(self):
-        return "Hash mismatch: read %s, expected %s" % (
-            self.content_hash,
-            self.std_hash,
-        )
-
+        return "Hash mismatch: read %s, expected %s" % (self.content_hash, self.std_hash)
 
 class TextMismatch(Mismatch):
     """exception for text mismatch"""
-
-    def __init__(
-        self,
-        content,
-        std,
-        err_msg,
-        lineno=None,
-        colno=None,
-        content_token=None,
-        std_token=None,
-    ):
+    def __init__(self, content, std, err_msg, lineno=None, colno=None, content_token=None, std_token=None):
         """
         content -> content got
         std -> content expected
@@ -54,9 +37,7 @@ def __init__(
         content_token -> the token of content mismatch
         std_token -> the token of std
         """
-        super(TextMismatch, self).__init__(
-            content, std, err_msg, lineno, colno, content_token, std_token
-        )
+        super(TextMismatch, self).__init__(content, std, err_msg, lineno, colno, content_token, std_token)
         self.err_msg = err_msg.format(lineno, colno, content_token, std_token)
         self.lineno = lineno
         self.colno = colno

cyaron/graders/noipstyle.py

@@ -5,46 +5,28 @@
 
 @CYaRonGraders.grader("NOIPStyle")
 def noipstyle(content, std):
-    content_lines = strtolines(content.replace("\r\n", "\n"))
-    std_lines = strtolines(std.replace("\r\n", "\n"))
+    content_lines = strtolines(content.replace('\r\n', '\n'))
+    std_lines = strtolines(std.replace('\r\n', '\n'))
     if len(content_lines) != len(std_lines):
-        return False, TextMismatch(content, std, "Too many or too few lines.")
+        return False, TextMismatch(content, std, 'Too many or too few lines.')
 
     for i in range(len(content_lines)):
         if std_lines[i] != content_lines[i]:
             for j in range(min(len(std_lines[i]), len(content_lines[i]))):
                 if std_lines[i][j] != content_lines[i][j]:
-                    return (
-                        False,
-                        TextMismatch(
-                            content,
-                            std,
-                            "On line {} column {}, read {}, expected {}.",
-                            i + 1,
-                            j + 1,
-                            content_lines[i][j : j + 5],
-                            std_lines[i][j : j + 5],
-                        ),
-                    )
+                    return (False,
+                            TextMismatch(
+                                content, std,
+                                'On line {} column {}, read {}, expected {}.',
+                                i + 1, j + 1, content_lines[i][j:j + 5],
+                                std_lines[i][j:j + 5]))
             if len(std_lines[i]) > len(content_lines[i]):
                 return False, TextMismatch(
-                    content,
-                    std,
-                    "Too short on line {}.",
-                    i + 1,
-                    j + 1,
-                    content_lines[i][j : j + 5],
-                    std_lines[i][j : j + 5],
-                )
+                    content, std, 'Too short on line {}.', i + 1, j + 1,
+                    content_lines[i][j:j + 5], std_lines[i][j:j + 5])
             if len(std_lines[i]) < len(content_lines[i]):
                 return False, TextMismatch(
-                    content,
-                    std,
-                    "Too long on line {}.",
-                    i + 1,
-                    j + 1,
-                    content_lines[i][j : j + 5],
-                    std_lines[i][j : j + 5],
-                )
+                    content, std, 'Too long on line {}.', i + 1, j + 1,
+                    content_lines[i][j:j + 5], std_lines[i][j:j + 5])
 
     return True, None