rbx.cp 0.5.45__tar.gz → 0.5.47__tar.gz

{rbx_cp-0.5.45 → rbx_cp-0.5.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rbx.cp
-Version: 0.5.45
+Version: 0.5.47
 Summary: 
 Author: Roberto Sales
 Requires-Python: >=3.9,<4.0

{rbx_cp-0.5.45 → rbx_cp-0.5.47}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rbx.cp"
-version = "0.5.45"
+version = "0.5.47"
 description = ""
 packages = [
   {include = "rbx"}

{rbx_cp-0.5.45 → rbx_cp-0.5.47}/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_cp-0.5.45 → rbx_cp-0.5.47}/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_cp-0.5.45 → rbx_cp-0.5.47}/rbx/box/generators.py

@@ -1,6 +1,5 @@
 import pathlib
 import shutil
-import tempfile
 from typing import Dict, List, Optional, Set
 
 import typer
@@ -63,6 +62,47 @@ def _copy_testcase_over(
         )
 
 
+def _copy_testcase_output_over(
+    src_output_path: pathlib.Path, dest_output_path: pathlib.Path, suffix: str
+) -> bool:
+    dest_output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    src_path = src_output_path.with_suffix(suffix)
+    if not src_path.is_file():
+        return False
+
+    shutil.copy(str(src_path), str(dest_output_path.with_suffix(suffix)))
+    return True
+
+
+def _copy_testcase_outputs_over(
+    testcase: Testcase, dest: Testcase, pipes: bool = False
+):
+    assert dest.outputPath is not None
+    dest.outputPath.parent.mkdir(parents=True, exist_ok=True)
+
+    has_copied = False
+
+    if testcase.outputPath is not None and testcase.outputPath.is_file():
+        shutil.copy(str(testcase.outputPath), str(dest.outputPath))
+        has_copied = True
+
+    if not pipes:
+        return has_copied
+
+    reference_path = testcase.outputPath or testcase.inputPath
+    if _copy_testcase_output_over(reference_path, dest.outputPath, '.pin'):
+        has_copied = True
+
+    if _copy_testcase_output_over(reference_path, dest.outputPath, '.pout'):
+        has_copied = True
+
+    if _copy_testcase_output_over(reference_path, dest.outputPath, '.pio'):
+        has_copied = True
+
+    return has_copied
+
+
 def get_all_built_testcases() -> Dict[str, List[Testcase]]:
     pkg = package.find_problem_package_or_die()
     res = {group.name: find_built_testcases(group) for group in pkg.testcases}
@@ -256,59 +296,46 @@ async def generate_testcases(
 async def generate_output_for_testcase(
     main_solution_digest: str,
     testcase: Testcase,
-    stderr_path: Optional[pathlib.Path] = None,
     interactor_digest: Optional[str] = None,
 ):
     assert testcase.outputPath is not None
     testcase.inputPath.parent.mkdir(parents=True, exist_ok=True)
     testcase.outputPath.parent.mkdir(parents=True, exist_ok=True)
 
-    if testcase.outputPath.is_file():
-        # Output file was already copied over from manual tests.
-        return
-
     main_solution = package.get_main_solution()
     if main_solution is None:
         return
 
-    with tempfile.TemporaryDirectory() as dir:
-        output_dir = pathlib.Path(dir)
+    eval: Evaluation = await run_solution_on_testcase(
+        main_solution,
+        main_solution_digest,
+        None,
+        testcase,
+        interactor_digest=interactor_digest,
+        use_retries=False,
+        use_timelimit=False,
+        capture_pipes=True,
+    )
 
-        eval: Evaluation = await run_solution_on_testcase(
-            main_solution,
-            main_solution_digest,
-            None,
-            testcase,
-            output_dir,
-            interactor_digest=interactor_digest,
-            use_retries=False,
-            use_timelimit=False,
+    if eval.result.outcome != Outcome.ACCEPTED:
+        console.console.print(
+            f'[error]Failed generating output for [item]{testcase.inputPath}[/item][/error]',
         )
-
-        if eval.log.stdout_absolute_path is not None:
-            shutil.copy(eval.log.stdout_absolute_path, testcase.outputPath)
-        if eval.log.stderr_absolute_path is not None and stderr_path is not None:
-            shutil.copy(eval.log.stderr_absolute_path, stderr_path)
-
-        if eval.result.outcome != Outcome.ACCEPTED:
-            console.console.print(
-                f'[error]Failed generating output for [item]{testcase.inputPath}[/item][/error]',
-            )
-            console.console.print(f'[error]Summary:[/error] {eval.log.get_summary()}')
-            console.console.print(
-                f'[warning]Verdict: [item]{eval.result.outcome.value}[/item][/warning]',
-            )
-            console.console.print(
-                f'[warning]Message: [info]{eval.result.message}[/info][/warning]',
-            )
-            console.console.print(f'Input written at [item]{testcase.inputPath}[/item]')
+        console.console.print(f'[error]Summary:[/error] {eval.log.get_summary()}')
+        console.console.print(
+            f'[warning]Verdict: [item]{eval.result.outcome.value}[/item][/warning]',
+        )
+        console.console.print(
+            f'[warning]Message: [info]{eval.result.message}[/info][/warning]',
+        )
+        console.console.print(f'Input written at [item]{testcase.inputPath}[/item]')
+        console.console.print(f'Output written at [item]{testcase.outputPath}[/item]')
+        if eval.log.stderr_absolute_path is not None:
             console.console.print(
-                f'Output written at [item]{testcase.outputPath}[/item]'
+                f'Stderr written at [item]{eval.log.stderr_absolute_path}[/item]'
             )
-            if stderr_path is not None:
-                console.console.print(f'Stderr written at [item]{stderr_path}[/item]')
 
-            raise typer.Exit(1)
+        raise typer.Exit(1)
 
 
 async def generate_outputs_for_testcases(
@@ -350,6 +377,14 @@ async def generate_outputs_for_testcases(
             return
         assert tc.outputPath is not None
 
+        if entry.metadata.copied_from is not None and _copy_testcase_outputs_over(
+            entry.metadata.copied_from, tc
+        ):
+            # Copy remaining pipe files.
+            _copy_testcase_outputs_over(entry.metadata.copied_from, tc, pipes=True)
+            step()
+            continue
+
         if (
             main_solution is None or solution_digest is None
         ) and not tc.outputPath.is_file():
@@ -362,7 +397,9 @@ async def generate_outputs_for_testcases(
         await generate_output_for_testcase(
             solution_digest,
             tc,
-            gen_runs_dir / 'main.stderr',
             interactor_digest=interactor_digest,
         )
+        if entry.metadata.copied_from is not None:
+            # Copy remaining pipe files.
+            _copy_testcase_outputs_over(entry.metadata.copied_from, tc, pipes=True)
         step()

{rbx_cp-0.5.45 → rbx_cp-0.5.47}/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_cp-0.5.45 → rbx_cp-0.5.47}/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()