sinol-make 1.5.29__tar.gz → 1.6.0.dev2__tar.gz

{sinol_make-1.5.29/src/sinol_make.egg-info → sinol_make-1.6.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sinol_make
-Version: 1.5.29
+Version: 1.6.0.dev2
 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.29 → sinol_make-1.6.0.dev2}/setup.cfg

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

{sinol_make-1.5.29 → sinol_make-1.6.0.dev2}/src/sinol_make/__init__.py

@@ -6,7 +6,7 @@ import argcomplete
 
 from sinol_make import util, oiejq
 
-__version__ = "1.5.29"
+__version__ = "1.6.0.dev2"
 
 
 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.29 → sinol_make-1.6.0.dev2}/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.29 → sinol_make-1.6.0.dev2}/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...')
@@ -97,6 +98,7 @@ class Command(BaseCommand):
         Creates ocen archive for sio2.
         :param target_dir: Path to exported package.
         """
+        print('Generating ocen archive...')
         attachments_dir = os.path.join(target_dir, 'attachments')
         if not os.path.exists(attachments_dir):
             os.makedirs(attachments_dir)
@@ -109,12 +111,25 @@ class Command(BaseCommand):
             os.makedirs(in_dir)
             out_dir = os.path.join(ocen_dir, 'out')
             os.makedirs(out_dir)
+            num_tests = 0
             for ext in ['in', 'out']:
                 for test in glob.glob(os.path.join(tests_dir, ext, f'{self.task_id}0*.{ext}')) + \
                             glob.glob(os.path.join(tests_dir, ext, f'{self.task_id}*ocen.{ext}')):
                     shutil.copy(test, os.path.join(ocen_dir, ext, os.path.basename(test)))
+                    num_tests += 1
 
-            shutil.make_archive(os.path.join(attachments_dir, f'{self.task_id}ocen'), 'zip', tmpdir)
+            if num_tests == 0:
+                print(util.warning('No ocen tests found.'))
+            else:
+                shutil.make_archive(os.path.join(attachments_dir, f'{self.task_id}ocen'), 'zip', tmpdir)
+
+            dlazaw_dir = os.path.join(os.getcwd(), 'dlazaw')
+            if os.path.exists(dlazaw_dir):
+                print('Archiving dlazaw directory and adding to attachments.')
+                os.makedirs(os.path.join(tmpdir, 'dlazaw'), exist_ok=True)
+                shutil.copytree(dlazaw_dir, os.path.join(tmpdir, 'dlazaw', 'dlazaw'))
+                shutil.make_archive(os.path.join(attachments_dir, 'dlazaw'), 'zip',
+                                    os.path.join(tmpdir, 'dlazaw'))
 
     def compile_statement(self):
         command = DocCommand()
@@ -168,7 +183,6 @@ class Command(BaseCommand):
 
         self.generate_output_files()
         if self.args.export_ocen:
-            print('Generating ocen archive...')
             self.create_ocen(target_dir)
 
     def clear_files(self, target_dir: str):

{sinol_make-1.5.29 → sinol_make-1.6.0.dev2}/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.29 → sinol_make-1.6.0.dev2}/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.29 → sinol_make-1.6.0.dev2}/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.
@@ -57,7 +57,7 @@ def compile_ingen(ingen_path: str, args: argparse.Namespace, compilation_flags='
 
     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,
+                                                       compilers, compilation_flags, use_fsanitize=use_fsanitize,
                                                        additional_flags='-D_INGEN')
 
     if ingen_exe is None:
@@ -86,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.29 → sinol_make-1.6.0.dev2}/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.29 → sinol_make-1.6.0.dev2}/src/sinol_make/commands/inwer/__init__.py

@@ -39,7 +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)
+        return parser
 
     @staticmethod
     def verify_test(execution: InwerExecution) -> VerificationResult:
@@ -94,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
 
@@ -108,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.')
 
@@ -203,7 +214,7 @@ class Command(BaseCommand):
             print('Verifying tests: ' + util.bold(', '.join(self.tests)))
 
         util.change_stack_size_to_unlimited()
-        self.inwer_executable = inwer_util.compile_inwer(self.inwer, args, args.compile_mode)
+        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('')
 
@@ -218,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.29 → sinol_make-1.6.0.dev2}/src/sinol_make/commands/inwer/inwer_util.py

@@ -29,13 +29,13 @@ 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])
     inwer_exe, compile_log_path = compile.compile_file(inwer_path, package_util.get_executable(inwer_path), compilers,
-                                                       compilation_flags, use_fsanitize=True,
+                                                       compilation_flags, use_fsanitize=use_fsanitize,
                                                        additional_flags='-D_INWER')
 
     if inwer_exe is None:

{sinol_make-1.5.29 → sinol_make-1.6.0.dev2}/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.29 → sinol_make-1.6.0.dev2}/src/sinol_make/commands/run/__init__.py

@@ -301,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

sinol_make-1.6.0.dev2/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.29 → sinol_make-1.6.0.dev2}/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.29 → sinol_make-1.6.0.dev2}/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.29 → sinol_make-1.6.0.dev2}/src/sinol_make/helpers/cache.py

@@ -35,7 +35,7 @@ def get_cache_file(solution_path: str) -> CacheFile:
         return CacheFile()
 
 
-def check_compiled(file_path: str) -> Union[str, None]:
+def check_compiled(file_path: str, compilation_flags: str, sanitizers: bool) -> Union[str, None]:
     """
     Check if a file is compiled
     :param file_path: Path to the file
@@ -44,7 +44,7 @@ def check_compiled(file_path: str) -> Union[str, None]:
     md5sum = util.get_file_md5(file_path)
     try:
         info = get_cache_file(file_path)
