rbx.cp 0.5.46__py3-none-any.whl → 0.5.47__py3-none-any.whl

rbx/box/checkers.py

@@ -1,4 +1,5 @@
 import pathlib
+import signal
 from typing import Optional
 
 import typer
@@ -108,23 +109,31 @@ def _convert_tle(result: CheckerResult, run_log: Optional[RunLog]) -> CheckerRes
     return result
 
 
+def _is_checker_exitcode(exitcode: int) -> bool:
+    return exitcode in [0, 1, 2, 3]
+
+
 def process_checker_run_log(
     checker_run_log: Optional[RunLog], message: str
-) -> Optional[CheckerResult]:
+) -> CheckerResult:
     if (
         checker_run_log is not None
-        and checker_run_log.exitcode != 0
-        and (
-            checker_run_log.exitstatus != SandboxBase.EXIT_NONZERO_RETURN
-            or checker_run_log.exitcode not in [0, 1, 2, 3]
-        )
+        and checker_run_log.exitstatus == SandboxBase.EXIT_SANDBOX_ERROR
     ):
-        return None
+        # When the sandbox fails, it means the checker failed to run.
+        # We don't know what happened.
+        return CheckerResult(
+            outcome=Outcome.INTERNAL_ERROR,
+            message='sandbox failed to run checker',
+        )
 
     if checker_run_log is None:
         return CheckerResult(outcome=Outcome.INTERNAL_ERROR)
-    if checker_run_log.exitcode not in [0, 1, 2, 3]:
-        return None
+    if not _is_checker_exitcode(checker_run_log.exitcode):
+        return CheckerResult(
+            outcome=Outcome.JUDGE_FAILED,
+            message=f'checker failed with unknown exit code {checker_run_log.exitcode}: {message}',
+        )
 
     result = CheckerResult(outcome=Outcome.ACCEPTED, message=message)
 
