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

rbx/box/unit.py

@@ -1,5 +1,7 @@
 from typing import List, Optional
 
+import syncer
+
 from rbx import console
 from rbx.box import checkers, package, validators
 from rbx.box.schema import CodeItem, Testcase, ValidatorOutcome, ValidatorTest
@@ -13,7 +15,7 @@ def _get_validator_for_test(test: ValidatorTest) -> Optional[CodeItem]:
     return pkg.validator
 
 
-def run_validator_unit_tests(progress: StatusProgress):
+async def run_validator_unit_tests(progress: StatusProgress):
     pkg = package.find_problem_package_or_die()
 
     vals: List[CodeItem] = []
@@ -38,7 +40,7 @@ def run_validator_unit_tests(progress: StatusProgress):
             continue
 
         compiled_digest = compiled_validators[str(val.path)]
-        info = validators.validate_one_off(
+        info = await validators.validate_one_off(
             test.input,
             val,
             compiled_digest,
@@ -61,7 +63,7 @@ def run_validator_unit_tests(progress: StatusProgress):
                 console.console.print(f'  [status]Actual[/status] {info.message}')
 
 
-def run_checker_unit_tests(progress: StatusProgress):
+async def run_checker_unit_tests(progress: StatusProgress):
     pkg = package.find_problem_package_or_die()
     if not pkg.unitTests.checker:
         return
@@ -82,7 +84,7 @@ def run_checker_unit_tests(progress: StatusProgress):
     empty_file = package.get_empty_sentinel_path()
 
     for i, test in enumerate(pkg.unitTests.checker):
-        result = checkers.check(
+        result = await checkers.check(
             compiled_digest,
             run_log=None,
             testcase=Testcase(
@@ -108,6 +110,7 @@ def run_checker_unit_tests(progress: StatusProgress):
                 console.console.print(f'  [status]Message[/status] {result.message}')
 
 
-def run_unit_tests(progress: StatusProgress):
-    run_validator_unit_tests(progress)
-    run_checker_unit_tests(progress)
+@syncer.sync
+async def run_unit_tests(progress: StatusProgress):
+    await run_validator_unit_tests(progress)
+    await run_checker_unit_tests(progress)

rbx/box/validators.py

@@ -86,7 +86,7 @@ def _has_group_specific_validator() -> bool:
     return any(group.validator is not None for group in pkg.testcases)
 
 
-def _validate_testcase(
+async def _validate_testcase(
     testcase: pathlib.Path,
     validator: CodeItem,
     validator_digest: str,
@@ -103,7 +103,7 @@ def _validate_testcase(
 
     message_digest = DigestHolder()
     log_digest = DigestHolder()
-    run_log = run_item(
+    run_log = await run_item(
         validator,
         DigestOrSource.create(validator_digest),
         stdin=DigestOrSource.create(testcase),
@@ -140,13 +140,13 @@ def _validate_testcase(
     )
 
 
-def _validate_test(
+async def _validate_test(
     testcase: pathlib.Path,
     validator: CodeItem,
     validator_digest: str,
 ) -> Tuple[bool, Optional[str], HitBounds]:
     pkg = package.find_problem_package_or_die()
-    return _validate_testcase(
+    return await _validate_testcase(
         testcase, validator, validator_digest, vars=pkg.expanded_vars
     )
 
@@ -159,12 +159,12 @@ def compile_main_validator() -> Optional[Tuple[CodeItem, str]]:
     return pkg.validator, _compile_validator(pkg.validator)
 
 
-def validate_one_off(
+async def validate_one_off(
     testcase: pathlib.Path,
     validator: CodeItem,
     validator_digest: str,
 ) -> TestcaseValidationInfo:
-    ok, message, _ = _validate_test(testcase, validator, validator_digest)
+    ok, message, _ = await _validate_test(testcase, validator, validator_digest)
     info = TestcaseValidationInfo(
         validator=validator,
         group='interactive',
@@ -211,7 +211,7 @@ def compile_validators_for_entries(
     return compile_validators(validators, progress=progress)
 
 
-def validate_testcases(
+async def validate_testcases(
     progress: Optional[StatusProgress] = None,
     groups: Optional[Set[str]] = None,
 ) -> List[TestcaseValidationInfo]:
@@ -219,7 +219,7 @@ def validate_testcases(
         if progress is not None:
             progress.step()
 
-    validation_entries = extract_generation_testcases_from_groups(groups)
+    validation_entries = await extract_generation_testcases_from_groups(groups)
     validator_to_compiled_digest = compile_validators_for_entries(
         validation_entries, progress=progress
     )
@@ -234,7 +234,7 @@ def validate_testcases(
         # Main validation.
         if entry.validator is not None:
             compiled_digest = validator_to_compiled_digest[str(entry.validator.path)]
-            ok, message, hit_bounds = _validate_test(
+            ok, message, hit_bounds = await _validate_test(
                 input_path, entry.validator, compiled_digest
             )
             validation_info.append(
@@ -250,7 +250,7 @@ def validate_testcases(
 
         for extra_validator in entry.extra_validators:
             compiled_digest = validator_to_compiled_digest[str(extra_validator.path)]
-            ok, message, hit_bounds = _validate_test(
+            ok, message, hit_bounds = await _validate_test(
                 input_path, extra_validator, compiled_digest
             )
             validation_info.append(

rbx/box/validators_test.py

@@ -7,9 +7,9 @@ from rbx.box.validators import validate_testcases
 
 
 @pytest.mark.test_pkg('box1')
-def test_validators(pkg_from_testdata: pathlib.Path):
-    generate_testcases()
-    validation_infos = validate_testcases()
+async def test_validators(pkg_from_testdata: pathlib.Path):
+    await generate_testcases()
+    validation_infos = await validate_testcases()
 
     for info in validation_infos:
         assert info.ok

rbx/grading/judge/sandbox.py

@@ -112,6 +112,7 @@ class SandboxParams(pydantic.BaseModel):
     timeout: Optional[int] = None  # ms
     wallclock_timeout: Optional[int] = None  # ms
     extra_timeout: Optional[int] = None  # ms
+    reverse_io: bool = False
 
     def get_cacheable_params(self) -> Dict[str, Any]:
         return self.model_dump(mode='json', exclude_unset=True, exclude_none=True)
@@ -393,6 +394,13 @@ class SandboxBase(abc.ABC):
             return None
         return real_path
 
+    def create_fifo(self, path: pathlib.Path, override: bool = False):
+        real_path = self.relative_path(path)
+        if override:
+            real_path.unlink(missing_ok=True)
+        os.mkfifo(str(real_path))
+        return real_path
+
     def create_file_from_storage(
         self,
         path: pathlib.Path,

rbx/grading/judge/sandboxes/stupid_sandbox.py

@@ -91,17 +91,22 @@ class StupidSandbox(SandboxBase):
             args.append(f'-w{walltimeout_in_s:.3f}')
         if self.params.address_space:
             args.append(f'-m{self.params.address_space}')
-        if self.params.stdin_file:
-            args.append(f'-i{self.params.stdin_file}')
-        if self.params.stdout_file:
-            args.append(f'-o{self.params.stdout_file}')
-        if self.params.stderr_file:
-            args.append(f'-e{self.params.stderr_file}')
         if self.params.fsize:
             args.append(f'-f{self.params.fsize}')
         if self.chdir:
             args.append(f'-c{self.chdir}')
-        return args
+
+        file_args = []
+        if self.params.stdin_file:
+            file_args.append(f'-i{self.params.stdin_file}')
+        if self.params.stdout_file:
+            file_args.append(f'-o{self.params.stdout_file}')
+        if self.params.stderr_file:
+            file_args.append(f'-e{self.params.stderr_file}')
+        if self.params.reverse_io:
+            file_args.reverse()
+
+        return args + file_args
 
     def get_root_path(self) -> pathlib.Path:
         """Return the toplevel path of the sandbox.

rbx/grading/judge/sandboxes/timeit.py

@@ -9,7 +9,7 @@ from time import monotonic
 from typing import List, Optional
 
 
-@dataclasses.dataclass()
+@dataclasses.dataclass
 class Options:
     output_file: str
     argv: List[str]
@@ -21,6 +21,7 @@ class Options:
     wall_time_limit: Optional[float] = None  # seconds
     memory_limit: Optional[int] = None  # kb, but passed in args as mb
     fs_limit: Optional[int] = None  # kb
+    files_to_open: List[int] = dataclasses.field(default_factory=list)
 
 
 def exit_with(code: int):
@@ -29,6 +30,7 @@ def exit_with(code: int):
 
 def parse_opts() -> Options:
     options = Options(output_file=sys.argv[1], argv=[])
+    options.files_to_open = []
     num_opts = 0
     while num_opts + 2 < len(sys.argv) and sys.argv[num_opts + 2].startswith('-'):
         # Process option
@@ -41,10 +43,13 @@ def parse_opts() -> Options:
             options.memory_limit = int(opt[2:]) * 1024
         elif opt.startswith('-i'):
             options.stdin_file = opt[2:]
+            options.files_to_open.append(0)
         elif opt.startswith('-o'):
             options.stdout_file = opt[2:]
+            options.files_to_open.append(1)
         elif opt.startswith('-e'):
             options.stderr_file = opt[2:]
+            options.files_to_open.append(2)
         elif opt.startswith('-c'):
             options.chdir = opt[2:]
         elif opt.startswith('-f'):
@@ -92,7 +97,8 @@ def set_rlimits(options: Options):
 def redirect_fds(options: Options):
     files = [options.stdin_file, options.stdout_file, options.stderr_file]
 
-    for i, file in enumerate(files):
+    for i in options.files_to_open:
+        file = files[i]
         if file is None:
             continue
         open_args = [

rbx/grading/steps.py

@@ -1,10 +1,16 @@
+import asyncio
+import contextlib
+import dataclasses
 import functools
+import os
 import pathlib
 import re
 import shlex
 import shutil
 import subprocess
 import sys
+import tempfile
+import typing
 from enum import Enum
 from typing import IO, Any, Dict, Iterable, List, Optional, Tuple, Union
 
@@ -123,6 +129,8 @@ class GradingFileOutput(BaseModel):
     intermediate: bool = False
     # Whether to track file through its hash (disable for optimization).
     hash: bool = True
+    # Whether to touch the file before the command runs.
+    touch: bool = False
 
     def get_file(self, storage: Storage) -> Optional[IO[bytes]]:
         if self.dest is not None:
@@ -136,6 +144,15 @@ class GradingFileOutput(BaseModel):
         raise ValueError('No file to get')
 
 
+class GradingFifo(BaseModel):
+    # Destination path relative to the sandbox.
+    path: pathlib.Path
+    # Symlink to the FIFO outside the sandbox.
+    symlink: Optional[pathlib.Path] = None
+    # Whether to create the FIFO if it does not exist.
+    create: bool = True
+
+
 class GradingArtifacts(BaseModel):
     # Root directory for the produced artifacts.
     root: pathlib.Path = pathlib.PosixPath('.')
@@ -143,6 +160,8 @@ class GradingArtifacts(BaseModel):
     inputs: List[GradingFileInput] = []
     # List of output files to copy from the sandbox.
     outputs: List[GradingFileOutput] = []
+    # List of FIFOs
+    fifos: List[GradingFifo] = []
     # Capture certain logs of the execution.
     logs: Optional[GradingLogsHolder] = None
 
@@ -241,6 +260,14 @@ def _process_input_artifacts(artifacts: GradingArtifacts, sandbox: SandboxBase):
             override=True,
             try_symlink=True,
         )
+    for output_artifact in artifacts.outputs:
+        if output_artifact.touch:
+            sandbox.create_file_from_string(
+                output_artifact.src,
+                '',
+                executable=output_artifact.executable,
+                override=True,
+            )
 
 
 def _process_output_artifacts(
@@ -278,6 +305,14 @@ def _process_output_artifacts(
     return True
 
 
+def _process_fifos(artifacts: GradingArtifacts, sandbox: SandboxBase):
+    for fifo in artifacts.fifos:
+        if fifo.symlink is not None:
+            sandbox.create_symlink(fifo.path, fifo.symlink, override=True)
+        else:
+            sandbox.create_fifo(fifo.path, override=True)
+
+
 def testlib_grading_input() -> GradingFileInput:
     return GradingFileInput(src=get_testlib(), dest=pathlib.Path('testlib.h'))
 
@@ -553,7 +588,7 @@ def compile(
     return _process_output_artifacts(artifacts, sandbox)
 
 
-def run(
+async def run(
     command: str,
     params: SandboxParams,
     sandbox: SandboxBase,
@@ -561,10 +596,11 @@ def run(
     metadata: Optional[RunLogMetadata] = None,
 ) -> Optional[RunLog]:
     _process_input_artifacts(artifacts, sandbox)
+    _process_fifos(artifacts, sandbox)
     cmd = _split_and_expand(command, sandbox)
     sandbox.set_params(params)
 
-    if not sandbox.execute_without_std(cmd):
+    if not await asyncio.to_thread(sandbox.execute_without_std, cmd):
         console.print(
             '[error]Sandbox crashed while processing command:[/error]',
             utils.highlight_json_obj(cmd),
@@ -600,6 +636,34 @@ def run(
     return run_log
 
 
+@dataclasses.dataclass
+class CoordinatedRunParams:
+    command: str
+    params: SandboxParams
+    sandbox: SandboxBase
+    artifacts: GradingArtifacts
+    metadata: Optional[RunLogMetadata] = None
+
+
+async def run_coordinated(
+    interactor: CoordinatedRunParams,
+    solution: CoordinatedRunParams,
+) -> Tuple[Optional[RunLog], Optional[RunLog]]:
+    runs = tuple(
+        run(
+            params.command,
+            params.params,
+            params.sandbox,
+            params.artifacts,
+            params.metadata,
+        )
+        for params in [interactor, solution]
+    )
+    return typing.cast(
+        Tuple[Optional[RunLog], Optional[RunLog]], tuple(await asyncio.gather(*runs))
+    )
+
+
 def _normalize_checked_words(s: str) -> Tuple[str, ...]:
     return tuple(s.split())
 
@@ -722,3 +786,13 @@ def evaluate(
         log=log,
         result=checker_result,
     )
+
+
+@contextlib.contextmanager
+def make_fifos():
+    with tempfile.TemporaryDirectory() as temp_dir:
+        fifo_in = pathlib.PosixPath(temp_dir) / 'fifo.in'
+        fifo_out = pathlib.PosixPath(temp_dir) / 'fifo.out'
+        os.mkfifo(fifo_in)
+        os.mkfifo(fifo_out)
+        yield fifo_in, fifo_out

rbx/grading/steps_with_caching.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 from rbx.grading import steps
 from rbx.grading.caching import DependencyCache, NoCacheException
@@ -11,6 +11,12 @@ from rbx.grading.steps import (
 )
 
 
+def _get_prefixed_cacheable_params(
+    params: Dict[str, Any], prefix: str
+) -> Dict[str, Any]:
+    return {f'{prefix}.{k}': v for k, v in params.items()}
+
+
 def compile(
     commands: List[str],
     params: SandboxParams,
@@ -36,7 +42,7 @@ def compile(
     return ok
 
 
-def run(
+async def run(
     command: str,
     params: SandboxParams,
     sandbox: SandboxBase,
@@ -52,7 +58,7 @@ def run(
 
     with dependency_cache([command], [artifacts], cacheable_params) as is_cached:
         if not is_cached:
-            steps.run(
+            await steps.run(
                 command=command,
                 params=params,
                 artifacts=artifacts,
@@ -61,3 +67,39 @@ def run(
             )
 
     return artifacts.logs.run
+
+
+async def run_coordinated(
+    interactor: steps.CoordinatedRunParams,
+    solution: steps.CoordinatedRunParams,
+    dependency_cache: DependencyCache,
+) -> Tuple[Optional[RunLog], Optional[RunLog]]:
+    interactor.artifacts.logs = GradingLogsHolder()
+    solution.artifacts.logs = GradingLogsHolder()
+
+    cacheable_params = {
+        **_get_prefixed_cacheable_params(
+            interactor.params.get_cacheable_params(), 'interactor'
+        ),
+        **_get_prefixed_cacheable_params(
+            solution.params.get_cacheable_params(), 'solution'
+        ),
+    }
+
+    if interactor.metadata is not None and interactor.metadata.retryIndex is not None:
+        cacheable_params['interactor.__retry_index__'] = interactor.metadata.retryIndex
+    if solution.metadata is not None and solution.metadata.retryIndex is not None:
+        cacheable_params['solution.__retry_index__'] = solution.metadata.retryIndex
+
+    with dependency_cache(
+        [interactor.command, solution.command],
+        [interactor.artifacts, solution.artifacts],
+        cacheable_params,
+    ) as is_cached:
+        if not is_cached:
+            await steps.run_coordinated(interactor, solution)
+
+    return (
+        interactor.artifacts.logs.run,
+        solution.artifacts.logs.run,
+    )