sinol-make 1.5.28__tar.gz → 1.6.0.dev1__tar.gz

{sinol_make-1.5.28/src/sinol_make.egg-info → sinol_make-1.6.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sinol_make
-Version: 1.5.28
+Version: 1.6.0.dev1
 Summary: CLI tool for creating sio2 task packages
 Author: Mateusz Masiarz
 Author-email: m.masiarz@fri.edu.pl
@@ -21,6 +21,7 @@ Requires-Dist: PyYAML
 Requires-Dist: dictdiffer
 Requires-Dist: importlib-resources
 Requires-Dist: psutil
+Requires-Dist: packaging
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-cov; extra == "tests"

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/setup.cfg

@@ -29,6 +29,7 @@ install_requires =
 	dictdiffer
 	importlib-resources
 	psutil
+	packaging
 
 [options.packages.find]
 where = src

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/__init__.py

@@ -6,7 +6,7 @@ import argcomplete
 
 from sinol_make import util, oiejq
 
-__version__ = "1.5.28"
+__version__ = "1.6.0.dev1"
 
 
 def configure_parsers():
@@ -79,6 +79,9 @@ def main_exn():
 def main():
     new_version = None
     try:
+        if util.is_dev(__version__):
+            print(util.warning('You are using a development version of sinol-make. '
+                               'It may be unstable and contain bugs.'))
         new_version = util.check_for_updates(__version__)
         main_exn()
     except argparse.ArgumentError as err:
@@ -92,6 +95,12 @@ def main():
                              'https://github.com/sio2project/sinol-make/#reporting-bugs-and-contributing-code')
     finally:
         if new_version is not None:
-            print(util.warning(
-                f'New version of sinol-make is available (your version: {__version__}, available version: '
-                f'{new_version}).\nYou can update it by running `pip3 install sinol-make --upgrade`.'))
+            if not util.is_dev(new_version):
+                print(util.warning(
+                    f'New version of sinol-make is available (your version: {__version__}, available version: '
+                    f'{new_version}).\nYou can update it by running `pip3 install sinol-make --upgrade`.'))
+            elif util.is_dev(new_version):
+                print(util.warning(
+                    f'New development version of sinol-make is available (your version: {__version__}, available '
+                    f'version: {new_version}).\nYou can update it by running `pip3 install sinol-make --pre --upgrade`.'
+                ))

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/commands/doc/__init__.py

@@ -76,6 +76,7 @@ class Command(BaseCommand):
                                  ' pdflatex - uses pdflatex. Works with .png and .jpg images.\n'
                                  ' latex_dvi - uses latex and dvipdf. Works with .ps and .eps images.', default='auto')
         parser.add_argument('files', type=str, nargs='*', help='files to compile')
+        return parser
 
     def run(self, args: argparse.Namespace):
         args = util.init_package_command(args)

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/commands/export/__init__.py

@@ -37,6 +37,7 @@ class Command(BaseCommand):
         parser.add_argument('--export-ocen', dest='export_ocen', action='store_true',
                             help='Create ocen archive')
         parsers.add_compilation_arguments(parser)
+        return parser
 
     def generate_input_tests(self):
         print('Generating tests...')

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/commands/gen/__init__.py

@@ -37,7 +37,11 @@ class Command(BaseCommand):
                             default=util.default_cpu_count())
         parser.add_argument('-n', '--no-validate', default=False, action='store_true',
                             help='do not validate test contents')
+        parser.add_argument('-f', '--fsanitize', default=False, action='store_true',
+                            help='Use -fsanitize=address,undefined for ingen compilation. Warning: this may fail on some '
+                                 'systems. To fix this, run `sudo sysctl vm.mmap_rnd_bits = 28`.')
         parsers.add_compilation_arguments(parser)
+        return parser
 
     def run(self, args: argparse.Namespace):
         args = util.init_package_command(args)

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/commands/ingen/__init__.py

@@ -30,7 +30,11 @@ class Command(BaseCommand):
                             help='path to ingen source file, for example prog/abcingen.cpp')
         parser.add_argument('-n', '--no-validate', default=False, action='store_true',
                             help='do not validate test contents')
+        parser.add_argument('-f', '--fsanitize', default=False, action='store_true',
+                            help='Use -fsanitize=address,undefined for compilation. Warning: this may fail on some '
+                                 'systems. Tof fix this, run `sudo sysctl vm.mmap_rnd_bits = 28`.')
         parsers.add_compilation_arguments(parser)
+        return parser
 
     def run(self, args: argparse.Namespace):
         args = util.init_package_command(args)
@@ -42,7 +46,7 @@ class Command(BaseCommand):
         util.change_stack_size_to_unlimited()
         self.ingen = get_ingen(self.task_id, args.ingen_path)
         print(util.info(f'Using ingen file {os.path.basename(self.ingen)}'))
-        self.ingen_exe = compile_ingen(self.ingen, self.args, self.args.compile_mode)
+        self.ingen_exe = compile_ingen(self.ingen, self.args, self.args.compile_mode, self.args.fsanitize)
 
         previous_tests = []
         try:

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/commands/ingen/ingen_util.py

@@ -47,7 +47,7 @@ def get_ingen(task_id, ingen_path=None):
     return correct_ingen
 
 
