rbx.cp 0.13.3__py3-none-any.whl → 0.13.5__py3-none-any.whl

rbx/box/testing/testing_preset.py

@@ -0,0 +1,36 @@
+import pathlib
+
+from rbx import utils
+from rbx.box.presets.schema import Preset
+from rbx.box.testing.testing_shared import PathOrStr, TestingShared
+
+
+class TestingPreset(TestingShared):
+    def __init__(self, root: PathOrStr):
+        super().__init__(root)
+        self._yml = None
+
+    def initialize(self):
+        if not self.yml_path.exists():
+            self.yml_path.parent.mkdir(parents=True, exist_ok=True)
+            self.yml_path.touch()
+            self.yml_path.write_text(
+                utils.model_to_yaml(
+                    Preset(uri='rsalesc/test-preset', env=pathlib.Path('env.rbx.yml'))
+                )
+            )
+            self.add_from_resources(
+                pathlib.Path('env.rbx.yml'), pathlib.Path('presets/default/env.rbx.yml')
+            )
+
+    def yml_path(self) -> pathlib.Path:
+        return self.root / 'preset.rbx.yml'
+
+    @property
+    def yml(self) -> Preset:
+        if self._yml is None:
+            self._yml = utils.model_from_yaml(Preset, self.yml_path.read_text())
+        return self._yml
+
+    def save(self):
+        self.yml_path.write_text(utils.model_to_yaml(self.yml))

rbx/box/testing/testing_shared.py

@@ -0,0 +1,81 @@
+import os
+import pathlib
+import shutil
+import tempfile
+from typing import Optional, Union
+
+from rbx import testing_utils, utils
+from rbx.config import get_resources_file
+from rbx.testing_utils import get_testdata_path
+
+PathOrStr = Union[os.PathLike, str]
+
+
+class TestingShared:
+    def __init__(self, root: PathOrStr):
+        self.root = pathlib.Path(root)
+        self._created_tmps = []
+        self._old_cwd = None
+
+    def __enter__(self):
+        self._old_cwd = pathlib.Path.cwd()
+        os.chdir(self.root)
+        testing_utils.clear_all_functools_cache()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self._old_cwd is not None:
+            os.chdir(self._old_cwd)
+        self.cleanup()
+
+    def path(self, path: PathOrStr) -> pathlib.Path:
+        return self.root / path
+
+    def abspath(self, path: PathOrStr) -> pathlib.Path:
+        return utils.abspath(self.path(path))
+
+    def mkdtemp(self) -> pathlib.Path:
+        temp_dir = pathlib.Path(tempfile.mkdtemp())
+        self._created_tmps.append(temp_dir)
+        return temp_dir
+
+    def cleanup(self):
+        for tmp in self._created_tmps:
+            shutil.rmtree(tmp)
+
+    def add_file(
+        self, path: PathOrStr, src: Optional[PathOrStr] = None
+    ) -> pathlib.Path:
+        filename = self.path(path)
+        filename.parent.mkdir(parents=True, exist_ok=True)
+        if src is not None:
+            self.add_from_testdata(path, src)
+        else:
+            filename.touch()
+        return filename
+
+    def relpath(self, path: PathOrStr) -> pathlib.Path:
+        return pathlib.Path(path).relative_to(self.root)
+
+    def add_from_testdata(self, path: PathOrStr, src: PathOrStr):
+        testdata_path = get_testdata_path()
+        testdata_file = testdata_path / src
+        if testdata_file.is_file():
+            shutil.copy(testdata_file, self.path(path))
+        elif testdata_file.is_dir():
+            shutil.copytree(testdata_file, self.path(path))
+        else:
+            raise ValueError(f'{testdata_file} is not a file or directory')
+
+    def add_from_resources(self, path: PathOrStr, src: PathOrStr):
+        resources_file = get_resources_file(pathlib.Path(src))
+        shutil.copy(resources_file, self.path(path))
+
+    def exists_file(self, path: PathOrStr) -> bool:
+        return self.path(path).exists()
+
+    def delete_file(self, path: PathOrStr):
+        self.path(path).unlink()
+
+    def copy_from(self, other: 'TestingShared'):
+        shutil.copytree(other.root, self.root, dirs_exist_ok=True, symlinks=True)

