Fix python3.10 issues with gen command (#171)

* Split gen_util.py into ingen_ and outgen_util

* Fix code

* Bump version

Author: MasloMaslane

src/sinol_make/__init__.py

@@ -9,7 +9,7 @@
 from sinol_make import util, oiejq
 
 
-__version__ = "1.5.18"
+__version__ = "1.5.19"
 
 
 def configure_parsers():

src/sinol_make/commands/export/__init__.py

@@ -7,8 +7,8 @@
 import yaml
 
 from sinol_make import util
+from sinol_make.commands.ingen.ingen_util import get_ingen, compile_ingen, run_ingen, ingen_exists
 from sinol_make.helpers import package_util, parsers, paths
-from sinol_make.commands.gen import gen_util
 from sinol_make.interfaces.BaseCommand import BaseCommand
 
 
@@ -32,17 +32,17 @@ def get_generated_tests(self):
         Returns list of generated tests.
         Executes ingen to check what tests are generated.
         """
-        if not gen_util.ingen_exists(self.task_id):
+        if not ingen_exists(self.task_id):
             return []
 
         working_dir = paths.get_cache_path('export', 'tests')
         if os.path.exists(working_dir):
             shutil.rmtree(working_dir)
         os.makedirs(working_dir)
 
-        ingen_path = gen_util.get_ingen(self.task_id)
-        ingen_exe = gen_util.compile_ingen(ingen_path, self.args, self.args.weak_compilation_flags)
-        if not gen_util.run_ingen(ingen_exe, working_dir):
+        ingen_path = get_ingen(self.task_id)
+        ingen_exe = compile_ingen(ingen_path, self.args, self.args.weak_compilation_flags)
+        if not run_ingen(ingen_exe, working_dir):
             util.exit_with_error('Failed to run ingen.')
 
         tests = glob.glob(os.path.join(working_dir, f'{self.task_id}*.in'))

src/sinol_make/commands/gen/__init__.py

@@ -3,7 +3,6 @@
 from sinol_make import util
 from sinol_make.commands.ingen import Command as IngenCommand
 from sinol_make.commands.outgen import Command as OutgenCommand
-from sinol_make.commands.gen import gen_util
 from sinol_make.helpers import parsers
 from sinol_make.interfaces.BaseCommand import BaseCommand
 

src/sinol_make/commands/ingen/__init__.py

@@ -2,7 +2,7 @@
 import os
 
 from sinol_make import util
-from sinol_make.commands.gen import gen_util
+from sinol_make.commands.ingen.ingen_util import get_ingen, compile_ingen, run_ingen
 from sinol_make.helpers import parsers, package_util
 from sinol_make.interfaces.BaseCommand import BaseCommand
 
@@ -37,11 +37,11 @@ def run(self, args: argparse.Namespace):
         self.task_id = package_util.get_task_id()
         package_util.validate_test_names(self.task_id)
         util.change_stack_size_to_unlimited()
-        self.ingen = gen_util.get_ingen(self.task_id, args.ingen_path)
+        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 = gen_util.compile_ingen(self.ingen, self.args, self.args.weak_compilation_flags)
+        self.ingen_exe = compile_ingen(self.ingen, self.args, self.args.weak_compilation_flags)
 
-        if gen_util.run_ingen(self.ingen_exe):
+        if run_ingen(self.ingen_exe):
             print(util.info('Successfully generated input files.'))
         else:
             util.exit_with_error('Failed to generate input files.')

src/sinol_make/commands/gen/gen_util.py renamed to src/sinol_make/commands/ingen/ingen_util.py

@@ -1,13 +1,11 @@
-import glob
-import os
 import stat
-import argparse
-import signal
 import subprocess
-import sys
+
+import argparse
+import os
 
 from sinol_make import util
-from sinol_make.helpers import compiler, package_util, compile
+from sinol_make.helpers import package_util, compiler, compile
 
 
 def ingen_exists(task_id):
@@ -69,34 +67,6 @@ def compile_ingen(ingen_path: str, args: argparse.Namespace, weak_compilation_fl
     return ingen_exe
 
 
-def get_correct_solution(task_id):
-    """
-    Returns path to correct solution for given task.
-    :param task_id: task id, for example abc
-    :return: path to correct solution or None if not found
-    """
-    correct_solution = package_util.get_files_matching_pattern(task_id, f'{task_id}.*')
-    if len(correct_solution) == 0:
-        util.exit_with_error(f'Correct solution for task {task_id} does not exist.')
-    return correct_solution[0]
-
-
-def compile_correct_solution(solution_path: str, args: argparse.Namespace, weak_compilation_flags=False):
-    """
-    Compiles correct solution and returns path to compiled executable.
-    """
-    compilers = compiler.verify_compilers(args, [solution_path])
-    correct_solution_exe, compile_log_path = compile.compile_file(solution_path, package_util.get_executable(solution_path), compilers,
-                                weak_compilation_flags)
-    if correct_solution_exe is None:
-        util.exit_with_error('Failed compilation of correct solution.',
-                                  lambda: compile.print_compile_log(compile_log_path))
-    else:
-        print(util.info('Successfully compiled correct solution.'))
-
-    return correct_solution_exe
-
-
 def run_ingen(ingen_exe, working_dir=None):
     """
     Runs ingen and generates all input files.
@@ -121,35 +91,3 @@ def run_ingen(ingen_exe, working_dir=None):
     exit_code = process.returncode
 
     return exit_code == 0
-
-
-def generate_output(arguments):
-    """
-    Generates output file for given input file.
-    :param arguments: arguments for output generation (type OutputGenerationArguments)
-    :return: True if the output was successfully generated, False otherwise
-    """
-    input_test = arguments.input_test
-    output_test = arguments.output_test
-    correct_solution_exe = arguments.correct_solution_exe
-
-    input_file = open(input_test, 'r')
-    output_file = open(output_test, 'w')
-    process = subprocess.Popen([correct_solution_exe], stdin=input_file, stdout=output_file, preexec_fn=os.setsid)
-    previous_sigint_handler = signal.getsignal(signal.SIGINT)
-
-    def sigint_handler(signum, frame):
-        try:
-            os.killpg(os.getpgid(process.pid), signal.SIGTERM)
-        except ProcessLookupError:
-            pass
-        sys.exit(1)
-    signal.signal(signal.SIGINT, sigint_handler)
-
-    process.wait()
-    signal.signal(signal.SIGINT, previous_sigint_handler)
-    exit_code = process.returncode
-    input_file.close()
-    output_file.close()
-
-    return exit_code == 0

src/sinol_make/commands/outgen/__init__.py

@@ -6,7 +6,7 @@
 import multiprocessing as mp
 
 from sinol_make import util
-from sinol_make.commands.gen import gen_util
+from sinol_make.commands.outgen.outgen_util import get_correct_solution, compile_correct_solution, generate_output
 from sinol_make.structs.gen_structs import OutputGenerationArguments
 from sinol_make.helpers import parsers, package_util, cache
 from sinol_make.interfaces.BaseCommand import BaseCommand
@@ -43,7 +43,7 @@ def generate_outputs(self, outputs_to_generate):
 
         with mp.Pool(self.args.cpus) as pool:
             results = []
-            for i, result in enumerate(pool.imap(gen_util.generate_output, arguments)):
+            for i, result in enumerate(pool.imap(generate_output, arguments)):
                 results.append(result)
                 if result:
                     print(util.info(f'Successfully generated output file {os.path.basename(arguments[i].output_test)}'))
@@ -93,14 +93,14 @@ def run(self, args: argparse.Namespace):
         package_util.validate_test_names(self.task_id)
         util.change_stack_size_to_unlimited()
         cache.check_correct_solution(self.task_id)
-        self.correct_solution = gen_util.get_correct_solution(self.task_id)
+        self.correct_solution = get_correct_solution(self.task_id)
 
         md5_sums, outputs_to_generate = self.calculate_md5_sums()
         if len(outputs_to_generate) == 0:
             print(util.info('All output files are up to date.'))
         else:
-            self.correct_solution_exe = gen_util.compile_correct_solution(self.correct_solution, self.args,
-                                                                          self.args.weak_compilation_flags)
+            self.correct_solution_exe = compile_correct_solution(self.correct_solution, self.args,
+                                                                 self.args.weak_compilation_flags)
             self.generate_outputs(outputs_to_generate)
             with open(os.path.join(os.getcwd(), 'in', '.md5sums'), 'w') as f:
                 yaml.dump(md5_sums, f)

src/sinol_make/commands/outgen/outgen_util.py

@@ -0,0 +1,69 @@
+import os
+import signal
+import subprocess
+import sys
+
+import argparse
+
+from sinol_make import util
+from sinol_make.helpers import package_util, compiler, compile
+
+
+def get_correct_solution(task_id):
+    """
+    Returns path to correct solution for given task.
+    :param task_id: task id, for example abc
+    :return: path to correct solution or None if not found
+    """
+    correct_solution = package_util.get_files_matching_pattern(task_id, f'{task_id}.*')
+    if len(correct_solution) == 0:
+        util.exit_with_error(f'Correct solution for task {task_id} does not exist.')
+    return correct_solution[0]
+
+
+def compile_correct_solution(solution_path: str, args: argparse.Namespace, weak_compilation_flags=False):
+    """
+    Compiles correct solution and returns path to compiled executable.
+    """
+    compilers = compiler.verify_compilers(args, [solution_path])
+    correct_solution_exe, compile_log_path = compile.compile_file(solution_path, package_util.get_executable(solution_path), compilers,
+                                weak_compilation_flags)
+    if correct_solution_exe is None:
+        util.exit_with_error('Failed compilation of correct solution.',
+                                  lambda: compile.print_compile_log(compile_log_path))
+    else:
+        print(util.info('Successfully compiled correct solution.'))
+
+    return correct_solution_exe
+
+
+def generate_output(arguments):
+    """
+    Generates output file for given input file.
+    :param arguments: arguments for output generation (type OutputGenerationArguments)
+    :return: True if the output was successfully generated, False otherwise
+    """
+    input_test = arguments.input_test
+    output_test = arguments.output_test
+    correct_solution_exe = arguments.correct_solution_exe
+
+    input_file = open(input_test, 'r')
+    output_file = open(output_test, 'w')
+    process = subprocess.Popen([correct_solution_exe], stdin=input_file, stdout=output_file, preexec_fn=os.setsid)
+    previous_sigint_handler = signal.getsignal(signal.SIGINT)
+
+    def sigint_handler(signum, frame):
+        try:
+            os.killpg(os.getpgid(process.pid), signal.SIGTERM)
+        except ProcessLookupError:
+            pass
+        sys.exit(1)
+    signal.signal(signal.SIGINT, sigint_handler)
+
+    process.wait()
+    signal.signal(signal.SIGINT, previous_sigint_handler)
+    exit_code = process.returncode
+    input_file.close()
+    output_file.close()
+
+    return exit_code == 0

tests/commands/gen/test_integration.py

@@ -7,8 +7,8 @@
 from sinol_make import util as sm_util
 from sinol_make.commands.gen import Command
 from sinol_make.commands.ingen import Command as IngenCommand
+from sinol_make.commands.ingen.ingen_util import get_ingen
 from sinol_make.commands.outgen import Command as OutgenCommand
-from sinol_make.commands.gen import gen_util
 from sinol_make.helpers import package_util, paths, cache
 from tests.fixtures import *
 from tests import util
@@ -108,7 +108,7 @@ def test_shell_ingen_unchanged(create_package):
     """
     package_path = create_package
     task_id = package_util.get_task_id()
-    shell_ingen_path = gen_util.get_ingen(task_id)
+    shell_ingen_path = get_ingen(task_id)
     assert os.path.splitext(shell_ingen_path)[1] == ".sh"
     edited_time = os.path.getmtime(shell_ingen_path)
     simple_run()