-def compile_ingen(ingen_path: str, args: argparse.Namespace, compilation_flags='default'):
+def compile_ingen(ingen_path: str, args: argparse.Namespace, compilation_flags='default', use_fsanitize=False):
     """
     Compiles ingen and returns path to compiled executable.
     If ingen_path is shell script, then it will be returned.
@@ -56,8 +56,9 @@ def compile_ingen(ingen_path: str, args: argparse.Namespace, compilation_flags='
         return ingen_path
 
     compilers = compiler.verify_compilers(args, [ingen_path])
-    ingen_exe, compile_log_path = compile.compile_file(ingen_path, package_util.get_executable(ingen_path), compilers,
-                                                       compilation_flags, use_fsanitize=True)
+    ingen_exe, compile_log_path = compile.compile_file(ingen_path, package_util.get_executable(ingen_path),
+                                                       compilers, compilation_flags, use_fsanitize=use_fsanitize,
+                                                       additional_flags='-D_INGEN')
 
     if ingen_exe is None:
         compile.print_compile_log(compile_log_path)
@@ -85,11 +86,21 @@ def run_ingen(ingen_exe, working_dir=None):
     print(util.bold(' Ingen output '.center(util.get_terminal_size()[1], '=')))
     process = subprocess.Popen([ingen_exe], stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
                                cwd=working_dir, shell=is_shell)
+    whole_output = ''
     while process.poll() is None:
-        print(process.stdout.readline().decode('utf-8'), end='')
-
-    print(process.stdout.read().decode('utf-8'), end='')
+        out = process.stdout.readline().decode('utf-8')
+        if out != '':
+            print(out, end='')
+            whole_output += out
+    out = process.stdout.read().decode('utf-8')
+    whole_output += out
+    print(out, end='')
     exit_code = process.returncode
     print(util.bold(' End of ingen output '.center(util.get_terminal_size()[1], '=')))
 
+    if util.has_sanitizer_error(whole_output, exit_code):
+        print(util.warning('Warning: if ingen failed due to sanitizer errors, you can either run '
+                           '`sudo sysctl vm.mmap_rnd_bits = 28` to fix this or disable sanitizers with the '
+                           '--no-fsanitize flag.'))
+
     return exit_code == 0

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/commands/init/__init__.py

@@ -23,6 +23,7 @@ class Command(BaseCommand):
             description='Create package from predefined template with given id.'
         )
         parser.add_argument('task_id', type=str, help='Id of the task to create')
+        return parser
 
     def download_template(self):
         repo = 'https://github.com/sio2project/sinol-make.git'
@@ -69,8 +70,7 @@ class Command(BaseCommand):
 
         self.move_folder()
         self.update_config()
-        
+
         self.used_tmpdir.cleanup()
 
         print(util.info(f'Successfully created task "{self.task_id}"'))
-

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/commands/inwer/__init__.py

@@ -39,14 +39,11 @@ class Command(BaseCommand):
                             help='test to verify, for example in/abc{0,1}*')
         parser.add_argument('-c', '--cpus', type=int,
                             help=f'number of cpus to use (default: {util.default_cpu_count()})')
+        parser.add_argument('-f', '--fsanitize', default=False, action='store_true',
+                            help='Use -fsanitize=address,undefined for compilation. Warning: this may fail on some '
+                                 'systems. Tof fix this, run `sudo sysctl vm.mmap_rnd_bits = 28`.')
         add_compilation_arguments(parser)
-
-    def compile_inwer(self, args: argparse.Namespace):
-        self.inwer_executable, compile_log_path = inwer_util.compile_inwer(self.inwer, args, args.compile_mode)
-        if self.inwer_executable is None:
-            util.exit_with_error('Compilation failed.', lambda: compile.print_compile_log(compile_log_path))
-        else:
-            print(util.info('Compilation successful.'))
+        return parser
 
     @staticmethod
     def verify_test(execution: InwerExecution) -> VerificationResult:
@@ -101,11 +98,14 @@ class Command(BaseCommand):
             thr.start()
 
         keyboard_interrupt = False
+        sanitizer_error = False
         try:
             with mp.Pool(self.cpus) as pool:
                 for i, result in enumerate(pool.imap(self.verify_test, executions)):
                     table_data.results[result.test_path].set_results(result.valid, result.output)
                     table_data.i = i
+                    if util.has_sanitizer_error(result.output, 0 if result.valid else 1):
+                        sanitizer_error = True
         except KeyboardInterrupt:
             keyboard_interrupt = True
 
@@ -115,6 +115,10 @@ class Command(BaseCommand):
 
         print("\n".join(inwer_util.print_view(terminal_width, terminal_height, table_data)[0]))
 
+        if sanitizer_error:
+            print(util.warning('Warning: if inwer failed due to sanitizer errors, you can either run '
+                               '`sudo sysctl vm.mmap_rnd_bits = 28` to fix this or disable sanitizers with the '
+                               '--no-fsanitize flag.'))
         if keyboard_interrupt:
             util.exit_with_error('Keyboard interrupt.')
 
@@ -210,7 +214,7 @@ class Command(BaseCommand):
             print('Verifying tests: ' + util.bold(', '.join(self.tests)))
 
         util.change_stack_size_to_unlimited()
-        self.compile_inwer(args)
+        self.inwer_executable = inwer_util.compile_inwer(self.inwer, args, args.compile_mode, args.fsanitize)
         results: Dict[str, TestResult] = self.verify_and_print_table()
         print('')
 
@@ -225,4 +229,3 @@ class Command(BaseCommand):
             print("Verifying tests order...")
             self.verify_tests_order()
             print(util.info('Verification successful.'))
-            exit(0)

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/commands/inwer/inwer_util.py

@@ -13,7 +13,7 @@ from sinol_make.helpers import compiler
 from sinol_make.interfaces.Errors import CompilationError
 
 
-def get_inwer_path(task_id: str, path = None) -> Union[str, None]:
+def get_inwer_path(task_id: str, path=None) -> Union[str, None]:
     """
     Returns path to inwer executable for given task or None if no inwer was found.
     """
@@ -29,13 +29,21 @@ def get_inwer_path(task_id: str, path = None) -> Union[str, None]:
         return None
 
 
-def compile_inwer(inwer_path: str, args: argparse.Namespace, compilation_flags='default'):
+def compile_inwer(inwer_path: str, args: argparse.Namespace, compilation_flags='default', use_fsanitize=False):
     """
     Compiles inwer and returns path to compiled executable and path to compile log.
     """
     compilers = compiler.verify_compilers(args, [inwer_path])
-    return compile.compile_file(inwer_path, package_util.get_executable(inwer_path), compilers, compilation_flags,
-                                use_fsanitize=True)
+    inwer_exe, compile_log_path = compile.compile_file(inwer_path, package_util.get_executable(inwer_path), compilers,
+                                                       compilation_flags, use_fsanitize=use_fsanitize,
+                                                       additional_flags='-D_INWER')
+
+    if inwer_exe is None:
+        compile.print_compile_log(compile_log_path)
+        util.exit_with_error('Failed inwer compilation.')
+    else:
+        print(util.info('Compilation successful.'))
+    return inwer_exe
 
 
 def sort_tests(tests, task_id):
@@ -62,11 +70,13 @@ def print_view(term_width, term_height, table_data: TableData):
         tests.append(result.test_path)
     tests = sort_tests(tests, table_data.task_id)
 
-    column_lengths[3] = max(10, term_width - column_lengths[0] - column_lengths[1] - column_lengths[2] - 9 - 3) # 9 is for " | " between columns, 3 for margin.
+    column_lengths[3] = max(10, term_width - column_lengths[0] - column_lengths[1] - column_lengths[
+        2] - 9 - 3)  # 9 is for " | " between columns, 3 for margin.
     margin = "  "
 
     def print_line_separator():
-        res = "-" * (column_lengths[0] + 3) + "+" + "-" * (column_lengths[1] + 1) + "+" + "-" * (column_lengths[2] + 1) + "+"
+        res = "-" * (column_lengths[0] + 3) + "+" + "-" * (column_lengths[1] + 1) + "+" + "-" * (
+                    column_lengths[2] + 1) + "+"
         res += "-" * (term_width - len(res) - 1)
         print(res)
 

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/commands/outgen/__init__.py

@@ -34,6 +34,7 @@ class Command(BaseCommand):
         parser.add_argument('-n', '--no-validate', default=False, action='store_true',
                             help='do not validate test contents')
         parsers.add_compilation_arguments(parser)
+        return parser
 
     def generate_outputs(self, outputs_to_generate):
         print(f'Generating output files for {len(outputs_to_generate)} tests on {self.args.cpus} cpus.')

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/commands/run/__init__.py

@@ -7,6 +7,7 @@ import threading
 import time
 import psutil
 import glob
+import shutil
 from io import StringIO
 from typing import Dict
 
@@ -300,6 +301,7 @@ class Command(BaseCommand):
         parser.add_argument('-a', '--apply-suggestions', dest='apply_suggestions', action='store_true',
                             help='apply suggestions from expected scores report')
         add_compilation_arguments(parser)
+        return parser
 
     def parse_time(self, time_str):
         if len(time_str) < 3: return -1
@@ -438,7 +440,7 @@ class Command(BaseCommand):
             return self.check_output_checker(name, input_file, output_file_path, answer_file_path)
 
     def execute_oiejq(self, name, timetool_path, executable, result_file_path, input_file_path, output_file_path, answer_file_path,
-                      time_limit, memory_limit, hard_time_limit):
+                      time_limit, memory_limit, hard_time_limit, execution_dir):
         command = f'"{timetool_path}" "{executable}"'
         env = os.environ.copy()
         env["MEM_LIMIT"] = f'{memory_limit}K'
@@ -449,7 +451,7 @@ class Command(BaseCommand):
         with open(input_file_path, "r") as input_file, open(output_file_path, "w") as output_file, \
                 open(result_file_path, "w") as result_file:
             process = subprocess.Popen(command, shell=True, stdin=input_file, stdout=output_file,
-                                       stderr=result_file, env=env, preexec_fn=os.setsid)
+                                       stderr=result_file, env=env, preexec_fn=os.setsid, cwd=execution_dir)
 
             def sigint_handler(signum, frame):
                 try:
@@ -518,7 +520,7 @@ class Command(BaseCommand):
 
 
     def execute_time(self, name, executable, result_file_path, input_file_path, output_file_path, answer_file_path,
-                      time_limit, memory_limit, hard_time_limit):
+                      time_limit, memory_limit, hard_time_limit, execution_dir):
         if sys.platform == 'darwin':
             time_name = 'gtime'
         elif sys.platform == 'linux':
@@ -531,7 +533,7 @@ class Command(BaseCommand):
         mem_limit_exceeded = False
         with open(input_file_path, "r") as input_file, open(output_file_path, "w") as output_file:
             process = subprocess.Popen(command, stdin=input_file, stdout=output_file, stderr=subprocess.DEVNULL,
-                                       preexec_fn=os.setsid)
+                                       preexec_fn=os.setsid, cwd=execution_dir)
 
             def sigint_handler(signum, frame):
                 try:
@@ -596,7 +598,7 @@ class Command(BaseCommand):
                 program_exit_code = int(lines[0].strip().split(" ")[-1])
             elif not mem_limit_exceeded:
                 result.Status = Status.RE
-                result.Error = "Unexpected output from time command: " + "\n".join(lines)
+                result.Error = "Unexpected output from time command: " + "".join(lines)
                 return result
 
         if program_exit_code is not None and program_exit_code != 0:
@@ -630,7 +632,7 @@ class Command(BaseCommand):
         Run an execution and return the result as ExecutionResult object.
         """
 