rbx/box/ui/screens/run_explorer.py

@@ -6,8 +6,6 @@ from textual.reactive import reactive
 from textual.screen import Screen
 from textual.widgets import Footer, Header, Label, ListItem, ListView
 
-from rbx.box import package
-from rbx.box.schema import TaskType
 from rbx.box.solutions import SolutionReportSkeleton
 from rbx.box.ui.screens.error import ErrorScreen
 from rbx.box.ui.screens.run_test_explorer import RunTestExplorerScreen
@@ -42,12 +40,6 @@ class RunExplorerScreen(Screen):
             tips.markup = True
             tips.display = False
             tips.border_title = 'Tips'
-            pkg = package.find_problem_package_or_die()
-            if pkg.type == TaskType.COMMUNICATION:
-                tips.display = True
-                tips.write(
-                    'This is an interactive problem.\nYou can use the [bold blue]rbx --capture run[/bold blue] command to capture the interaction between the processes and see them here.'
-                )
             yield tips
 
     def on_mount(self):

rbx/box/ui/utils/run_ui.py

@@ -92,7 +92,7 @@ def get_run_testcase_metadata_markup(
     )
     lines.append(f'[b]Time:[/b] {time_str} / [b]Memory:[/b] {memory_str}')
     if checker_msg is not None:
-        lines.append(f'[b]Checker:[/b] {checker_msg}')
+        lines.append(f'[b]Checker:[/b] {utils.escape_markup(checker_msg)}')
     return '\n'.join(lines)
 
 
@@ -102,7 +102,11 @@ def get_metadata_markup(entry: GenerationTestcaseEntry) -> str:
     if entry.metadata.copied_from is not None:
         lines.append(f'[b]Copied from:[/b] {entry.metadata.copied_from.inputPath}')
     if entry.metadata.generator_call is not None:
-        lines.append(f'[b]Gen. call:[/b] {entry.metadata.generator_call}')
+        lines.append(
+            f'[b]Gen. call:[/b] {utils.escape_markup(str(entry.metadata.generator_call))}'
+        )
     if entry.metadata.generator_script is not None:
-        lines.append(f'[b]Gen. script:[/b] {entry.metadata.generator_script}')
+        lines.append(
+            f'[b]Gen. script:[/b] {utils.escape_markup(str(entry.metadata.generator_script))}'
+        )
     return '\n'.join(lines)

rbx/box/ui/widgets/test_output_box.py

@@ -44,7 +44,7 @@ class TestBoxWidget(Widget, can_focus=False):
         output: FileLog
         stderr: FileLog
         log: FileLog