-        if info.md5sum == md5sum:
+        if info.md5sum == md5sum and info.compilation_flags == compilation_flags and info.sanitizers == sanitizers:
             exe_path = info.executable_path
             if os.path.exists(exe_path):
                 return exe_path
@@ -53,19 +53,18 @@ def check_compiled(file_path: str) -> Union[str, None]:
         return None
 
 
-def save_compiled(file_path: str, exe_path: str, is_checker: bool = False):
+def save_compiled(file_path: str, exe_path: str, compilation_flags: str, sanitizers: bool, is_checker: bool = False):
     """
     Save the compiled executable path to cache in `.cache/md5sums/<basename of file_path>`,
     which contains the md5sum of the file and the path to the executable.
     :param file_path: Path to the file
     :param exe_path: Path to the compiled executable
+    :param compilation_flags: Compilation flags used
+    :param sanitizers: Whether -fsanitize=undefined,address was used
     :param is_checker: Whether the compiled file is a checker. If True, all cached tests are removed.
     """
-    info = CacheFile()
-    info.executable_path = exe_path
-    info.md5sum = util.get_file_md5(file_path)
+    info = CacheFile(util.get_file_md5(file_path), exe_path, compilation_flags, sanitizers)
     info.save(file_path)
-
     if is_checker:
         remove_results_cache()
 

{sinol_make-1.5.29 → sinol_make-1.6.0.dev2}/src/sinol_make/helpers/compile.py

@@ -37,10 +37,17 @@ def compile(program, output, compilers: Compilers = None, compile_log=None, comp
     if use_fsanitize and util.is_macos_arm():
         use_fsanitize = False
 
+    if compilation_flags == 'w':
+        compilation_flags = 'weak'
+    elif compilation_flags == 'o':
+        compilation_flags = 'oioioi'
+    elif compilation_flags == 'd':
+        compilation_flags = 'default'
+
     if extra_compilation_files is None:
         extra_compilation_files = []
 
-    compiled_exe = check_compiled(program)
+    compiled_exe = check_compiled(program, compilation_flags, use_fsanitize)
     if compiled_exe is not None:
         if compile_log is not None:
             compile_log.write(f'Using cached executable {compiled_exe}\n')
@@ -53,12 +60,11 @@ def compile(program, output, compilers: Compilers = None, compile_log=None, comp
         shutil.copy(file, os.path.join(os.path.dirname(output), os.path.basename(file)))
 
     gcc_compilation_flags = ''
-    if compilation_flags == 'weak' or compilation_flags == 'w':
-        compilation_flags = 'weak'
+    if compilation_flags == 'weak':
         gcc_compilation_flags = ''  # Disable all warnings
-    elif compilation_flags == 'oioioi' or compilation_flags == 'o':
+    elif compilation_flags == 'oioioi':
         gcc_compilation_flags = ' -Wall -Wno-unused-result -Werror'  # Same flags as oioioi
-    elif compilation_flags == 'default' or compilation_flags == 'd':
+    elif compilation_flags == 'default':
         gcc_compilation_flags = ' -Werror -Wall -Wextra -Wshadow -Wconversion -Wno-unused-result -Wfloat-equal'
     else:
         util.exit_with_error(f'Unknown compilation flags group: {compilation_flags}')
@@ -108,7 +114,7 @@ def compile(program, output, compilers: Compilers = None, compile_log=None, comp
     if process.returncode != 0:
         raise CompilationError('Compilation failed')
     else:
-        save_compiled(program, output, is_checker)
+        save_compiled(program, output, compilation_flags, use_fsanitize, is_checker)
         return True
 
 

{sinol_make-1.5.29 → sinol_make-1.6.0.dev2}/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.29 → sinol_make-1.6.0.dev2}/src/sinol_make/structs/cache_structs.py

@@ -43,20 +43,28 @@ class CacheFile:
     md5sum: str
     # Path to the executable
     executable_path: str
+    # Compilation flags used
+    compilation_flags: str
+    # Whether -fsanitize=undefined,address was used
+    sanitizers: bool
     # Test results
     tests: Dict[str, CacheTest]
 
-    def __init__(self, md5sum="", executable_path="", tests=None):
+    def __init__(self, md5sum="", executable_path="", compilation_flags="default", sanitizers=False, tests=None):
         if tests is None:
             tests = {}
         self.md5sum = md5sum
         self.executable_path = executable_path
+        self.compilation_flags = compilation_flags
+        self.sanitizers = sanitizers
         self.tests = tests
 
     def to_dict(self) -> Dict:
         return {
             "md5sum": self.md5sum,
             "executable_path": self.executable_path,
+            "compilation_flags": self.compilation_flags,
+            "sanitizers": self.sanitizers,
             "tests": {k: v.to_dict() for k, v in self.tests.items()}
         }
 
@@ -65,6 +73,8 @@ class CacheFile:
         return CacheFile(
             md5sum=dict.get("md5sum", ""),
             executable_path=dict.get("executable_path", ""),
+            compilation_flags=dict.get("compilation_flags", "default"),
+            sanitizers=dict.get("sanitizers", False),
             tests={k: CacheTest(
                 time_limit=v["time_limit"],
                 memory_limit=v["memory_limit"],

{sinol_make-1.5.29 → sinol_make-1.6.0.dev2}/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.29 → sinol_make-1.6.0.dev2/src/sinol_make.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sinol_make
-Version: 1.5.29
+Version: 1.6.0.dev2
 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.29 → sinol_make-1.6.0.dev2}/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.29 → sinol_make-1.6.0.dev2}/src/sinol_make.egg-info/requires.txt

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

{sinol_make-1.5.29 → sinol_make-1.6.0.dev2}/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.29 → sinol_make-1.6.0.dev2}/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")