-        (name, executable, test, time_limit, memory_limit, timetool_path) = data_for_execution
+        (name, executable, test, time_limit, memory_limit, timetool_path, execution_dir) = data_for_execution
         file_no_ext = paths.get_executions_path(name, package_util.extract_test_id(test, self.ID))
         output_file = file_no_ext + ".out"
         result_file = file_no_ext + ".res"
@@ -638,12 +640,12 @@ class Command(BaseCommand):
 
         if self.timetool_name == 'oiejq':
             return self.execute_oiejq(name, timetool_path, executable, result_file, test, output_file, self.get_output_file(test),
-                                      time_limit, memory_limit, hard_time_limit_in_s)
+                                      time_limit, memory_limit, hard_time_limit_in_s, execution_dir)
         elif self.timetool_name == 'time':
             return self.execute_time(name, executable, result_file, test, output_file, self.get_output_file(test),
-                                     time_limit, memory_limit, hard_time_limit_in_s)
+                                     time_limit, memory_limit, hard_time_limit_in_s, execution_dir)
 
-    def run_solutions(self, compiled_commands, names, solutions):
+    def run_solutions(self, compiled_commands, names, solutions, executables_dir):
         """
         Run solutions on tests and print the results as a table to stdout.
         """
@@ -653,6 +655,13 @@ class Command(BaseCommand):
         all_results = collections.defaultdict(
             lambda: collections.defaultdict(lambda: collections.defaultdict(map)))
 