-        interaction: FileLog
+        interaction: InteractionBox
 
     def logs(self) -> Logs:
         return self.Logs(

rbx/box/validators.py

@@ -8,7 +8,8 @@ from pydantic import BaseModel
 from rbx import console
 from rbx.box import package
 from rbx.box.code import SanitizationLevel, compile_item, run_item
-from rbx.box.schema import CodeItem, Primitive
+from rbx.box.fields import Primitive
+from rbx.box.schema import CodeItem
 from rbx.box.testcase_extractors import (
     GenerationTestcaseEntry,
     extract_generation_testcases_from_groups,
@@ -118,6 +119,7 @@ async def _validate_testcase(
         extra_args=shlex.join(var_args) if var_args else None,
     )
 
+    message = package.get_digest_as_string(message_digest.value or '')
     if (
         run_log is not None
         and run_log.exitcode != 0
@@ -127,12 +129,13 @@ async def _validate_testcase(
             f'[error]Validator [item]{validator.path}[/item] failed unexpectedly.[/error]'
         )
         console.console.print(f'[error]Summary:[/error] {run_log.get_summary()}')
+        console.console.print(f'[error]Message:[/error] {message}')
+        console.console.print(f'[error]Testcase:[/error] {testcase}')
         raise typer.Exit(1)
 
     log_overview = ''
     if log_digest.value is not None:
         log_overview = package.get_digest_as_string(log_digest.value or '')
-    message = package.get_digest_as_string(message_digest.value or '')
     return (
         run_log is not None and run_log.exitcode == 0,
         message,

rbx/grading/caching.py

@@ -8,6 +8,7 @@ import tempfile
 from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel
+from sqlitedict import SqliteDict
 
 from rbx import console
 from rbx.grading import grading_context
@@ -87,15 +88,26 @@ def _check_digests(artifacts_list: List[GradingArtifacts]):
             produced.add(id(output.digest))
 
 
-def _build_digest_list(artifacts_list: List[GradingArtifacts]) -> List[DigestHolder]:
-    digests = []
+def _build_artifact_with_digest_list(
+    artifacts_list: List[GradingArtifacts],
+) -> List[GradingFileOutput]:
+    outputs = []
     for artifacts in artifacts_list:
         for output in artifacts.outputs:
             if output.hash and output.digest is None:
                 output.digest = DigestHolder()
             if output.digest is None:
                 continue
-            digests.append(output.digest)
+            outputs.append(output)
+    return outputs
+
+
+def _build_digest_list(artifacts_list: List[GradingArtifacts]) -> List[DigestHolder]:
+    outputs = _build_artifact_with_digest_list(artifacts_list)
+    digests = []
+    for output in outputs:
+        assert output.digest is not None
+        digests.append(output.digest)
     return digests
 
 
@@ -114,27 +126,44 @@ def _build_fingerprint_list(
     return fingerprints
 
 
-def _maybe_check_integrity(output: GradingFileOutput):
+def _maybe_check_integrity(output: GradingFileOutput, integrity_digest: str):
     if not grading_context.should_check_integrity():
         return
-    if output.dest is None or not output.dest.is_symlink():
+    if not output.hash:
+        return
+    if output.dest is None or not output.dest.is_symlink() or not output.dest.is_file():
+        # Only makes sense if the file EXISTS and IS A SYMLINK pointing to an
+        # EXISTING storage file.
+        # If the storage file ceases to exist, we can simply evict from the cache.
         return
-    if output.digest is None or output.digest.value is None:
+    if output.digest is None:
         return
     with output.dest.open('rb') as f:
-        fingerprint = digest_cooperatively(f)
-    if fingerprint != output.digest.value:
+        output_digest = digest_cooperatively(f)
+    if output_digest != integrity_digest:
         raise ValueError(
             f'Cache was tampered with, file {output.dest} has changed since it was cached.\nPlease run `rbx clean` to reset the cache.'
         )
 
 
-def _build_output_fingerprint_list(artifacts_list: List[GradingArtifacts]) -> List[str]:
+def _check_digest_list_integrity(
+    artifacts_list: List[GradingArtifacts], integrity_digests: List[Optional[str]]
+):
+    outputs = _build_artifact_with_digest_list(artifacts_list)
+    assert len(outputs) == len(integrity_digests)
+    for output, integrity_digest in zip(outputs, integrity_digests):
+        assert output.digest is not None
+        if integrity_digest is None:
+            continue
+        _maybe_check_integrity(output, integrity_digest)
+
+
+def _build_output_fingerprint_list(
+    artifacts_list: List[GradingArtifacts],
+) -> List[str]:
     fingerprints = []
     for artifacts in artifacts_list:
         for output in artifacts.outputs:
-            if output.hash:
-                _maybe_check_integrity(output)
             if output.dest is None or output.intermediate or output.hash:
                 continue
             if not output.dest.is_file():
@@ -159,7 +188,10 @@ def _build_cache_fingerprint(
 ) -> CacheFingerprint:
     digests = [digest.value for digest in _build_digest_list(artifacts_list)]
     fingerprints = _build_fingerprint_list(artifacts_list, cacher)
-    output_fingerprints = _build_output_fingerprint_list(artifacts_list)
+    output_fingerprints = _build_output_fingerprint_list(
+        artifacts_list,
+    )
+
     logs = _build_logs_list(artifacts_list)
     return CacheFingerprint(
         digests=digests,
@@ -334,9 +366,9 @@ class DependencyCache:
     def __init__(self, root: pathlib.Path, cacher: FileCacher):
         self.root = root
         self.cacher = cacher
-        self.db = shelve.open(self._cache_name())
+        self.db = SqliteDict(self._cache_name(), autocommit=True)
         tmp_dir = pathlib.Path(tempfile.mkdtemp())
-        self.transient_db = shelve.open(str(tmp_dir / '.cache_db'))
+        self.transient_db = SqliteDict(str(tmp_dir / '.cache_db'), autocommit=True)
         atexit.register(lambda: self.db.close())
         atexit.register(lambda: self.transient_db.close())
         atexit.register(lambda: shutil.rmtree(tmp_dir))
@@ -388,7 +420,10 @@ class DependencyCache:
         if fingerprint is None:
             return False
 
-        reference_fingerprint = _build_cache_fingerprint(artifact_list, self.cacher)
+        reference_fingerprint = _build_cache_fingerprint(
+            artifact_list,
+            self.cacher,
+        )
 
         if not _fingerprints_match(fingerprint, reference_fingerprint):
             self._evict_from_cache(key)
@@ -398,6 +433,11 @@ class DependencyCache:
             self._evict_from_cache(key)
             return False
 
+        # Check whether existing storage files were not tampered with.
+        _check_digest_list_integrity(
+            artifact_list,
+            fingerprint.digests,
+        )
         reference_digests = _build_digest_list(artifact_list)
 
         # Apply digest changes.
@@ -421,6 +461,10 @@ class DependencyCache:
         for logs, reference_logs in zip(fingerprint.logs, reference_fingerprint.logs):
             if logs.run is not None:
                 reference_logs.run = logs.run.model_copy(deep=True)
+            if logs.interactor_run is not None:
+                reference_logs.interactor_run = logs.interactor_run.model_copy(
+                    deep=True
+                )
             if logs.preprocess is not None:
                 reference_logs.preprocess = [
                     log.model_copy(deep=True) for log in logs.preprocess
@@ -447,4 +491,11 @@ class DependencyCache:
         if not are_artifacts_ok(artifact_list, self.cacher):
             return
 
-        self._store_in_cache(key, _build_cache_fingerprint(artifact_list, self.cacher))
+        reference_fingerprint = _build_cache_fingerprint(
+            artifact_list,
+            self.cacher,
+        )
+        self._store_in_cache(
+            key,
+            reference_fingerprint,
+        )

rbx/grading/judge/program.py

@@ -0,0 +1,268 @@
+import dataclasses
+import os
+import pathlib
+import resource
+import subprocess
+import sys
+import threading
+import typing
+from enum import Enum
+from time import monotonic
+from typing import IO, Any, Dict, List, Optional, Union
+
+import psutil
+
+from rbx.utils import PathOrStr
+
+FileLike = Union[PathOrStr, IO[bytes], int]
+
+
+def _maybe_close_files(files):
+    for fobj in files:
+        if isinstance(fobj, int):
+            continue
+        fobj.close()
+
+
+def _is_pathlike(obj: Any) -> bool:
+    return isinstance(obj, str) or isinstance(obj, pathlib.Path)
+
+
+@dataclasses.dataclass
+class ProgramIO:
+    input: FileLike = subprocess.PIPE
+    output: FileLike = subprocess.PIPE
+    stderr: FileLike = subprocess.PIPE
+
+    def get_file_objects(self):
+        if isinstance(self.input, int):
+            input_fobj = self.input
+        elif _is_pathlike(self.input):
+            input_fobj = pathlib.Path(typing.cast(str, self.input)).open('r')
+        else:
+            input_fobj = typing.cast(IO[bytes], self.input)
+        if isinstance(self.output, int):
+            output_fobj = self.output
+        elif _is_pathlike(self.output):
+            output_path = pathlib.Path(typing.cast(str, self.output))
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_fobj = output_path.open('w')
+        else:
+            output_fobj = typing.cast(IO[bytes], self.output)
+        if isinstance(self.stderr, int):
+            stderr_fobj = self.stderr
+        elif _is_pathlike(self.stderr):
+            stderr_path = pathlib.Path(typing.cast(str, self.stderr))
+            stderr_path.parent.mkdir(parents=True, exist_ok=True)
+            stderr_fobj = stderr_path.open('w')
+        else:
+            stderr_fobj = typing.cast(IO[bytes], self.stderr)
+        return input_fobj, output_fobj, stderr_fobj
+
+
+@dataclasses.dataclass
+class ProgramPipes:
+    input: Optional[IO[bytes]] = None
+    output: Optional[IO[bytes]] = None
+    stderr: Optional[IO[bytes]] = None
+
+
+@dataclasses.dataclass
+class ProgramParams:
+    io: ProgramIO = dataclasses.field(default_factory=ProgramIO)
+    chdir: Optional[pathlib.Path] = None
+    time_limit: Optional[float] = None  # seconds
+    wall_time_limit: Optional[float] = None  # seconds
+    memory_limit: Optional[int] = None  # megabytes
+    fs_limit: Optional[int] = None  # kilobytes
+    env: Dict[str, str] = dataclasses.field(default_factory=dict)
+    pgid: Optional[int] = None
+
+
+def get_preexec_fn(params: ProgramParams):
+    def preexec_fn():
+        os.setpgid(0, params.pgid or 0)
+        if params.time_limit is not None:
+            time_limit_in_ms = int(params.time_limit * 1000)
+            rlimit_cpu = int((time_limit_in_ms + 999) // 1000)
+            resource.setrlimit(resource.RLIMIT_CPU, (rlimit_cpu, rlimit_cpu + 1))
+        if params.fs_limit is not None:
+            fs_limit = params.fs_limit * 1024  # in bytes
+            resource.setrlimit(resource.RLIMIT_FSIZE, (fs_limit + 1, fs_limit * 2))
+
+    return preexec_fn
+
+
+def get_memory_usage(ru: resource.struct_rusage) -> int:
+    if sys.platform == 'darwin':
+        return ru.ru_maxrss // 1024 + ru.ru_ixrss
+    return ru.ru_maxrss + ru.ru_ixrss + ru.ru_idrss + ru.ru_isrss
+
+
+def get_cpu_time(ru: resource.struct_rusage) -> float:
+    return ru.ru_utime + ru.ru_stime
+
+
+def get_file_sizes(io: ProgramIO):
+    return _get_file_size(io.output) + _get_file_size(io.stderr)
+
+
+def _get_file_size(filename: Optional[FileLike]) -> int:
+    if filename is None or not _is_pathlike(filename):
+        return 0
+    path = pathlib.Path(typing.cast(str, filename))
+    if not path.is_file():
+        return 0
+    return path.stat().st_size
+
+
+class ProgramCode(Enum):
+    RE = 'RE'
+    SG = 'SG'
+    TO = 'TO'
+    WT = 'WT'
+    ML = 'ML'
+    OL = 'OL'
+    TE = 'TE'
+
+
+@dataclasses.dataclass
+class ProgramResult:
+    exitcode: int
+    wall_time: float
+    cpu_time: float
+    memory_used: int
+    file_sizes: int
+    program_codes: List[ProgramCode]
+    killing_signal: Optional[int] = None
+    alarm_msg: Optional[str] = None
+
+
+class Program:
+    def __init__(self, command: List[str], params: ProgramParams):
+        self.command = command
+        self.params = params
+        self.popen: Optional[subprocess.Popen] = None
+        self._files = []
+
+        self._stop_wall_handler = threading.Event()
+        self._stop_alarm_handler = threading.Event()
+        self._alarm_msg = ''
+
+        self._run()
+
+    @property
+    def pipes(self) -> ProgramPipes:
+        assert self.popen is not None
+        return ProgramPipes(
+            input=self.popen.stdin,
+            output=self.popen.stdout,
+            stderr=self.popen.stderr,
+        )
+
+    @property
+    def pid(self) -> int:
+        assert self.popen is not None
+        return self.popen.pid
+
+    def _kill_process(self):
+        if self.popen is not None:
+            self.popen.kill()
+
+    def _handle_wall(self):
+        if self._stop_wall_handler.wait(self.params.wall_time_limit):
+            return
+        self._stop_alarm_handler.set()
+        self._alarm_msg = 'wall timelimit'
+        self._kill_process()
+
+    def _handle_alarm(self):
+        if self._stop_alarm_handler.wait(0.3):
+            return
+        try:
+            process = psutil.Process(self.pid)
+            if self.params.time_limit is not None:
+                times = process.cpu_times()
+                cpu_time = times.user + times.system
+                if cpu_time > self.params.time_limit:
+                    self._alarm_msg = 'timelimit'
+                    self._kill_process()
+            if self.params.memory_limit is not None:
+                memory_info = process.memory_info()
+                memory_used = memory_info.rss
+                if memory_used > self.params.memory_limit * 1024 * 1024:
+                    self._alarm_msg = 'memorylimit'
+                    self._kill_process()
+            self._stop_alarm_handler.clear()
+            self._handle_alarm()
+        except psutil.NoSuchProcess:
+            return
+
+    def _run(self):
+        self._files = self.params.io.get_file_objects()
+        self.popen = subprocess.Popen(
+            self.command,
+            stdin=self._files[0],
+            stdout=self._files[1],
+            stderr=self._files[2],
+            cwd=self.params.chdir,
+            env={**os.environ, **self.params.env},
+            preexec_fn=get_preexec_fn(self.params),
+            close_fds=True,
+        )
+        self.start_time = monotonic()
+
+        threading.Thread(target=self._handle_wall, daemon=True).start()
+        threading.Thread(target=self._handle_alarm, daemon=True).start()
+
+    def process_exit(self, exitstatus, ru) -> ProgramResult:
+        wall_time = monotonic() - self.start_time
+        cpu_time = get_cpu_time(ru)
+        memory_used = get_memory_usage(ru)
+        file_sizes = get_file_sizes(self.params.io)
+        exitcode = os.waitstatus_to_exitcode(exitstatus)
+        killing_signal = None
+        program_codes = []
+
+        if exitcode < 0:
+            killing_signal = -exitcode
+            program_codes.append(ProgramCode.SG)
+        if exitcode > 0:
+            program_codes.append(ProgramCode.RE)
+        if self.params.time_limit is not None and (
+            cpu_time > self.params.time_limit or -exitcode == 24
+        ):
+            program_codes.append(ProgramCode.TO)
+        if (
+            self.params.wall_time_limit is not None
+            and wall_time > self.params.wall_time_limit
+        ):
+            program_codes.append(ProgramCode.WT)
+            program_codes.append(ProgramCode.TO)
+        if (
+            self.params.memory_limit is not None
+            and memory_used > self.params.memory_limit * 1024 * 1024
+            or self._alarm_msg == 'memorylimit'
+        ):
+            program_codes.append(ProgramCode.ML)
+        if (
+            self.params.fs_limit is not None
+            and file_sizes > self.params.fs_limit * 1024
+        ):
+            program_codes.append(ProgramCode.OL)
+
+        return ProgramResult(
+            exitcode=exitcode,
+            wall_time=wall_time,
+            cpu_time=cpu_time,
+            memory_used=memory_used,
+            file_sizes=file_sizes,
+            program_codes=program_codes,
+            killing_signal=killing_signal,
+            alarm_msg=self._alarm_msg or None,
+        )
+
+    def wait(self):
+        assert self.popen is not None
+        _, exitstatus, ru = os.wait4(self.pid, 0)
+        return self.process_exit(exitstatus, ru)