rbx.cp 0.13.4__py3-none-any.whl → 0.13.6__py3-none-any.whl

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/unit.py

@@ -41,7 +41,7 @@ class CheckerTestEntry(BaseModel):
         return ', '.join(res)
 
 
-def _extract_validator_test_entries(
+def extract_validator_test_entries(
     tests: List[ValidatorTest],
 ) -> List[ValidatorTestEntry]:
     res: List[ValidatorTestEntry] = []
@@ -57,7 +57,7 @@ def _extract_validator_test_entries(
     return sorted(res, key=lambda x: x.input.name)
 
 
-def _extract_checker_test_entries(tests: List[CheckerTest]) -> List[CheckerTestEntry]:
+def extract_checker_test_entries(tests: List[CheckerTest]) -> List[CheckerTestEntry]:
     res: List[CheckerTestEntry] = []
     seen: Set[pathlib.Path] = set()
     for test in tests:
@@ -94,7 +94,7 @@ def _get_validator_for_test(test: ValidatorTestEntry) -> Optional[CodeItem]:
 async def run_validator_unit_tests(progress: StatusProgress):
     pkg = package.find_problem_package_or_die()
 
-    entries = _extract_validator_test_entries(pkg.unitTests.validator)
+    entries = extract_validator_test_entries(pkg.unitTests.validator)
 
     vals: List[CodeItem] = []
     for test in entries:
@@ -158,7 +158,7 @@ async def run_checker_unit_tests(progress: StatusProgress):
 
     console.console.rule('Checker tests', style='info')
 
-    entries = _extract_checker_test_entries(pkg.unitTests.checker)
+    entries = extract_checker_test_entries(pkg.unitTests.checker)
     if not entries:
         console.console.print('No checker unit tests found.')
         return

rbx/box/validators.py

@@ -119,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
@@ -128,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

@@ -88,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
 
 
@@ -115,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():
@@ -160,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,
@@ -340,7 +371,7 @@ class DependencyCache:
         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))
+        atexit.register(lambda: shutil.rmtree(tmp_dir, ignore_errors=True))
 
     def _cache_name(self) -> str:
         return str(self.root / '.cache_db')
@@ -389,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)
@@ -399,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.
@@ -422,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
@@ -448,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/cacher.py

@@ -73,7 +73,9 @@ class FileCacher:
             self.file_dir = pathlib.Path(tempfile.mkdtemp())
             # Delete this directory on exit since it has a random name and
             # won't be used again.
-            atexit.register(lambda: shutil.rmtree(str(self.file_dir)))
+            atexit.register(
+                lambda: shutil.rmtree(str(self.file_dir), ignore_errors=True)
+            )
         else:
             assert folder is not None
             self.file_dir = folder / 'fs-cache-shared'
@@ -84,7 +86,7 @@ class FileCacher:
         self.temp_dir = pathlib.Path(
             tempfile.mkdtemp(dir=self.file_dir, prefix='_temp')
         )
-        atexit.register(lambda: shutil.rmtree(str(self.temp_dir)))
+        atexit.register(lambda: shutil.rmtree(str(self.temp_dir), ignore_errors=True))
         # Just to make sure it was created.
 
     def is_shared(self) -> bool:
@@ -526,7 +528,7 @@ class FileCacher:
         """
         if self.is_shared():
             raise Exception('You may not destroy a shared cache.')
-        shutil.rmtree(str(self.file_dir))
+        shutil.rmtree(str(self.file_dir), ignore_errors=True)
 
     def list(self) -> List[storage.FileWithMetadata]:
         """List the files available in the storage.

rbx/grading/judge/program.py

@@ -0,0 +1,300 @@
+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:
+    """Get memory usage in bytes from resource usage statistics.
+
+    Returns the total memory usage (RSS + shared memory segments) in bytes.
+
+    Platform differences in ru.ru_maxrss:
+    - macOS/Darwin: ru.ru_maxrss is in bytes
+    - Linux: ru.ru_maxrss is in kilobytes
+
+    This function normalizes the result to always return bytes.
+
+    Args:
+        ru: Resource usage statistics from os.wait4() or similar
+
+    Returns:
+        int: Total memory usage in bytes
+    """
+    if sys.platform == 'darwin':
+        # On macOS, ru.ru_maxrss is already in bytes
+        return ru.ru_maxrss + ru.ru_ixrss * 1024
+    # On Linux, ru.ru_maxrss is in kilobytes, so convert to bytes
+    return (ru.ru_maxrss + ru.ru_ixrss + ru.ru_idrss + ru.ru_isrss) * 1024
+
+
+def get_cpu_time(ru: resource.struct_rusage) -> float:
+    """Get CPU time in seconds from resource usage statistics.
+
+    Returns the total CPU time (user + system) in seconds.
+
+    Args:
+        ru: Resource usage statistics from os.wait4() or similar
+
+    Returns:
+        float: Total CPU time in seconds
+    """
+    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)
+        # Memory limit checking: Two ways a process can exceed memory limits:
+        # 1. Runtime monitoring (_handle_alarm) kills the process during execution
+        # 2. Post-execution check using ru.ru_maxrss detects peak memory usage exceeded limit
+        # Both memory_used (from ru.ru_maxrss) and memory_limit (converted to bytes) are in bytes
+        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)