+        for lang, files in self.config.get('extra_execution_files', {}).items():
+            for file in files:
+                shutil.copy(os.path.join(os.getcwd(), "prog", file), executables_dir)
+        # Copy swig generated .so files
+        for file in glob.glob(os.path.join(os.getcwd(), "prog", f"_{self.ID}lib.so")):
+            shutil.copy(file, executables_dir)
+
         for (name, executable, result) in compiled_commands:
             lang = package_util.get_file_lang(name)
             solution_cache = cache.get_cache_file(os.path.join(os.getcwd(), "prog", name))
@@ -670,7 +679,7 @@ class Command(BaseCommand):
                         all_results[name][self.get_group(test)][test] = test_result.result
                     else:
                         executions.append((name, executable, test, test_time_limit, test_memory_limit,
-                                           self.timetool_path))
+                                           self.timetool_path, os.path.dirname(executable)))
                         all_results[name][self.get_group(test)][test] = ExecutionResult(Status.PENDING)
                 os.makedirs(paths.get_executions_path(name), exist_ok=True)
             else:
@@ -743,7 +752,7 @@ class Command(BaseCommand):
         executables = [paths.get_executables_path(package_util.get_executable(solution)) for solution in solutions]
         compiled_commands = zip(solutions, executables, compilation_results)
         names = solutions
