rbx.cp 0.5.40__py3-none-any.whl → 0.5.45__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/cacher.py

@@ -9,8 +9,6 @@ import tempfile
 import typing
 from typing import IO, List, Optional
 
-import gevent
-
 from rbx.grading.judge import digester, storage
 
 logger = logging.getLogger(__name__)
@@ -318,8 +316,6 @@ class FileCacher:
                 d.update(buf)
                 while len(buf) > 0:
                     written = dst.write(buf)
-                    # Cooperative yield.
-                    gevent.sleep(0)
                     if written is None:
                         break
                     buf = buf[written:]

rbx/grading/judge/digester.py

@@ -2,8 +2,6 @@ import hashlib
 import pathlib
 from typing import IO
 
-import gevent
-
 
 class Digester:
     """Simple wrapper of hashlib using our preferred hasher."""
@@ -26,7 +24,6 @@ def digest_cooperatively_into_digester(
     buf = f.read(chunk_size)
     while len(buf) > 0:
         digester.update(buf)
-        gevent.sleep(0)
         buf = f.read(chunk_size)
 
 

rbx/grading/judge/sandbox.py

@@ -1,4 +1,5 @@
 import abc
+import collections
 import dataclasses
 import io
 import logging
@@ -112,6 +113,13 @@ 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
+
+    # For timeit
+    timeit_dups: Dict[str, List[pathlib.Path]] = dataclasses.field(
+        default_factory=lambda: collections.defaultdict(list)
+    )
+    timeit_prefix: Optional[str] = None
 
     def get_cacheable_params(self) -> Dict[str, Any]:
         return self.model_dump(mode='json', exclude_unset=True, exclude_none=True)
@@ -393,6 +401,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,16 +91,30 @@ 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}')
+
+        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()
+        args.extend(file_args)
+
+        if self.params.timeit_dups:
+            for i, files in self.params.timeit_dups.items():
+                assert i.lower() in ['di', 'do', 'de']
+                for file in files:
+                    args.append(f'-{i}{file}')
+        if self.params.timeit_prefix:
+            args.append(f'-P{self.params.timeit_prefix}')
+
         return args
 
     def get_root_path(self) -> pathlib.Path:

rbx/grading/judge/sandboxes/timeit.py

@@ -6,10 +6,10 @@ import signal
 import stat
 import sys
 from time import monotonic
-from typing import List, Optional
+from typing import Any, Dict, List, Optional, Set, Union
 
 
-@dataclasses.dataclass()
+@dataclasses.dataclass
 class Options:
     output_file: str
     argv: List[str]
@@ -21,14 +21,100 @@ 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)
+    file_duplicates: Dict[int, List[str]] = dataclasses.field(default_factory=dict)
+    prefixed: Set[str] = dataclasses.field(default_factory=set)
+    prefix: str = ''
 
 
 def exit_with(code: int):
     sys.exit(code)
 
 
+def get_tee_command(files: List[str]) -> str:
+    path = (
+        os.path.join(os.path.dirname(os.path.realpath(__file__)), 'tee.py')
+        + ' '
+        + ' '.join(files)
+    )
+    return sys.executable + ' ' + path
+
+
+valid_modes = ['a', 'w']
+
+
+@dataclasses.dataclass
+class Tee:
+    file: Any
+    prefix: Union[str, bytes] = ''
+
+
+def create_tee(files, mode, buffer_size=4096, prefix=''):
+    """Get a file object that will mirror writes across multiple files objs
+
+    Options:
+        files     A list of files and/or file objects. All strings will be
+                  treated as file paths and opened for writing. Everything
+                  else is assumed to be a file-like object that implements
+                  both the write() and flush() methods.
+
+        mode      Which mode to use when opening new files. Valid values
+                  are 'a' (append) and 'w' (overwrite).
+
+        buffer_size
+                Control the size of the buffer between writes to the
+                resulting file object and the list of files.
+    """
+    if mode not in valid_modes:
+        raise IOError(
+            'Only valid modes to create_tee() are: %s' % ', '.join(valid_modes)
+        )
+
+    tee_list = []
+    for file in files:
+        if isinstance(file, Tee):
+            tee_list.append(file)
+        else:
+            tee_list.append(Tee(file))
+    for tee in tee_list:
+        if isinstance(tee.file, str):
+            tee.file = open(tee.file, f'{mode}b')
+        if isinstance(tee.prefix, str):
+            tee.prefix = tee.prefix.encode()
+
+    pipe_read, pipe_write = os.pipe()
+    pid = os.fork()
+    if pid == 0:
+        # Child -- Read bytes from the pipe and write them to the specified
+        #          files.
+        try:
+            # Close parent's end of the pipe
+            os.close(pipe_write)
+
+            bytes = os.read(pipe_read, buffer_size)
+            while bytes:
+                for tee in tee_list:
+                    if tee.prefix:
+                        tee.file.write(tee.prefix)
+                    tee.file.write(bytes)
+                    tee.file.flush()
+                    # TODO maybe add in fsync() here if the fileno() method
+                    # exists on file
+
+                bytes = os.read(pipe_read, buffer_size)
+        except Exception:
+            pass
+        finally:
+            os._exit(255)
+    else:
+        # Parent -- Return a file object wrapper around the pipe to the
+        #           child.
+        return os.fdopen(pipe_write, 'w', closefd=False)
+
+
 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,14 +127,28 @@ 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('-d') or opt.startswith('-D'):
+            is_prefixed = opt.startswith('-D')
+            possibilities = [None, 'o', 'e']
+            index = possibilities.index(opt[2])
+            if index not in options.file_duplicates:
+                options.file_duplicates[index] = []
+            options.file_duplicates[index].append(opt[3:])
+            if is_prefixed:
+                options.prefixed.add(opt[3:])
         elif opt.startswith('-c'):
             options.chdir = opt[2:]
         elif opt.startswith('-f'):
             options.fs_limit = int(opt[2:])
+        elif opt.startswith('-P'):
+            options.prefix = opt[2:]
         else:
             raise Exception(f'Invalid option {opt}')
         num_opts += 1
@@ -92,7 +192,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 = [
@@ -102,10 +203,18 @@ def redirect_fds(options: Options):
         if i == 0:
             # stdin
             open_args = [os.O_RDONLY]
-        fd = os.open(
-            file,
-            *open_args,
-        )
+        if i in options.file_duplicates:
+            dups = [
+                Tee(f, prefix=options.prefix if f in options.prefixed else '')
+                for f in options.file_duplicates[i]
+            ]
+            tee = create_tee(dups + [file], 'a', prefix=options.prefix)
+            fd = tee.fileno()
+        else:
+            fd = os.open(
+                file,
+                *open_args,
+            )
         os.dup2(fd, i)
         os.close(fd)
 
@@ -215,3 +324,4 @@ def main():
 
 if __name__ == '__main__':
     main()
+# type: ignore

rbx/grading/judge/storage.py

@@ -6,8 +6,6 @@ import tempfile
 from abc import ABC, abstractmethod
 from typing import IO, AnyStr, List, Optional
 
-import gevent
-
 logger = logging.getLogger(__name__)
 
 TOMBSTONE = 'x'
@@ -40,11 +38,9 @@ def copyfileobj(
         if maxlen > 0 and maxlen < len(buffer):
             buffer = buffer[:maxlen]
         while len(buffer) > 0:
-            gevent.sleep(0)
             written = destination_fobj.write(buffer)
             buffer = buffer[written:]
             maxlen -= written
-        gevent.sleep(0)
 
 
 @dataclasses.dataclass

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,
+    )