Formatted code

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,26 +50,43 @@ 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:
@@ -86,61 +103,121 @@ 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']
-        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"]
+        time_limit = kwargs["time_limit"]
+        memory_limit = kwargs["memory_limit"]
+
+        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,9 +2,13 @@
 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,5 +1,6 @@
 class Mismatch(ValueError):
     """exception for content mismatch"""
+
     def __init__(self, content, std, *args):
         """
         content -> content got
@@ -9,8 +10,10 @@ 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
@@ -23,11 +26,25 @@ 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
@@ -37,7 +54,9 @@ def __init__(self, content, std, err_msg, lineno=None, colno=None, content_token
         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,28 +5,46 @@
 
 @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