-        return self.run_solutions(compiled_commands, names, solutions)
+        return self.run_solutions(compiled_commands, names, solutions, paths.get_executables_path())
 
     def convert_status_to_string(self, dictionary):
         """
@@ -1196,7 +1205,8 @@ class Command(BaseCommand):
         title = self.config["title"]
         print("Task: %s (tag: %s)" % (title, self.ID))
         self.cpus = args.cpus or util.default_cpu_count()
-        cache.save_to_cache_extra_compilation_files(self.config.get("extra_compilation_files", []), self.ID)
+        cache.process_extra_compilation_files(self.config.get("extra_compilation_files", []), self.ID)
+        cache.process_extra_execution_files(self.config.get("extra_execution_files", {}), self.ID)
         cache.remove_results_if_contest_type_changed(self.config.get("sinol_contest_type", "default"))
 
         checker = package_util.get_files_matching_pattern(self.ID, f'{self.ID}chk.*')

sinol_make-1.6.0.dev1/src/sinol_make/commands/verify/__init__.py

@@ -0,0 +1,160 @@
+import os
+import stat
+import shutil
+import argparse
+import subprocess
+
+from sinol_make import util, contest_types
+from sinol_make.helpers import parsers, package_util, paths
+from sinol_make.interfaces.BaseCommand import BaseCommand
+from sinol_make.commands.gen import Command as GenCommand
+from sinol_make.commands.doc import Command as DocCommand
+from sinol_make.commands.inwer import Command as InwerCommand, inwer_util
+from sinol_make.commands.run import Command as RunCommand
+
+
+class Command(BaseCommand):
+    """
+    Class for `verify` command.
+    """
+
+    def get_name(self):
+        return "verify"
+
+    def configure_subparser(self, subparser):
+        parser = subparser.add_parser(
+            self.get_name(),
+            help='Verify the package',
+            description='Verify the whole package. This command will first '
+                        'run stress tests (if the file `prog/{task_id}stresstest.sh` exists), '
+                        'verify the config, generate tests, generate problem '
+                        'statements, run inwer and run all solutions. '
+                        'Ingen and inwer are compiled with sanitizers (-fsanitize=address,undefined), '
+                        'which may fail on some systems. To fix this, run `sudo sysctl vm.mmap_rnd_bits = 28` '
+                        'or disable sanitizers with --no-fsanitize.'
+        )
+
+        parser.add_argument('-f', '--no-fsanitize', action='store_true', default=False,
+                             help='do not use sanitizers for ingen and inwer programs')
+        parser.add_argument('-c', '--cpus', type=int,
+                            help=f'number of cpus that sinol-make will use '
+                                 f'(default: {util.default_cpu_count()})',
+                            default=util.default_cpu_count())
+        parsers.add_compilation_arguments(parser)
+
+    def remove_cache(self):
+        """
+        Remove whole cache dir
+        """
+        cache_dir = paths.get_cache_path()
+        if os.path.exists(cache_dir):
+            shutil.rmtree(cache_dir)
+
+    def check_extra_files(self):
+        """
+        Checks if extra_compilation_files and extra_execution_files exist.
+        """
+        extra_compilation_files = self.config.get('extra_compilation_files', [])
+        for file in extra_compilation_files:
+            if not os.path.exists(os.path.join(os.getcwd(), "prog", file)):
+                util.exit_with_error(f"Extra compilation file `{file}` does not exist. "
+                                     f"It should be in `prog` directory.")
+        if extra_compilation_files:
+            print(util.info("All extra compilation files exist."))
+
+        extra_execution_files = self.config.get('extra_execution_files', {})
+        for lang, files in extra_execution_files.items():
+            for file in files:
+                if not os.path.exists(os.path.join(os.getcwd(), "prog", file)):
+                    util.exit_with_error(f"Extra execution file `{file}` for language `{lang}` does not exist. "
+                                         f"It should be in `prog` directory.")
+        if extra_execution_files:
+            print(util.info("All extra execution files exist."))
+
+    def verify_scores(self, scored_groups):
+        config_scores = self.config.get('scores', {})
+        if not config_scores:
+            return
+        if '0' in scored_groups:
+            scored_groups.remove('0')
+        if 0 in scored_groups:
+            scored_groups.remove(0)
+
+        for group in scored_groups:
+            if int(group) not in config_scores:
+                util.exit_with_error(f"Score for group '{group}' not found. "
+                                     f"You must either provide scores for all groups "
+                                     f"or not provide them at all (to have them assigned automatically).")
+
+        for group in config_scores:
+            if int(group) not in scored_groups:
+                util.exit_with_error(f"Score for group '{group}' found in config, "
+                                     f"but no such test group exists in scored groups. "
+                                     f"You must either provide scores for all groups "
+                                     f"or not provide them at all (to have them assigned automatically).")
+
+        print(util.info("All scores are provided for all groups."))
+
+    def prepare_args(self, command):
+        parser = argparse.ArgumentParser()
+        subparser = parser.add_subparsers(dest='command')
+        command_parser = command.configure_subparser(subparser)
+        command_args = command_parser.parse_args([])
+        for key, value in vars(self.args).items():
+            setattr(command_args, key, value)
+        setattr(command_args, 'fsanitize', not self.args.no_fsanitize)
+        return command_args
+
+    def run_stresstests(self):
+        stresstests_path = os.path.join(os.getcwd(), 'prog', self.task_id + 'stresstest.sh')
+        if not os.path.exists(stresstests_path):
+            return
+
+        print(util.bold(' Running stress tests '.center(util.get_terminal_size()[1], '=')))
+        print(f"See the comments in `prog/{self.task_id}stresstest.sh` for details.".center(
+            util.get_terminal_size()[1], ' '))
+        st = os.stat(stresstests_path)
+        os.chmod(stresstests_path, st.st_mode | stat.S_IEXEC)
+        p = subprocess.Popen([stresstests_path], shell=True)
+        p.wait()
+        if p.returncode != 0:
+            util.exit_with_error("Stress tests failed.")
+
+    def run(self, args: argparse.Namespace):
+        self.args = util.init_package_command(args)
+        self.config = package_util.get_config()
+        self.task_id = package_util.get_task_id()
+        self.contest = contest_types.get_contest_type()
+
+        self.remove_cache()
+        self.check_extra_files()
+        self.contest.verify_pre_gen()
+
+        # Run stresstests (if present)
+        self.run_stresstests()
+
+        # Generate tests
+        print(util.bold(' Generating tests '.center(util.get_terminal_size()[1], '=')))
+        gen = GenCommand()
+        gen.run(self.prepare_args(gen))
+        self.verify_scores(package_util.get_groups(package_util.get_all_inputs(self.task_id), self.task_id))
+
+        # Generate problem statements
+        print(util.bold(' Generating problem statements '.center(util.get_terminal_size()[1], '=')))
+        doc = DocCommand()
+        doc.run(self.prepare_args(doc))
+
+        # Run inwer
+        if inwer_util.get_inwer_path(self.task_id) is None:
+            print(util.warning("Package doesn't have inwer."))
+        else:
+            print(util.bold(' Running inwer '.center(util.get_terminal_size()[1], '=')))
+            inwer = InwerCommand()
+            inwer.run(self.prepare_args(inwer))
+
+        # Run solutions
+        print(util.bold(' Running solutions '.center(util.get_terminal_size()[1], '=')))
+        run = RunCommand()
+        run.run(self.prepare_args(run))
+
+        print(util.info('Package verification successful.'))

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/contest_types/default.py

@@ -64,7 +64,7 @@ class DefaultContest:
         :param scores: Dictionary: {"<group>": <points>}
         :return: Maximum possible score.
         """
