rbx.cp 0.5.40__py3-none-any.whl → 0.5.45__py3-none-any.whl

rbx/box/code.py

@@ -1,3 +1,4 @@
+import dataclasses
 import pathlib
 import re
 import resource
@@ -14,6 +15,7 @@ from rbx import console
 from rbx.box import download, package, setter_config, state
 from rbx.box.environment import (
     ExecutionConfig,
+    FileMapping,
     get_compilation_config,
     get_execution_config,
     get_file_mapping,
@@ -26,7 +28,8 @@ from rbx.box.environment import (
 from rbx.box.formatting import get_formatted_memory
 from rbx.box.sanitizers import warning_stack
 from rbx.box.schema import CodeItem
-from rbx.grading import steps_with_caching
+from rbx.grading import steps, steps_with_caching
+from rbx.grading.judge.sandbox import SandboxParams
 from rbx.grading.steps import (
     DigestHolder,
     DigestOrDest,
@@ -202,6 +205,163 @@ function rbx() {{
         raise typer.Exit(1)
 
 
+@dataclasses.dataclass
+class PreparedRun:
+    command: str
+    sandbox_params: SandboxParams
+    artifacts: GradingArtifacts
+    sanitized: bool
+
+    file_mapping: FileMapping
+    metadata: RunLogMetadata
+
+
+@dataclasses.dataclass
+class CaptureSpec:
+    prefix: str
+    output: Optional[DigestOrDest] = None
+    merged_capture: Optional[pathlib.Path] = None
+
+
+def _prepare_for_communication(
+    run: PreparedRun,
+    stdin: pathlib.Path,
+    stdout: pathlib.Path,
+    reverse_io: bool = False,
+    capture: Optional[CaptureSpec] = None,
+):
+    run.sandbox_params.set_stdio(
+        stdin=stdin,
+        stdout=stdout,
+    )
+    run.sandbox_params.reverse_io = reverse_io
+    if capture is not None:
+        run.sandbox_params.timeit_prefix = capture.prefix
+
+        if capture.output is not None:
+            output_path = PosixPath('capture')
+            run.sandbox_params.timeit_dups['do'].append(output_path)
+
+            run.artifacts.outputs.append(
+                GradingFileOutput(
+                    src=output_path,
+                    **capture.output.expand(),
+                    touch=True,
+                )
+            )
+
+        if capture.merged_capture is not None:
+            merged_output_path = package.get_merged_capture_path().resolve()
+            run.sandbox_params.timeit_dups['Do'].append(merged_output_path)
+
+            run.artifacts.outputs.append(
+                GradingFileOutput(
+                    src=merged_output_path,
+                    dest=capture.merged_capture,
+                )
+            )
+
+
+def _prepare_run(
+    code: CodeItem,
+    executable: DigestOrSource,
+    stdin: Optional[DigestOrSource] = None,
+    stdout: Optional[DigestOrDest] = None,
+    stderr: Optional[DigestOrDest] = None,
+    inputs: Optional[List[GradingFileInput]] = None,
+    outputs: Optional[List[GradingFileOutput]] = None,
+    extra_args: Optional[str] = None,
+    extra_config: Optional[ExecutionConfig] = None,
+    retry_index: Optional[int] = None,
+):
+    language = find_language_name(code)
+    execution_options = get_execution_config(language)
+    if extra_config is not None:
+        execution_options = merge_execution_configs([execution_options, extra_config])
+    file_mapping = get_file_mapping(language)
+    sandbox_params = get_sandbox_params_from_config(execution_options.sandbox)
+
+    # Sanitization parameters.
+    sanitized = False
+    if is_executable_sanitized(executable):
+        # Remove any memory constraints for a sanitized executable.
+        # Sanitizers are known to be memory-hungry.
+        sandbox_params.address_space = None
+
+        # Reset timeout configs since sanitizers are known to be time-hungry.
+        sandbox_params.timeout = None
+        sandbox_params.wallclock_timeout = None
+        sanitized = True
+
+    sandbox_params.set_stdall(
+        stdin=PosixPath(file_mapping.input) if stdin is not None else None,
+        stdout=PosixPath(file_mapping.output) if stdout is not None else None,
+        stderr=PosixPath(file_mapping.error)
+        if stderr is not None or sanitized
+        else None,
+    )
+
+    assert execution_options.command
+    command = get_mapped_command(execution_options.command, file_mapping)
+    command = substitute_commands([command], sanitized=sanitized)[0]
+
+    if extra_args is not None:
+        splitted_command = shlex.split(command)
+        splitted_command.extend(shlex.split(extra_args))
+        command = shlex.join(splitted_command)
+
+    artifacts = GradingArtifacts()
+    artifacts.inputs.append(
+        GradingFileInput(
+            **executable.expand(),
+            dest=PosixPath(file_mapping.executable),
+            executable=True,
+        )
+    )
+    if stdin is not None:
+        artifacts.inputs.append(
+            GradingFileInput(
+                **stdin.expand(),
+                dest=PosixPath(file_mapping.input),
+            )
+        )
+    if stdout is not None:
+        artifacts.outputs.append(
+            GradingFileOutput(
+                src=PosixPath(file_mapping.output),
+                **stdout.expand(),
+                touch=True,
+            )
+        )
+    if stderr is not None:
+        artifacts.outputs.append(
+            GradingFileOutput(
+                src=PosixPath(file_mapping.error),
+                **stderr.expand(),
+                touch=True,
+            )
+        )
+    if inputs:
+        artifacts.inputs.extend(inputs)
+    if outputs:
+        artifacts.outputs.extend(outputs)
+
+    return PreparedRun(
+        command=command,
+        sandbox_params=sandbox_params,
+        artifacts=artifacts,
+        sanitized=sanitized,
+        file_mapping=file_mapping,
+        metadata=RunLogMetadata(
+            language=code.language,
+            is_sanitized=sanitized,
+            timeLimit=sandbox_params.timeout,
+            memoryLimit=sandbox_params.address_space,
+            retryIndex=retry_index,
+        ),
+    )
+
+
 # Compile code item and return its digest in the storage.
 def compile_item(
     code: CodeItem,
@@ -310,7 +470,7 @@ def compile_item(
     return compiled_digest.value
 
 
-def run_item(
+async def run_item(
     code: CodeItem,
     executable: DigestOrSource,
     stdin: Optional[DigestOrSource] = None,
@@ -324,99 +484,127 @@ def run_item(
 ) -> Optional[RunLog]:
     _check_stack_limit()
 
-    language = find_language_name(code)
-    execution_options = get_execution_config(language)
-    if extra_config is not None:
-        execution_options = merge_execution_configs([execution_options, extra_config])
-    file_mapping = get_file_mapping(language)
     dependency_cache = package.get_dependency_cache()
-    sandbox = package.get_singleton_sandbox()
-    sandbox_params = get_sandbox_params_from_config(execution_options.sandbox)
-
-    # Sanitization parameters.
-    sanitized = False
-    if is_executable_sanitized(executable):
-        # Remove any memory constraints for a sanitized executable.
-        # Sanitizers are known to be memory-hungry.
-        sandbox_params.address_space = None
-
-        # Reset timeout configs since sanitizers are known to be time-hungry.
-        sandbox_params.timeout = None
-        sandbox_params.wallclock_timeout = None
-        sanitized = True
 
-    sandbox_params.set_stdall(
-        stdin=PosixPath(file_mapping.input) if stdin is not None else None,
-        stdout=PosixPath(file_mapping.output) if stdout is not None else None,
-        stderr=PosixPath(file_mapping.error)
-        if stderr is not None or sanitized
-        else None,
+    prepared = _prepare_run(
+        code,
+        executable,
+        stdin,
+        stdout,
+        stderr,
+        inputs,
+        outputs,
+        extra_args,
+        extra_config,
+        retry_index,
     )
 
-    assert execution_options.command
-    command = get_mapped_command(execution_options.command, file_mapping)
-    command = substitute_commands([command], sanitized=sanitized)[0]
-
-    if extra_args is not None:
-        splitted_command = shlex.split(command)
-        splitted_command.extend(shlex.split(extra_args))
-        command = shlex.join(splitted_command)
-
-    artifacts = GradingArtifacts()
-    artifacts.inputs.append(
-        GradingFileInput(
-            **executable.expand(),
-            dest=PosixPath(file_mapping.executable),
-            executable=True,
-        )
-    )
-    if stdin is not None:
-        artifacts.inputs.append(
-            GradingFileInput(
-                **stdin.expand(),
-                dest=PosixPath(file_mapping.input),
-            )
-        )
-    if stdout is not None:
-        artifacts.outputs.append(
-            GradingFileOutput(
-                src=PosixPath(file_mapping.output),
-                **stdout.expand(),
-            )
-        )
-    if stderr is not None:
-        artifacts.outputs.append(
-            GradingFileOutput(
-                src=PosixPath(file_mapping.error),
-                **stderr.expand(),
-            )
-        )
-    if inputs:
-        artifacts.inputs.extend(inputs)
-    if outputs:
-        artifacts.outputs.extend(outputs)
-
-    run_log = steps_with_caching.run(
-        command,
-        params=sandbox_params,
-        sandbox=sandbox,
-        artifacts=artifacts,
+    run_log = await steps_with_caching.run(
+        prepared.command,
+        params=prepared.sandbox_params,
+        sandbox=package.get_singleton_sandbox(),
+        artifacts=prepared.artifacts,
         dependency_cache=dependency_cache,
-        metadata=RunLogMetadata(
-            language=code.language,
-            is_sanitized=sanitized,
-            timeLimit=sandbox_params.timeout,
-            memoryLimit=sandbox_params.address_space,
-            retryIndex=retry_index,
-        ),
+        metadata=prepared.metadata,
     )
 
     # Find sanitizer logs.
     if run_log is not None and run_log.warnings:
-        assert sandbox_params.stderr_file is not None
-        stderr_output = artifacts.get_output_file_for_src(sandbox_params.stderr_file)
+        assert prepared.sandbox_params.stderr_file is not None
+        stderr_output = prepared.artifacts.get_output_file_for_src(
+            prepared.sandbox_params.stderr_file
+        )
         if stderr_output is not None:
             warning_stack.get_warning_stack().add_sanitizer_warning(
                 package.get_cache_storage(), code, stderr_output
             )
     return run_log
+
+
+@dataclasses.dataclass
+class CommunicationItem:
+    code: CodeItem
+    executable: DigestOrSource
+    stderr: Optional[DigestOrDest] = None
+    inputs: Optional[List[GradingFileInput]] = None
+    outputs: Optional[List[GradingFileOutput]] = None
+    extra_args: Optional[str] = None
+    extra_config: Optional[ExecutionConfig] = None
+    capture: Optional[DigestOrDest] = None
+
+    def prepare(self) -> PreparedRun:
+        return _prepare_run(
+            self.code,
+            self.executable,
+            stderr=self.stderr,
+            inputs=self.inputs,
+            outputs=self.outputs,
+            extra_args=self.extra_args,
+            extra_config=self.extra_config,
+        )
+
+
+async def run_communication(
+    interactor: CommunicationItem,
+    solution: CommunicationItem,
+    merged_capture: Optional[pathlib.Path] = None,
+    retry_index: Optional[int] = None,
+):
+    fifo_in, fifo_out = package.get_fifos()
+    interactor_prepared = interactor.prepare()
+    solution_prepared = solution.prepare()
+
+    # Prepare retry index.
+    interactor_prepared.metadata.retryIndex = retry_index
+    solution_prepared.metadata.retryIndex = retry_index
+
+    interactor_prefix = 'INTERACTOR:'
+    solution_prefix = 'SOLUTION:'
+
+    if merged_capture is not None:
+        package.get_merged_capture_path().write_text(
+            f'{interactor_prefix}\n{solution_prefix}\n'
+        )
+
+    _prepare_for_communication(
+        interactor_prepared,
+        fifo_out,
+        fifo_in,
+        capture=CaptureSpec(
+            prefix=interactor_prefix,
+            output=interactor.capture,
+            merged_capture=merged_capture,
+        ),
+    )
+    _prepare_for_communication(
+        solution_prepared,
+        fifo_in,
+        fifo_out,
+        reverse_io=True,
+        capture=CaptureSpec(
+            prefix=solution_prefix,
+            output=solution.capture,
+            merged_capture=merged_capture,
+        ),
+    )
+
+    interactor_run_params = steps.CoordinatedRunParams(
+        command=interactor_prepared.command,
+        params=interactor_prepared.sandbox_params,
+        sandbox=package.get_singleton_interactor_sandbox(),
+        artifacts=interactor_prepared.artifacts,
+        metadata=interactor_prepared.metadata,
+    )
+    solution_run_params = steps.CoordinatedRunParams(
+        command=solution_prepared.command,
+        params=solution_prepared.sandbox_params,
+        sandbox=package.get_singleton_sandbox(),
+        artifacts=solution_prepared.artifacts,
+        metadata=solution_prepared.metadata,
+    )
+
+    return await steps_with_caching.run_coordinated(
+        interactor_run_params,
+        solution_run_params,
+        dependency_cache=package.get_dependency_cache(),
+    )

rbx/box/contest/statements.py

@@ -1,5 +1,6 @@
 from typing import Annotated, List, Optional
 
+import syncer
 import typer
 
 from rbx import annotations, console
@@ -16,7 +17,8 @@ app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
 
 @app.command('build, b', help='Build statements.')
 @within_contest
-def build(
+@syncer.sync
+async def build(
     verification: environment.VerificationParam,
     languages: Annotated[
         Optional[List[str]],
@@ -53,7 +55,7 @@ def build(
             with cd.new_package_cd(problem.get_path()):
                 package.clear_package_cache()
 
-                if not builder.build(
+                if not await builder.build(
                     verification=verification, groups=set(['samples']), output=None
                 ):
                     console.console.print(

rbx/box/generators.py

@@ -1,5 +1,6 @@
 import pathlib
 import shutil
+import tempfile
 from typing import Dict, List, Optional, Set
 
 import typer
@@ -7,15 +8,13 @@ import typer
 from rbx import console
 from rbx.box import checkers, package, testcase_utils, validators
 from rbx.box.code import SanitizationLevel, compile_item, run_item
-from rbx.box.environment import (
-    EnvironmentSandbox,
-    ExecutionConfig,
-)
 from rbx.box.schema import (
     CodeItem,
     GeneratorCall,
+    TaskType,
     Testcase,
 )
+from rbx.box.tasks import run_solution_on_testcase
 from rbx.box.testcase_extractors import (
     GenerationMetadata,
     GenerationTestcaseEntry,
@@ -32,6 +31,8 @@ from rbx.grading.steps import (
     DigestHolder,
     DigestOrDest,
     DigestOrSource,
+    Evaluation,
+    Outcome,
 )
 from rbx.utils import StatusProgress
 
@@ -73,7 +74,7 @@ def get_call_from_string(call_str: str) -> GeneratorCall:
     return GeneratorCall(name=name, args=args)
 
 
-def _get_necessary_generators_for_groups(
+async def _get_necessary_generators_for_groups(
     groups: Optional[Set[str]] = None,
 ) -> Set[str]:
     pkg = package.find_problem_package_or_die()
@@ -81,11 +82,11 @@ def _get_necessary_generators_for_groups(
     necessary_generators = set()
 
     class NecessaryGeneratorsVisitor(TestcaseGroupVisitor):
-        def visit(self, entry: GenerationTestcaseEntry):
+        async def visit(self, entry: GenerationTestcaseEntry):
             if entry.metadata.generator_call is not None:
                 necessary_generators.add(entry.metadata.generator_call.name)
 
-    run_testcase_visitor(NecessaryGeneratorsVisitor(groups))
+    await run_testcase_visitor(NecessaryGeneratorsVisitor(groups))
 
     return existing_generators.intersection(necessary_generators)
 
@@ -126,7 +127,7 @@ def expand_generator_call(call: GeneratorCall) -> GeneratorCall:
     return call.model_copy(update={'args': generator_for_args.generate(parsed_args)})
 
 
-def generate_standalone(
+async def generate_standalone(
     spec: GenerationMetadata,
     validate: bool = True,
     group_entry: Optional[TestcaseEntry] = None,
@@ -166,7 +167,7 @@ def generate_standalone(
             progress.update(
                 f'Generating testcase [status]{generator.name} {call.args}[/status]...'
             )
-        generation_log = run_item(
+        generation_log = await run_item(
             generator,
             DigestOrSource.create(generator_digest),
             stdout=DigestOrDest.create(spec.copied_to.inputPath),
@@ -200,7 +201,7 @@ def generate_standalone(
             _, validator_digest = validator_tp
         if progress:
             progress.update('Validating test...')
-        validation_info = validators.validate_one_off(
+        validation_info = await validators.validate_one_off(
             spec.copied_to.inputPath,
             validator,
             validator_digest,
@@ -214,7 +215,7 @@ def generate_standalone(
             raise typer.Exit(1)
 
 
-def generate_testcases(
+async def generate_testcases(
     progress: Optional[StatusProgress] = None, groups: Optional[Set[str]] = None
 ):
     def step():
@@ -223,7 +224,7 @@ def generate_testcases(
 
     compiled_generators = compile_generators(
         progress=progress,
-        tracked_generators=_get_necessary_generators_for_groups(groups)
+        tracked_generators=await _get_necessary_generators_for_groups(groups)
         if groups is not None
         else None,
     )
@@ -231,7 +232,7 @@ def generate_testcases(
     testcase_utils.clear_built_testcases()
 
     class BuildTestcaseVisitor(TestcaseGroupVisitor):
-        def visit(self, entry: GenerationTestcaseEntry):
+        async def visit(self, entry: GenerationTestcaseEntry):
             if entry.metadata.copied_from is not None:
                 _copy_testcase_over(
                     entry.metadata.copied_from,
@@ -239,7 +240,7 @@ def generate_testcases(
                 )
 
             if entry.metadata.generator_call is not None:
-                generate_standalone(
+                await generate_standalone(
                     entry.metadata,
                     group_entry=entry.group_entry,
                     validate=False,
@@ -249,13 +250,14 @@ def generate_testcases(
                 )
             step()
 
-    run_testcase_visitor(BuildTestcaseVisitor(groups))
+    await run_testcase_visitor(BuildTestcaseVisitor(groups))
 
 
-def generate_output_for_testcase(
+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)
@@ -265,55 +267,51 @@ def generate_output_for_testcase(
         # Output file was already copied over from manual tests.
         return
 
-    pkg = package.find_problem_package_or_die()
     main_solution = package.get_main_solution()
     if main_solution is None:
         return
 
-    # Obey no limits when generating testcases.
-    sandbox = EnvironmentSandbox()
-    sandbox.fileSizeLimit = pkg.outputLimit
-    extra_config = ExecutionConfig(sandbox=sandbox)
+    with tempfile.TemporaryDirectory() as dir:
+        output_dir = pathlib.Path(dir)
 
-    try:
-        run_log = run_item(
+        eval: Evaluation = await run_solution_on_testcase(
             main_solution,
-            DigestOrSource.create(main_solution_digest),
-            stdin=DigestOrSource.create(testcase.inputPath),
-            stdout=DigestOrDest.create(testcase.outputPath),
-            stderr=DigestOrDest.create(stderr_path)
-            if stderr_path is not None
-            else None,
-            extra_config=extra_config,
-        )
-    except:
-        console.console.print(
-            '[error]Failed running main solution to generate testcase.[/error]'
+            main_solution_digest,
+            None,
+            testcase,
+            output_dir,
+            interactor_digest=interactor_digest,
+            use_retries=False,
+            use_timelimit=False,
         )
-        raise
 
-    if run_log is None or run_log.exitcode != 0:
-        console.console.print(
-            f'[error]Failed generating output for [item]{testcase.inputPath}[/item][/error]',
-        )
-        if run_log is not None:
-            console.console.print(f'[error]Summary:[/error] {run_log.get_summary()}')
-            checker_result = checkers.check_with_no_output(run_log)
+        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]{checker_result.outcome.value}[/item][/warning]',
+                f'[warning]Verdict: [item]{eval.result.outcome.value}[/item][/warning]',
             )
             console.console.print(
-                f'[warning]Message: [info]{checker_result.message}[/info][/warning]',
+                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]'
             )
-            console.console.print(f'Stderr written at [item]{stderr_path}[/item]')
-        raise typer.Exit(1)
+            if stderr_path is not None:
+                console.console.print(f'Stderr written at [item]{stderr_path}[/item]')
+
+            raise typer.Exit(1)
 
 
-def generate_outputs_for_testcases(
+async def generate_outputs_for_testcases(
     entries: List[TestcaseEntry],
     progress: Optional[StatusProgress] = None,
 ):
@@ -324,6 +322,13 @@ def generate_outputs_for_testcases(
     main_solution = package.get_main_solution()
     solution_digest: Optional[str] = None
 
+    pkg = package.find_problem_package_or_die()
+
+    if pkg.type == TaskType.COMMUNICATION:
+        interactor_digest = checkers.compile_interactor(progress)
+    else:
+        interactor_digest = None
+
     if main_solution is not None:
         if progress:
             progress.update('Compiling main solution...')
@@ -337,7 +342,7 @@ def generate_outputs_for_testcases(
     shutil.rmtree(str(gen_runs_dir), ignore_errors=True)
     gen_runs_dir.mkdir(parents=True, exist_ok=True)
 
-    generation_entries = extract_generation_testcases(entries)
+    generation_entries = await extract_generation_testcases(entries)
 
     for entry in generation_entries:
         tc = entry.metadata.copied_to
@@ -354,9 +359,10 @@ def generate_outputs_for_testcases(
             raise typer.Exit(1)
 
         assert solution_digest is not None
-        generate_output_for_testcase(
+        await generate_output_for_testcase(
             solution_digest,
             tc,
             gen_runs_dir / 'main.stderr',
+            interactor_digest=interactor_digest,
         )
         step()