@@ -185,7 +194,7 @@ async def _check(
     message = package.get_digest_as_string(error.value or '') or ''
 
     processed_checker_result = process_checker_run_log(checker_run_log, message)
-    if processed_checker_result is None:
+    if processed_checker_result.outcome == Outcome.INTERNAL_ERROR:
         console.console.print(
             f'[error]Checker [item]{package.get_checker().path}[/item] failed unexpectedly.[/error]'
         )
@@ -240,33 +249,77 @@ async def check_communication(
     program_output: pathlib.Path,
     skip_run_log: bool = False,
 ) -> CheckerResult:
-    sanitizer_warnings = _check_sanitizer_warnings(run_log)
+    def _extra_check_and_sanitize(result: CheckerResult) -> CheckerResult:
+        result.sanitizer_warnings = _check_sanitizer_warnings(run_log)
+        return result
+
+    def _check_interactor(reinterpret_rte: bool = True) -> Optional[CheckerResult]:
+        result = process_checker_run_log(
+            interactor_run_log, interactor_stderr.read_text()
+        )
+        if result.outcome in [Outcome.JUDGE_FAILED, Outcome.WRONG_ANSWER]:
+            # Only return testlib errors (exit code 2 and 3), skip other types of RTEs and verdicts.
+            if (
+                interactor_run_log is not None
+                and _is_checker_exitcode(interactor_run_log.exitcode)
+                and interactor_run_log.exitstatus == SandboxBase.EXIT_NONZERO_RETURN
+            ):
+                return _extra_check_and_sanitize(result)
+            else:
+                # Check for other verdicts, but potentially reinterpret RTEs as JUDGE_FAILED.
+                result = check_with_no_output(interactor_run_log)
+                if result.outcome == Outcome.RUNTIME_ERROR and reinterpret_rte:
+                    result.outcome = Outcome.JUDGE_FAILED
+                if result.outcome != Outcome.ACCEPTED:
+                    return _extra_check_and_sanitize(result)
+        else:
+            # Return any other checker/interactor errors, such as INTERNAL_ERRORs.
+            return _extra_check_and_sanitize(result)
+
+        # No relevant error was found.
+        return None
 
+    # 1. If the solution received SIGPIPE or was terminated, it means the
+    # interactor exited before it. Thus, check the interactor, as it might have
+    # returned a checker verdict.
+    #
+    # Also, do the same if the solution returned a non-zero exit code. Checker verdict
+    # should usually supersede a solution's RTE verdict.
+    if (
+        interactor_run_log is not None
+        and run_log is not None
+        and (
+            run_log.exitcode == -signal.SIGPIPE
+            or run_log.exitstatus == SandboxBase.EXIT_TERMINATED
+            or run_log.exitstatus == SandboxBase.EXIT_NONZERO_RETURN
+        )
+    ):
+        result = _check_interactor()
+        if result is not None and result.outcome != Outcome.ACCEPTED:
+            return _extra_check_and_sanitize(result)
+
+    # 2. Check if the solution failed without looking at its output (TLE, MLE, RTE, etc).
     result = check_with_no_output(run_log)
-    result.sanitizer_warnings = sanitizer_warnings
     if result.outcome != Outcome.ACCEPTED:
-        return result
+        return _extra_check_and_sanitize(result)
 
-    result = process_checker_run_log(
-        interactor_run_log,
-        interactor_stderr.read_text(),
-    )
-
-    if result is None:
-        result = check_with_no_output(interactor_run_log)
-        result.sanitizer_warnings = sanitizer_warnings
-        if result.outcome != Outcome.ACCEPTED:
-            result.outcome = Outcome.JUDGE_FAILED
-            return result
+    # 3. Now check interactor return code regardless of what happened to the
+    # solution.
+    result = _check_interactor()
+    if result is not None and result.outcome != Outcome.ACCEPTED:
+        return _extra_check_and_sanitize(result)
 
-    result.sanitizer_warnings = sanitizer_warnings
+    # Just a defensive pattern to ensure result is not None, should never happen.
+    result = check_with_no_output(interactor_run_log)
     if result.outcome != Outcome.ACCEPTED:
-        return result
+        if result.outcome == Outcome.RUNTIME_ERROR:
+            result.outcome = Outcome.JUDGE_FAILED
+        return _extra_check_and_sanitize(result)
 
+    # 4. Now actually check the output with a checker.
     if checker_digest is not None:
         result = await check(
             checker_digest, run_log, testcase, program_output, skip_run_log
         )
-        result.sanitizer_warnings = sanitizer_warnings
 
-    return result
+    return _extra_check_and_sanitize(result)

rbx/box/cli.py

@@ -222,7 +222,7 @@ async def run(
         tracked_solutions = {solution}
 
     if choice:
-        tracked_solutions = set(pick_solutions(tracked_solutions))
+        tracked_solutions = set(await pick_solutions(tracked_solutions))
         if not tracked_solutions:
             console.console.print('[error]No solutions selected. Exiting.[/error]')
             raise typer.Exit(1)
@@ -453,7 +453,7 @@ async def irun(
         tracked_solutions = {solution}
 
     if choice:
-        tracked_solutions = set(pick_solutions(tracked_solutions))
+        tracked_solutions = set(await pick_solutions(tracked_solutions))
         if not tracked_solutions:
             console.console.print('[error]No solutions selected. Exiting.[/error]')
             raise typer.Exit(1)
@@ -515,7 +515,8 @@ def create(
     help='Run a stress test.',
 )
 @package.within_problem
-def stress(
+@syncer.sync
+async def stress(
     name: Annotated[
         str,
         typer.Argument(
@@ -574,7 +575,7 @@ def stress(
     from rbx.box import stresses
 
     with utils.StatusProgress('Running stress...') as s:
-        report = stresses.run_stress(
+        report = await stresses.run_stress(
             name,
             timeout,
             args=generator_args,
@@ -608,15 +609,15 @@ def stress(
 
         import questionary
 
-        testgroup = questionary.select(
+        testgroup = await questionary.select(
             'Choose the testgroup to add the tests to.\nOnly test groups that have a .txt generatorScript are shown below: ',
             choices=list(groups_by_name) + ['(create new script)', '(skip)'],
-        ).ask()
+        ).ask_async()
 
         if testgroup == '(create new script)':
-            new_script_name = questionary.text(
+            new_script_name = await questionary.text(
                 'Enter the name of the new .txt generatorScript file: '
-            ).ask()
+            ).ask_async()
             new_script_path = pathlib.Path(new_script_name).with_suffix('.txt')
             new_script_path.parent.mkdir(parents=True, exist_ok=True)
             new_script_path.touch()
@@ -673,7 +674,8 @@ def stress(
     help='Compile an asset given its path.',
 )
 @package.within_problem
-def compile_command(
+@syncer.sync
+async def compile_command(
     path: Annotated[
         Optional[str],
         typer.Argument(help='Path to the asset to compile.'),
@@ -694,7 +696,7 @@ def compile_command(
     if path is None:
         import questionary
 
-        path = questionary.path("What's the path to your asset?").ask()
+        path = await questionary.path("What's the path to your asset?").ask_async()
         if path is None:
             console.console.print('[error]No path specified.[/error]')
             raise typer.Exit(1)

rbx/box/packaging/boca/packager.py

@@ -10,6 +10,7 @@ from rbx.box import package
 from rbx.box.environment import get_extension_or_default
 from rbx.box.packaging.boca.extension import BocaExtension, BocaLanguage
 from rbx.box.packaging.packager import BasePackager, BuiltStatement
+from rbx.box.schema import TaskType
 from rbx.box.statements.schema import Statement
 from rbx.config import get_default_app_path, get_testlib
 
@@ -24,6 +25,10 @@ def test_time(time):
 
 
 class BocaPackager(BasePackager):
+    @classmethod
+    def task_types(cls) -> List[TaskType]:
+        return [TaskType.BATCH, TaskType.COMMUNICATION]
+
     def _get_main_statement(self) -> Statement:
         pkg = package.find_problem_package_or_die()
 
@@ -119,7 +124,7 @@ class BocaPackager(BasePackager):
         )
 
     def _get_compare(self) -> str:
-        compare_path = get_default_app_path() / 'packagers' / 'boca' / 'compare'
+        compare_path = get_default_app_path() / 'packagers' / 'boca' / 'compare.sh'
         if not compare_path.exists():
             console.console.print(
                 '[error]BOCA template compare script not found.[/error]'
@@ -145,7 +150,26 @@ class BocaPackager(BasePackager):
             .replace('{{checker_content}}', checker)
         )
 
+    def _get_interactor(self) -> str:
+        extension = get_extension_or_default('boca', BocaExtension)
+
+        interactor_path = (
+            get_default_app_path() / 'packagers' / 'boca' / 'interactor_compile.sh'
+        )
+        if not interactor_path.exists():
+            console.console.print(
+                '[error]BOCA template interactor compile script not found.[/error]'
+            )
+            raise typer.Exit(1)
+
+        interactor_text = interactor_path.read_text()
+        interactor = package.get_interactor().path.read_text()
+        return interactor_text.replace(
+            '{{rbxFlags}}', extension.flags_with_defaults()['cc']
+        ).replace('{{interactor_content}}', interactor)
+
     def _get_compile(self, language: BocaLanguage) -> str:
+        pkg = package.find_problem_package_or_die()
         extension = get_extension_or_default('boca', BocaExtension)
 
         compile_path = (
@@ -160,6 +184,10 @@ class BocaPackager(BasePackager):
         compile_text = compile_path.read_text()
 
         assert 'umask 0022' in compile_text
+        if pkg.type == TaskType.COMMUNICATION:
+            compile_text = compile_text.replace(
+                'umask 0022', 'umask 0022\n\n' + self._get_interactor()
+            )
         compile_text = compile_text.replace(
             'umask 0022', 'umask 0022\n\n' + self._get_checker()
         )
@@ -197,7 +225,8 @@ class BocaPackager(BasePackager):
                     )
                 )
 
-    def name(self) -> str:
+    @classmethod
+    def name(cls) -> str:
         return 'boca'
 
     def package(
@@ -207,7 +236,7 @@ class BocaPackager(BasePackager):
         built_statements: List[BuiltStatement],
     ) -> pathlib.Path:
         extension = get_extension_or_default('boca', BocaExtension)
-
+        pkg = package.find_problem_package_or_die()
         # Prepare limits
         limits_path = into_path / 'limits'
         limits_path.mkdir(parents=True, exist_ok=True)
@@ -227,9 +256,17 @@ class BocaPackager(BasePackager):
             run_orig_path = (
                 get_default_app_path() / 'packagers' / 'boca' / 'run' / language
             )
+            if pkg.type == TaskType.COMMUNICATION:
+                run_orig_path = (
+                    get_default_app_path()
+                    / 'packagers'
+                    / 'boca'
+                    / 'interactive'
+                    / language
+                )
             if not run_orig_path.is_file():
                 console.console.print(
-                    f'[error]Run script for language [item]{language}[/item] not found.[/error]'
+                    f'[error]Run script for language [item]{language}[/item] not found for task of type [item]{pkg.type}[/item].[/error]'
                 )
                 raise typer.Exit(1)
             shutil.copyfile(run_orig_path, run_path / language)
@@ -268,11 +305,11 @@ class BocaPackager(BasePackager):
 
         testcases = self.get_flattened_built_testcases()
         for i, testcase in enumerate(testcases):
-            shutil.copyfile(testcase.inputPath, inputs_path / f'{i+1:03d}')
+            shutil.copyfile(testcase.inputPath, inputs_path / f'{i + 1:03d}')
             if testcase.outputPath is not None:
-                shutil.copyfile(testcase.outputPath, outputs_path / f'{i+1:03d}')
+                shutil.copyfile(testcase.outputPath, outputs_path / f'{i + 1:03d}')
             else:
-                (outputs_path / f'{i+1:03d}').touch()
+                (outputs_path / f'{i + 1:03d}').touch()
 
         # Zip all.
         shutil.make_archive(

rbx/box/packaging/main.py

@@ -28,6 +28,13 @@ async def run_packager(
         raise typer.Exit(1)
 
     pkg = package.find_problem_package_or_die()
+
+    if pkg.type not in packager_cls.task_types():
+        console.console.print(
+            f'[error]Packager [item]{packager_cls.name()}[/item] does not support task type [item]{pkg.type}[/item].[/error]'
+        )
+        raise typer.Exit(1)
+
     packager = packager_cls(**kwargs)
 
     statement_types = packager.statement_types()

rbx/box/packaging/moj/packager.py

@@ -7,10 +7,10 @@ import typer
 from rbx import console
 from rbx.box import package
 from rbx.box.environment import get_extension_or_default
-from rbx.box.packaging.boca.extension import BocaExtension
+from rbx.box.packaging.boca.extension import BocaExtension, BocaLanguage
 from rbx.box.packaging.boca.packager import BocaPackager
 from rbx.box.packaging.packager import BuiltStatement
-from rbx.box.schema import ExpectedOutcome
+from rbx.box.schema import ExpectedOutcome, TaskType
 from rbx.config import get_default_app_path, get_testlib
 from rbx.grading.judge.digester import digest_cooperatively
 
@@ -20,6 +20,10 @@ class MojPackager(BocaPackager):
         super().__init__()
         self.for_boca = for_boca
 
+    @classmethod
+    def task_types(cls) -> List[TaskType]:
+        return [TaskType.COMMUNICATION, TaskType.BATCH]
+
     def _get_problem_info(self) -> str:
         statement = self._get_main_statement()
         return (
@@ -40,8 +44,12 @@ class MojPackager(BocaPackager):
     def _get_limits(self) -> str:
         pkg = package.find_problem_package_or_die()
         ml = pkg.memoryLimit
-        ol = pkg.outputLimit
-        return f'ULIMITS[-f]={ol}\n' f'ULIMITS[-v]={ml * 1024}\n'
+        # ol = pkg.outputLimit
+        limits = [
+            f'ULIMITS[-v]={ml * 1024}',
+            # f'ULIMITS[-f]={ol}',
+        ]
+        return '\n'.join(limits) + '\n'
 
     def _get_compare(self) -> str:
         extension = get_extension_or_default('boca', BocaExtension)
@@ -65,6 +73,33 @@ class MojPackager(BocaPackager):
     def _get_checker(self) -> str:
         return package.get_checker().path.read_text()
 
+    def _get_interactor(self) -> str:
+        return package.get_interactor().path.read_text()
+
+    def _expand_language_vars(self, language: BocaLanguage, dir: pathlib.Path):
+        extension = get_extension_or_default('boca', BocaExtension)
+
+        for path in dir.glob('**/*'):
+            if not path.is_file():
+                continue
+
+            replaced = path.read_text()
+            replaced = replaced.replace(
+                '{{rbxMaxMemory}}', f'{self._get_pkg_memorylimit(language)}'
+            ).replace(
+                '{{rbxInitialMemory}}',
+                f'{min(512, int(self._get_pkg_memorylimit(language) * 0.9))}',
+            )
+
+            flags = extension.flags_with_defaults()
+            if language in flags:
+                replaced = replaced.replace('{{rbxFlags}}', flags[language])
+
+            path.write_text(replaced)
+
+            if path.suffix == '.sh':
+                path.chmod(0o755)
+
     def _copy_solutions_moj(self, into_path: pathlib.Path):
         into_path = into_path / 'sols'
         has_good = False
@@ -83,7 +118,8 @@ class MojPackager(BocaPackager):
             console.console.print('[error]No good solution found.[/error]')
             raise typer.Exit(1)
 
-    def name(self) -> str:
+    @classmethod
+    def name(cls) -> str:
         return 'moj'
 
     def package(
@@ -92,6 +128,8 @@ class MojPackager(BocaPackager):
         into_path: pathlib.Path,
         built_statements: List[BuiltStatement],
     ) -> pathlib.Path:
+        pkg = package.find_problem_package_or_die()
+
         # Prepare dummy files
         author_path = into_path / 'author'
         author_path.parent.mkdir(parents=True, exist_ok=True)
@@ -128,6 +166,48 @@ class MojPackager(BocaPackager):
         checker_path.parent.mkdir(parents=True, exist_ok=True)
         checker_path.write_text(self._get_checker())
 
+        # Prepare interactor
+        if pkg.type == TaskType.COMMUNICATION:
+            interactor_path = into_path / 'scripts' / 'interactor.cpp'
+            interactor_path.parent.mkdir(parents=True, exist_ok=True)
+            interactor_path.write_text(self._get_interactor())
+
+            interactor_prep_path = into_path / 'scripts' / 'interactor_prep.sh'
+            interactor_prep_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(
+                get_default_app_path()
+                / 'packagers'
+                / 'moj'
+                / 'scripts'
+                / 'interactor_prep.sh',
+                interactor_prep_path,
+            )
+            interactor_prep_path.chmod(0o755)
+
+            interactor_run_path = into_path / 'scripts' / 'interactor_run.sh'
+            interactor_run_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(
+                get_default_app_path()
+                / 'packagers'
+                / 'moj'
+                / 'scripts'
+                / 'interactor_run.sh',
+                interactor_run_path,
+            )
+            interactor_run_path.chmod(0o755)
+
+        # Prepare language scripts
+        extension = get_extension_or_default('boca', BocaExtension)
+        for language in extension.languages:
+            language_path = into_path / 'scripts' / language
+            language_path.parent.mkdir(parents=True, exist_ok=True)
+            src_path = (
+                get_default_app_path() / 'packagers' / 'moj' / 'scripts' / language
+            )
+            if src_path.exists():
+                shutil.copytree(src_path, language_path)
+                self._expand_language_vars(language, language_path)
+
         # Problem statement
         enunciado_path = into_path / 'docs' / 'enunciado.pdf'
         enunciado_path.parent.mkdir(parents=True, exist_ok=True)
@@ -150,11 +230,11 @@ class MojPackager(BocaPackager):
 
         testcases = self.get_flattened_built_testcases()
         for i, testcase in enumerate(testcases):
-            shutil.copyfile(testcase.inputPath, inputs_path / f'{i+1:03d}')
+            shutil.copyfile(testcase.inputPath, inputs_path / f'{i + 1:03d}')
             if testcase.outputPath is not None:
-                shutil.copyfile(testcase.outputPath, outputs_path / f'{i+1:03d}')
+                shutil.copyfile(testcase.outputPath, outputs_path / f'{i + 1:03d}')
             else:
-                (outputs_path / f'{i+1:03d}').touch()
+                (outputs_path / f'{i + 1:03d}').touch()
 
         # Zip all.
         shutil.make_archive(

rbx/box/packaging/packager.py

@@ -7,7 +7,7 @@ from rbx.box import package
 from rbx.box.contest import contest_package
 from rbx.box.contest.schema import ContestProblem, ContestStatement
 from rbx.box.generators import get_all_built_testcases
-from rbx.box.schema import Package, Testcase, TestcaseGroup
+from rbx.box.schema import Package, TaskType, Testcase, TestcaseGroup
 from rbx.box.statements.schema import Statement, StatementType
 
 
@@ -33,10 +33,15 @@ class BuiltProblemPackage:
 
 
 class BasePackager(ABC):
+    @classmethod
     @abstractmethod
-    def name(self) -> str:
+    def name(cls) -> str:
         pass
 
+    @classmethod
+    def task_types(cls) -> List[TaskType]:
+        return [TaskType.BATCH]
+
     def languages(self):
         pkg = package.find_problem_package_or_die()
 

rbx/box/packaging/polygon/packager.py

@@ -188,15 +188,15 @@ class PolygonPackager(BasePackager):
         for i, testcase in enumerate(testcases):
             shutil.copyfile(
                 testcase.inputPath,
-                into_path / f'tests/{i+1:03d}',
+                into_path / f'tests/{i + 1:03d}',
             )
             if testcase.outputPath is not None:
                 shutil.copyfile(
                     testcase.outputPath,
-                    into_path / f'tests/{i+1:03d}.a',
+                    into_path / f'tests/{i + 1:03d}.a',
                 )
             else:
-                (into_path / f'tests/{i+1:03d}.a').touch()
+                (into_path / f'tests/{i + 1:03d}.a').touch()
 
         # Write problem.xml
         (into_path / 'problem.xml').write_text(descriptor)
@@ -208,7 +208,8 @@ class PolygonPackager(BasePackager):
 
 
 class PolygonContestPackager(BaseContestPackager):
-    def name(self) -> str:
+    @classmethod
+    def name(cls) -> str:
         return 'polygon'
 
     def _get_names(self) -> List[polygon_schema.Name]:

rbx/box/solutions.py

@@ -616,7 +616,7 @@ def _get_solution_repr(sol: Solution) -> List[Tuple[str, str]]:
     ]
 
 
-def pick_solutions(tracked_solutions: Optional[Set[str]]) -> List[str]:
+async def pick_solutions(tracked_solutions: Optional[Set[str]]) -> List[str]:
     pkg = package.find_problem_package_or_die()
     if tracked_solutions is None:
         tracked_solutions = set(str(sol.path) for sol in pkg.solutions)
@@ -630,7 +630,7 @@ def pick_solutions(tracked_solutions: Optional[Set[str]]) -> List[str]:
         if str(sol.path) in tracked_solutions
     ]
 
-    picked = questionary.checkbox('Select solutions', choices=choices).ask()
+    picked = await questionary.checkbox('Select solutions', choices=choices).ask_async()
     if picked is None:
         raise typer.Abort()
     return picked

rbx/box/stresses.py

@@ -50,7 +50,6 @@ def _compile_finder(finder: CodeItem) -> str:
     return digest
 
 
-@syncer.sync
 async def run_stress(
     name: str,
     timeoutInSeconds: int,

rbx/box/tasks.py

@@ -194,7 +194,8 @@ async def _run_communication_solution_on_testcase(
             output_path = testcase.outputPath
         else:
             output_path = output_dir / testcase.inputPath.with_suffix('.out').name
-        error_path = output_path.with_suffix('.err')
+        solution_error_path = output_path.with_suffix('.sol.err')
+        interactor_error_path = output_path.with_suffix('.int.err')
         log_path = output_path.with_suffix('.log')
         output_path.parent.mkdir(parents=True, exist_ok=True)
 
@@ -204,7 +205,7 @@ async def _run_communication_solution_on_testcase(
         interactor_item = CommunicationItem(
             code=package.get_interactor(),
             executable=DigestOrSource.create(interactor_digest),
-            stderr=DigestOrDest.create(error_path),
+            stderr=DigestOrDest.create(interactor_error_path),
             extra_config=interactor_extra_config,
             extra_args='interactor.in interactor.out',
             inputs=[
@@ -230,6 +231,7 @@ async def _run_communication_solution_on_testcase(
         solution_item = CommunicationItem(
             code=solution,
             executable=DigestOrSource.create(compiled_digest),
+            stderr=DigestOrDest.create(solution_error_path),
             extra_config=extra_config,
             capture=DigestOrDest.create(solution_capture_path)
             if solution_capture_path
@@ -248,7 +250,7 @@ async def _run_communication_solution_on_testcase(
             checker_digest,
             run_log,
             interactor_run_log,
-            error_path,
+            interactor_error_path,
             testcase,
             output_path,
         )
@@ -263,7 +265,7 @@ async def _run_communication_solution_on_testcase(
             log=TestcaseLog(
                 **(run_log.model_dump() if run_log is not None else {}),
                 stdout_absolute_path=output_path.absolute(),
-                stderr_absolute_path=error_path.absolute(),
+                stderr_absolute_path=solution_error_path.absolute(),
                 log_absolute_path=log_path.absolute(),
             ),
         )