-        if groups[0] == 0 and len(groups) == 1:
+        if len(groups) == 0 or (groups[0] == 0 and len(groups) == 1):
             return 0
 
         possible_score = 0
@@ -126,3 +126,9 @@ class DefaultContest:
         Returns maximum score for single test
         """
         return 100
+
+    def verify_pre_gen(self):
+        """
+        Called by verify command before generating tests.
+        """
+        pass

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/contest_types/oi.py

@@ -1,5 +1,7 @@
 import argparse
 
+from sinol_make import util
+from sinol_make.helpers import package_util
 from sinol_make.structs.status_structs import ExecutionResult
 from sinol_make.contest_types.default import DefaultContest
 
@@ -28,3 +30,14 @@ class OIContest(DefaultContest):
             return result.Points
         else:
             return 1 + int((result.Points - 1) * ((time_limit - result.Time) / (time_limit / 2.0)))
+
+    def verify_pre_gen(self):
+        """
+        Verify if scores sum up to 100.
+        """
+        config = package_util.get_config()
+        if 'scores' not in config:
+            return
+        total_score = sum(config['scores'].values())
+        if total_score != 100:
+            util.exit_with_error(f"Total score in config is {total_score}, but should be 100.")

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/helpers/cache.py

@@ -70,14 +70,29 @@ def save_compiled(file_path: str, exe_path: str, is_checker: bool = False):
         remove_results_cache()
 
 
-def save_to_cache_extra_compilation_files(extra_compilation_files, task_id):
+def _check_file_changed(file_path, lang, task_id):
+    solutions_re = package_util.get_solutions_re(task_id)
+    md5sum = util.get_file_md5(file_path)
+    info = get_cache_file(file_path)
+
+    if info.md5sum != md5sum:
+        for solution in os.listdir(paths.get_cache_path('md5sums')):
+            # Remove only files in the same language and matching the solution regex
+            if package_util.get_file_lang(solution) == lang and \
+                    solutions_re.match(solution) is not None:
+                os.unlink(paths.get_cache_path('md5sums', solution))
+
+    info.md5sum = md5sum
+    info.save(file_path)
+
+
+def process_extra_compilation_files(extra_compilation_files, task_id):
     """
     Checks if extra compilation files have changed and saves them to cache.
     If they have, removes all cached solutions that use them.
     :param extra_compilation_files: List of extra compilation files
     :param task_id: Task id
     """
-    solutions_re = package_util.get_solutions_re(task_id)
     for file in extra_compilation_files:
         file_path = os.path.join(os.getcwd(), "prog", file)
         if not os.path.exists(file_path):
@@ -86,17 +101,22 @@ def save_to_cache_extra_compilation_files(extra_compilation_files, task_id):
         lang = package_util.get_file_lang(file)
         if lang == 'h':
             lang = 'cpp'
-        info = get_cache_file(file_path)
+        _check_file_changed(file_path, lang, task_id)
 
-        if info.md5sum != md5sum:
-            for solution in os.listdir(paths.get_cache_path('md5sums')):
-                # Remove only files in the same language and matching the solution regex
-                if package_util.get_file_lang(solution) == lang and \
-                        solutions_re.match(solution) is not None:
-                    os.unlink(paths.get_cache_path('md5sums', solution))
 
-        info.md5sum = md5sum
-        info.save(file_path)
+def process_extra_execution_files(extra_execution_files, task_id):
+    """
+    Checks if extra execution files have changed and saves them to cache.
+    If they have, removes all cached solutions that use them.
+    :param extra_execution_files: List of extra execution files
+    :param task_id: Task id
+    """
+    for lang, files in extra_execution_files.items():
+        for file in files:
+            file_path = os.path.join(os.getcwd(), "prog", file)
+            if not os.path.exists(file_path):
+                continue
+            _check_file_changed(file_path, lang, task_id)
 
 
 def remove_results_cache():

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/helpers/compile.py

@@ -112,7 +112,8 @@ def compile(program, output, compilers: Compilers = None, compile_log=None, comp
         return True
 
 
-def compile_file(file_path: str, name: str, compilers: Compilers, compilation_flags='default', use_fsanitize=False) \
+def compile_file(file_path: str, name: str, compilers: Compilers, compilation_flags='default',
+                 use_fsanitize=False, additional_flags=None) \
         -> Tuple[Union[str, None], str]:
     """
     Compile a file
@@ -121,6 +122,7 @@ def compile_file(file_path: str, name: str, compilers: Compilers, compilation_fl
     :param compilers: Compilers object
     :param compilation_flags: Group of compilation flags to use
     :param use_fsanitize: Whether to use fsanitize when compiling C/C++ programs. Sanitizes address and undefined behavior.
+    :param additional_flags: Additional flags for c / c++ compiler.
     :return: Tuple of (executable path or None if compilation failed, log path)
     """
     os.makedirs(paths.get_executables_path(), exist_ok=True)
@@ -135,6 +137,8 @@ def compile_file(file_path: str, name: str, compilers: Compilers, compilation_fl
     if isinstance(args, str):
         args = [args]
     extra_compilation_args = [os.path.join(os.getcwd(), "prog", file) for file in args]
+    if additional_flags is not None:
+        extra_compilation_args.append(additional_flags)
 
     output = paths.get_executables_path(name)
     compile_log_path = paths.get_compilation_log_path(os.path.splitext(name)[0] + '.compile_log')

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/helpers/package_util.py

@@ -266,6 +266,14 @@ def get_memory_limit(test_path, config, lang, task_id, args=None):
     return _get_limit(LimitTypes.MEMORY_LIMIT, test_path, str_config, lang, task_id)
 
 
+def get_in_tests_re(task_id: str) -> re.Pattern:
+    return re.compile(r'^%s(([0-9]+)([a-z]?[a-z0-9]*))\.in$' % re.escape(task_id))
+
+
+def get_out_tests_re(task_id: str) -> re.Pattern:
+    return re.compile(r'^%s(([0-9]+)([a-z]?[a-z0-9]*))\.out$' % re.escape(task_id))
+
+
 def validate_test_names(task_id):
     """
     Checks if all files in the package have valid names.
@@ -278,12 +286,12 @@ def validate_test_names(task_id):
                 invalid_files.append(os.path.basename(file))
         return invalid_files
 
-    in_test_re = re.compile(r'^(%s(([0-9]+)([a-z]?[a-z0-9]*))).in$' % (re.escape(task_id)))
+    in_test_re = get_in_tests_re(task_id)
     invalid_in_tests = get_invalid_files(os.path.join("in", "*.in"), in_test_re)
     if len(invalid_in_tests) > 0:
         util.exit_with_error(f'Input tests with invalid names: {", ".join(invalid_in_tests)}.')
 
-    out_test_re = re.compile(r'^(%s(([0-9]+)([a-z]?[a-z0-9]*))).out$' % (re.escape(task_id)))
+    out_test_re = get_out_tests_re(task_id)
     invalid_out_tests = get_invalid_files(os.path.join("out", "*.out"), out_test_re)
     if len(invalid_out_tests) > 0:
         util.exit_with_error(f'Output tests with invalid names: {", ".join(invalid_out_tests)}.')
@@ -376,3 +384,12 @@ def validate_test(test_path: str):
 
         if num_empty != 0:
             util.exit_with_error(f'Exactly one empty line expected in {basename}')
+
+
+def get_all_inputs(task_id):
+    in_test_re = get_in_tests_re(task_id)
+    inputs = []
+    for file in glob.glob(os.path.join(os.getcwd(), "in", "*.in")):
+        if in_test_re.match(os.path.basename(file)):
+            inputs.append(file)
+    return inputs

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make/util.py

@@ -7,6 +7,7 @@ import hashlib
 import multiprocessing
 import resource
 from typing import Union
+from packaging.version import parse as parse_version
 
 from sinol_make.contest_types import get_contest_type
 from sinol_make.helpers import paths, cache
@@ -150,10 +151,18 @@ def import_importlib_resources():
     return importlib
 
 
-def check_for_updates(current_version) -> Union[str, None]:
+def is_dev(version):
+    """
+    Function to check if the version is a development version.
+    """
+    return parse_version(version).is_devrelease
+
+
+def check_for_updates(current_version, check=True) -> Union[str, None]:
     """
     Function to check if there is a new version of sinol-make.
     :param current_version: current version of sinol-make
+    :param check: whether to check for new version
     :return: returns new version if there is one, None otherwise
     """
     importlib = import_importlib_resources()
@@ -164,8 +173,9 @@ def check_for_updates(current_version) -> Union[str, None]:
 
     # We check for new version asynchronously, so that it doesn't slow down the program.
     # If the main process exits, the check_version process will also exit.
-    process = multiprocessing.Process(target=check_version, daemon=True)
-    process.start()
+    if check:
+        process = multiprocessing.Process(target=check_version, daemon=True)
+        process.start()
     version_file = data_dir.joinpath("version")
 
     try:
@@ -178,7 +188,9 @@ def check_for_updates(current_version) -> Union[str, None]:
             return None
 
     try:
-        if compare_versions(current_version, version) == -1:
+        if not is_dev(version) and parse_version(version) > parse_version(current_version):
+            return version
+        if is_dev(current_version) and is_dev(version) and parse_version(version) > parse_version(current_version):
             return version
         else:
             return None
@@ -217,26 +229,6 @@ def check_version():
                 pass
 
 
-def compare_versions(version_a, version_b):
-    """
-    Function to compare two versions.
-    Returns 1 if version_a > version_b, 0 if version_a == version_b, -1 if version_a < version_b.
-    """
-
-    def convert(version):
-        return tuple(map(int, version.split(".")))
-
-    version_a = convert(version_a)
-    version_b = convert(version_b)
-
-    if version_a > version_b:
-        return 1
-    elif version_a == version_b:
-        return 0
-    else:
-        return -1
-
-
 def lines_diff(lines1, lines2):
     """
     Function to compare two lists of lines.
@@ -441,3 +433,7 @@ def exit_with_error(text, func=None):
     except TypeError:
         pass
     exit(1)
+
+
+def has_sanitizer_error(output, exit_code):
+    return ('ELF_ET_DYN_BASE' in output or 'ASan' in output) and exit_code != 0

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1/src/sinol_make.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sinol_make
-Version: 1.5.28
+Version: 1.6.0.dev1
 Summary: CLI tool for creating sio2 task packages
 Author: Mateusz Masiarz
 Author-email: m.masiarz@fri.edu.pl
@@ -21,6 +21,7 @@ Requires-Dist: PyYAML
 Requires-Dist: dictdiffer
 Requires-Dist: importlib-resources
 Requires-Dist: psutil
+Requires-Dist: packaging
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-cov; extra == "tests"

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ src/sinol_make/commands/inwer/inwer_util.py
 src/sinol_make/commands/outgen/__init__.py
 src/sinol_make/commands/outgen/outgen_util.py
 src/sinol_make/commands/run/__init__.py
+src/sinol_make/commands/verify/__init__.py
 src/sinol_make/contest_types/__init__.py
 src/sinol_make/contest_types/default.py
 src/sinol_make/contest_types/icpc.py

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/src/sinol_make.egg-info/requires.txt

@@ -5,6 +5,7 @@ PyYAML
 dictdiffer
 importlib-resources
 psutil
+packaging
 
 [tests]
 pytest

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/tests/test_multiple_arguments.py

@@ -21,7 +21,7 @@ def test_simple_package(create_package):
 
 @pytest.mark.parametrize("create_package", [util.get_inwer_package_path()], indirect=True)
 def test_inwer_package(create_package):
-    run("sinol-make ingen inwer run")
+    run("sinol-make gen inwer run")
     run("sinol-make ingen prog/weringen.cpp inwer prog/werinwer.cpp --tests wer1a.in run --tests wer2a.in")
     run("sinol-make ingen inwer run export --no-statement")
 

{sinol_make-1.5.28 → sinol_make-1.6.0.dev1}/tests/test_util.py

@@ -44,28 +44,6 @@ def test_file_diff():
         assert util.file_diff(a_file, b_file) is False
 
 
-def test_compare_versions():
-    """
-    Tests for compare_versions function
-    """
-
-    assert util.compare_versions('1.0.0', '1.0.0') == 0
-    assert util.compare_versions('1.0.0', '1.0.1') == -1
-    assert util.compare_versions('1.0.1', '1.0.0') == 1
-    assert util.compare_versions('1.0.0', '1.1.0') == -1
-    assert util.compare_versions('1.1.0', '1.0.0') == 1
-    assert util.compare_versions('1.0.0', '2.0.0') == -1
-    assert util.compare_versions('2.0.0', '1.0.0') == 1
-    with pytest.raises(ValueError):
-        util.compare_versions('1.0.0', '')
-    with pytest.raises(ValueError):
-        util.compare_versions('', '1.0.0')
-    with pytest.raises(ValueError):
-        util.compare_versions('1.0.0', 'abc')
-    with pytest.raises(ValueError):
-        util.compare_versions('abc', '1.0.0')
-
-
 @requests_mock.Mocker(kw="mocker")
 def test_check_version(**kwargs):
     """
@@ -74,6 +52,29 @@ def test_check_version(**kwargs):
     """
     mocker = kwargs["mocker"]
 
+    mocker.get("https://pypi.python.org/pypi/sinol-make/json", json={"info": {"version": "1.0.0.dev2"}})
+    util.check_version()
+    version = util.check_for_updates("1.0.0.dev1", False)
+    assert version == "1.0.0.dev2"
+    assert util.is_dev(version)
+
+    mocker.get("https://pypi.python.org/pypi/sinol-make/json", json={"info": {"version": "1.0.0"}})
+    util.check_version()
+    version = util.check_for_updates("1.0.0.dev1", False)
+    assert version == "1.0.0"
+    assert not util.is_dev(version)
+
+    mocker.get("https://pypi.python.org/pypi/sinol-make/json", json={"info": {"version": "2.0.0.dev1"}})
+    util.check_version()
+    version = util.check_for_updates("1.0.0", False)
+    assert version is None
+
+    mocker.get("https://pypi.python.org/pypi/sinol-make/json", json={"info": {"version": "1.0.1"}})
+    util.check_version()
+    version = util.check_for_updates("1.0.0", False)
+    assert version == "1.0.1"
+    assert not util.is_dev(version)
+
     importlib = util.import_importlib_resources()
 
     data_dir = importlib.files('sinol_make').joinpath("data")