rbx.cp 0.5.53__py3-none-any.whl → 0.5.55__py3-none-any.whl

rbx/box/ui/main.py

@@ -5,10 +5,14 @@ from textual.containers import Center
 from textual.screen import Screen
 from textual.widgets import Footer, Header, OptionList
 
-from rbx.box.ui.run import RunScreen
+from rbx.box.ui.screens.build import BuildScreen
+from rbx.box.ui.screens.run import RunScreen
+from rbx.box.ui.screens.test_explorer import TestExplorerScreen
 
 SCREEN_OPTIONS = [
     ('Run solutions against define testsets.', RunScreen),
+    ('Build tests.', BuildScreen),
+    ('Explore tests.', TestExplorerScreen),
 ]
 
 

rbx/box/ui/screens/build.py

@@ -0,0 +1,6 @@
+from rbx.box.ui.screens.command import CommandScreen
+
+
+class BuildScreen(CommandScreen):
+    def __init__(self):
+        super().__init__(['rbx', 'build'])

rbx/box/ui/screens/command.py

@@ -0,0 +1,35 @@
+import asyncio
+from typing import List
+
+from textual.app import ComposeResult
+from textual.screen import Screen
+from textual.widgets import Footer, Header
+
+from rbx.box.ui.captured_log import LogDisplay
+
+
+class CommandScreen(Screen):
+    BINDINGS = [('q', 'app.pop_screen', 'Back')]
+
+    def __init__(self, command: List[str]):
+        super().__init__()
+        self.command = command
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Footer()
+        yield LogDisplay()
+
+    async def _run_command(self):
+        exitcode = await self.query_one(LogDisplay).capture(self.command)
+        if exitcode != 0:
+            self.query_one(LogDisplay).border_subtitle = f'Exit code: {exitcode}'
+            return
+
+        self.query_one(LogDisplay).border_subtitle = 'Finished'
+
+    async def on_mount(self):
+        self.query_one(LogDisplay).border_title = 'Command output'
+
+        # Fire and forget.
+        asyncio.create_task(self._run_command())

rbx/box/ui/{run.py → screens/run.py}

@@ -18,9 +18,10 @@ from rbx.box.solutions import (
     SolutionReportSkeleton,
     get_evals_formatted_time,
     get_testcase_markup_verdict,
-    run_solutions,
 )
 from rbx.box.ui.captured_log import LogDisplay, LogDisplayState
+from rbx.box.ui.screens.command import CommandScreen
+from rbx.grading.steps import Evaluation
 
 
 def _build_solution_selection_label(sol: Solution) -> Text:
@@ -36,7 +37,7 @@ def _build_solution_selection_label(sol: Solution) -> Text:
 class SolutionReportScreen(Screen):
     skeleton: SolutionReportSkeleton
 
-    BINDINGS = [('q', 'app.pop_screen', 'Quit')]
+    BINDINGS = [('q', 'app.pop_screen', 'Back')]
 
     def __init__(
         self,
@@ -86,7 +87,7 @@ class SolutionReportScreen(Screen):
                 return i
         raise
 
-    async def process(self, item: EvaluationItem):
+    async def process(self, item: EvaluationItem, eval: Evaluation):
         pkg = package.find_problem_package_or_die()
         sol_idx_in_skeleton = self._find_solution_index_in_skeleton(
             pkg.solutions[item.solution_index]
@@ -101,17 +102,19 @@ class SolutionReportScreen(Screen):
 
         table.update_cell_at(
             Coordinate(row=row_idx, column=2),
-            get_testcase_markup_verdict(await item.eval()),
+            get_testcase_markup_verdict(eval),
             update_width=True,
         )
         table.update_cell_at(
             Coordinate(row=row_idx, column=3),
-            get_evals_formatted_time([await item.eval()]),
+            get_evals_formatted_time([eval]),
             update_width=True,
         )
 
 
 class RunScreen(Screen):
+    BINDINGS = [('q', 'app.pop_screen', 'Back')]
+
     def compose(self) -> ComposeResult:
         yield Header()
         yield Footer()
@@ -141,7 +144,6 @@ class RunScreen(Screen):
                 id='run-config',
             )
             yield Button('Run')
-            yield LogDisplay()
 
     def on_mount(self):
         sols = self.query_one('#run-sols', SelectionList)
@@ -160,7 +162,6 @@ class RunScreen(Screen):
     async def on_button_pressed(self, _: Button.Pressed):
         await self.action_run()
 
-    @textual.work(thread=True)
     async def _run_solutions(self, tracked_solutions: Set[str], check: bool):
         main_solution = package.get_main_solution()
         if check and main_solution is None:
@@ -169,36 +170,7 @@ class RunScreen(Screen):
             )
             check = False
 
-        async def build():
-            return await self.query_one(LogDisplay).capture(['rbx', 'build'])
-
-        exitcode = self.app.call_from_thread(build)
-
-        if exitcode != 0:
-            textual.log(f'early quit: {exitcode}')
-            return
-
-        textual.log('build finished ok, running solutions')
-
-        res = run_solutions(tracked_solutions=tracked_solutions, check=check)
-
-        async def mount_report_widget() -> SolutionReportScreen:
-            # log_display_state = self.query_one(LogDisplay).export()
-            log_display_state = None
-            await self.app.push_screen(
-                screen := SolutionReportScreen(
-                    res.skeleton, log_display_state=log_display_state
-                )
-            )
-            return screen
-
-        new_screen = await mount_report_widget()
-
-        async def process_item(item: EvaluationItem):
-            await new_screen.process(item)
-
-        for item in res.items:
-            self.app.call_from_thread(process_item, item)
+        self.app.switch_screen(CommandScreen(['rbx', 'run']))
 
     async def action_run(self):
         sols = self.query_one('#run-sols', SelectionList)
@@ -207,4 +179,4 @@ class RunScreen(Screen):
         tracked_solutions = set(str(sol) for sol in sols.selected)
         check = 'check' in config.selected
 
-        self._run_solutions(tracked_solutions, check)
+        await self._run_solutions(tracked_solutions, check)

rbx/box/ui/screens/run_explorer.py

@@ -0,0 +1,5 @@
+from textual.screen import Screen
+
+
+class RunExplorerScreen(Screen):
+    pass

rbx/box/ui/screens/test_explorer.py

@@ -0,0 +1,100 @@
+from typing import List, Optional
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import Screen
+from textual.widgets import Footer, Header, Label, ListItem, ListView, RichLog
+
+from rbx.box.testcase_extractors import (
+    GenerationTestcaseEntry,
+    extract_generation_testcases_from_groups,
+)
+from rbx.box.ui.widgets.file_log import FileLog
+from rbx.box.ui.widgets.rich_log_box import RichLogBox
+
+
+class TestExplorerScreen(Screen):
+    BINDINGS = [
+        ('q', 'app.pop_screen', 'Quit'),
+        ('m', 'toggle_metadata', 'Toggle metadata'),
+    ]
+
+    def __init__(self):
+        super().__init__()
+        self._entries: List[GenerationTestcaseEntry] = []
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Footer()
+        with Horizontal(id='test-explorer'):
+            with Vertical(id='test-list-container'):
+                yield ListView(id='test-list')
+            with Vertical(id='test-details'):
+                yield FileLog(id='test-input')
+                yield FileLog(id='test-output')
+                yield RichLogBox(id='test-metadata')
+
+    async def on_mount(self):
+        self.query_one('#test-list').border_title = 'Tests'
+        self.query_one('#test-input').border_title = 'Input'
+        self.query_one('#test-output').border_title = 'Output'
+
+        metadata = self.query_one('#test-metadata', RichLogBox)
+        metadata.display = False
+        metadata.border_title = 'Metadata'
+        metadata.wrap = True
+        metadata.markup = True
+        metadata.clear().write('No test selected')
+        await self._update_tests()
+
+    def action_toggle_metadata(self):
+        metadata = self.query_one('#test-metadata', RichLogBox)
+        metadata.display = not metadata.display
+
+    def _update_selected_test(self, index: Optional[int]):
+        input = self.query_one('#test-input', FileLog)
+        output = self.query_one('#test-output', FileLog)
+        metadata = self.query_one('#test-metadata', RichLog)
+
+        if index is None:
+            input.path = None
+            output.path = None
+            metadata.clear().write('No test selected')
+            return
+        entry = self._entries[index]
+        input.path = entry.metadata.copied_to.inputPath
+        output.path = entry.metadata.copied_to.outputPath
+
+        metadata.clear()
+        metadata.write(
+            f'[bold]{entry.group_entry.group}[/bold] / [bold]{entry.group_entry.index}[/bold]'
+        )
+        if entry.metadata.copied_from is not None:
+            metadata.write(
+                f'[bold]Copied from:[/bold] {entry.metadata.copied_from.inputPath}'
+            )
+        if entry.metadata.generator_call is not None:
+            metadata.write(f'[bold]Gen. call:[/bold] {entry.metadata.generator_call}')
+        if entry.metadata.generator_script is not None:
+            metadata.write(
+                f'[bold]Gen. script:[/bold] {entry.metadata.generator_script}'
+            )
+
+    async def _update_tests(self):
+        self.watch(
+            self.query_one('#test-list', ListView),
+            'index',
+            self._update_selected_test,
+        )
+
+        self._entries = await extract_generation_testcases_from_groups()
+
+        test_names = [
+            f'{entry.group_entry.group}/{entry.group_entry.index}'
+            for entry in self._entries
+        ]
+
+        await self.query_one('#test-list', ListView).clear()
+        await self.query_one('#test-list', ListView).extend(
+            [ListItem(Label(name)) for name in test_names]
+        )

rbx/box/ui/widgets/file_log.py

@@ -0,0 +1,63 @@
+import pathlib
+from typing import Optional
+
+import aiofiles
+from textual import work
+from textual.app import ComposeResult
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Log
+
+BATCH_SIZE = 1024
+
+
+class FileLog(Widget, can_focus=False):
+    DEFAULT_CSS = """
+    FileLog {
+        border: solid $accent;
+        height: 1fr;
+        width: 1fr;
+    }
+    """
+
+    path: reactive[Optional[pathlib.Path]] = reactive(None)
+
+    def compose(self) -> ComposeResult:
+        yield Log()
+
+    def on_mount(self):
+        self.query_one(Log).auto_scroll = False
+        self.query_one(Log).can_focus = False
+
+    @work(exclusive=True)
+    async def _load_file(self, path: pathlib.Path):
+        log = self.query_one(Log)
+        log.clear()
+        path_str = str(path.relative_to(pathlib.Path.cwd()))
+        self.border_subtitle = f'{path_str} (loading...)'
+
+        async with aiofiles.open(path, 'r') as f:
+            batch = []
+            async for line in f:
+                batch.append(line)
+                if len(batch) >= BATCH_SIZE:
+                    log.write(''.join(batch))
+                    batch = []
+
+            if batch:
+                log.write(''.join(batch))
+
+        self.border_subtitle = path_str
+
+    async def watch_path(self, path: Optional[pathlib.Path]):
+        log = self.query_one(Log)
+        log.clear()
+
+        if path is None:
+            return
+
+        if not path.is_file():
+            self.query_one(Log).write(f'File {path} does not exist')
+            return
+
+        self._load_file(path)

rbx/box/ui/widgets/rich_log_box.py

@@ -0,0 +1,5 @@
+from textual.widgets import RichLog
+
+
+class RichLogBox(RichLog, can_focus=False):
+    pass

rbx/grading/judge/sandboxes/stupid_sandbox.py

@@ -322,7 +322,11 @@ class StupidSandbox(SandboxBase):
         return self.translate_box_exitcode(self.returncode)
 
     def translate_box_exitcode(self, exitcode: int) -> bool:
-        # SIGALRM can be safely ignored, just in case it leaks away.
+        # SIGALRM can be safely ignored, just in case it leaks away. SIGTERM also.
+        if self.log is None:
+            return False
+        if 'TE' in self.get_status_list():
+            return True
         return super().translate_box_exitcode(exitcode) or -exitcode == signal.SIGALRM
 
     def debug_message(self) -> Any:

rbx/grading/judge/sandboxes/timeit.py

@@ -109,7 +109,8 @@ def create_tee(files, mode, buffer_size=4096, prefix=''):
     else:
         # Parent -- Return a file object wrapper around the pipe to the
         #           child.
-        return os.fdopen(pipe_write, 'w', closefd=False)
+        # Preserve line buffering (buffering=1).
+        return os.fdopen(pipe_write, 'w', buffering=1, closefd=False)
 
 
 def parse_opts() -> Options:

rbx/grading/processing_context.py

@@ -1,3 +1,4 @@
+import asyncio
 import contextlib
 import os
 import signal
@@ -5,22 +6,26 @@ import threading
 from typing import Optional, Set
 
 _processing_context_pids: Optional[Set[int]] = None
+_terminate_all_on_error = False
 _lock = threading.Lock()
 
 # Creating a processing context is not thread-safe, but adding to it is.
 
 
 @contextlib.contextmanager
-def new_processing_context():
-    global _processing_context_pids
+def new_processing_context(terminate_all_on_error: bool = False):
+    global _processing_context_pids, _terminate_all_on_error
     with _lock:
         old_processing_context_pids = _processing_context_pids
+        _old_terminate_all_on_error = _terminate_all_on_error
         _processing_context_pids = set()
+        _terminate_all_on_error = terminate_all_on_error
     try:
         yield
     finally:
         with _lock:
             _processing_context_pids = old_processing_context_pids
+            _terminate_all_on_error = _old_terminate_all_on_error
 
 
 def get_processing_context() -> Set[int]:
@@ -36,7 +41,8 @@ def add_to_processing_context(pid: int):
         _processing_context_pids.add(pid)
 
 
-def terminate_all_processes_in_context():
+def terminate_all_processes_in_context(clear: bool = True):
+    global _processing_context_pids
     with _lock:
         if _processing_context_pids is None:
             return
@@ -45,4 +51,37 @@ def terminate_all_processes_in_context():
                 os.kill(pid, signal.SIGTERM)
             except OSError:
                 pass
-        _processing_context_pids.clear()
+        if clear:
+            _processing_context_pids.clear()
+
+
+async def wait_all_processes_in_context(wait_for: int):
+    global _processing_context_pids, _terminate_all_on_error
+    wait_pids = set()
+    while len(get_processing_context()) < wait_for:
+        await asyncio.sleep(0.01)
+
+    with _lock:
+        if _processing_context_pids is None:
+            return
+        wait_pids.update(_processing_context_pids)
+
+    wait_lock = threading.Lock()
+    finished_pids = []
+
+    def process(pid: int, returncode: int):
+        with wait_lock:
+            finished_pids.append(pid)
+        if returncode != 0 and _terminate_all_on_error:
+            terminate_all_processes_in_context()
+
+    def wait_all_processes():
+        while len(finished_pids) < len(wait_pids):
+            try:
+                pid, status = os.wait()
+            except ChildProcessError:
+                return
+            if pid in wait_pids:
+                process(pid, os.waitstatus_to_exitcode(status))
+
+    await asyncio.to_thread(wait_all_processes)

rbx/grading/steps.py

@@ -193,6 +193,11 @@ class RunLogMetadata(BaseModel):
     retryIndex: Optional[int] = None
 
 
+class ProcessingContextLog(BaseModel):
+    pid: int = -1
+    exitindex: int = -1
+
+
 class RunLog(BaseModel):
     exitcode: int = 0
     exitstatus: str = SandboxBase.EXIT_SANDBOX_ERROR
@@ -330,14 +335,29 @@ def _expand_part(part: str, sandbox: SandboxBase) -> List[str]:
     return [part]
 
 
+def _get_java_memory_limits(sandbox: SandboxBase) -> Tuple[int, int]:
+    max_memory = sandbox.params.address_space
+    if max_memory is None:
+        max_memory = 2048
+    return max_memory, min(512, int(max_memory * 0.9))
+
+
 def _split_and_expand(command: str, sandbox: SandboxBase) -> List[str]:
     res = []
-    parts = shlex.split(command.format(memory=sandbox.params.address_space or 2048))
+    max_mem, init_mem = _get_java_memory_limits(sandbox)
+    parts = shlex.split(command.format(memory=max_mem, initialMemory=init_mem))
     for part in parts:
         res.extend(_expand_part(part, sandbox))
     return res
 
 
+def get_exe_from_command(command: str) -> str:
+    cmds = shlex.split(command)
+    if not cmds:
+        return command
+    return cmds[0]
+
+
 def _is_c_command(exe_command: str) -> bool:
     return 'gcc' in exe_command or 'clang' in exe_command
 
@@ -351,15 +371,26 @@ def is_cxx_command(exe_command: str) -> bool:
 
 
 def is_cxx_sanitizer_command(command: str) -> bool:
-    cmds = shlex.split(command)
-    if not cmds:
+    exe = get_exe_from_command(command)
+    if not exe:
         return False
-    exe = cmds[0]
     if not is_cxx_command(exe):
         return False
     return 'fsanitize' in command
 
 
+def is_java_command(exe_command: str) -> bool:
+    return 'javac' in exe_command or 'java' in exe_command
+
+
+def is_kotlin_command(exe_command: str) -> bool:
+    return 'kotlinc' in exe_command or 'kotlin' in exe_command
+
+
+def is_java_like_command(exe_command: str) -> bool:
+    return is_java_command(exe_command) or is_kotlin_command(exe_command)
+
+
 @functools.cache
 def _complain_about_clang() -> None:
     console.print(
@@ -539,6 +570,10 @@ def compile(
         stderr_file = pathlib.PosixPath(f'compile-{i}.stderr')
         sandbox.params.set_stdall(stdout=stdout_file, stderr=stderr_file)
 
+        # Remove memory constraints for Java.
+        if is_java_like_command(get_exe_from_command(command)):
+            sandbox.params.address_space = None
+
         if bits_artifact is not None and _is_cpp_command(cmd[0]):
             # Include from sandbox directory to import bits/stdc++.h.
             cmd.append('-I.')
@@ -604,6 +639,10 @@ async def run(
     cmd = _split_and_expand(command, sandbox)
     sandbox.set_params(params)
 
+    # Remove memory constraints for Java.
+    if is_java_like_command(get_exe_from_command(command)):
+        sandbox.params.address_space = None
+
     if not await asyncio.to_thread(sandbox.execute_without_std, cmd):
         console.print(
             '[error]Sandbox crashed while processing command:[/error]',
@@ -614,7 +653,7 @@ async def run(
         return None
 
     if sandbox.get_exit_code() != 0 and kill_on_processing_context_exit:
-        processing_context.terminate_all_processes_in_context()
+        processing_context.terminate_all_processes_in_context(clear=False)
 
     if not _process_output_artifacts(artifacts, sandbox):
         return None
@@ -657,22 +696,27 @@ async def run_coordinated(
     interactor: CoordinatedRunParams,
     solution: CoordinatedRunParams,
 ) -> Tuple[Optional[RunLog], Optional[RunLog]]:
-    with processing_context.new_processing_context():
+    with processing_context.new_processing_context(terminate_all_on_error=True):
+        # Schedule both runs to execute immediately.
         runs = tuple(
-            run(
-                params.command,
-                params.params,
-                params.sandbox,
-                params.artifacts,
-                params.metadata,
-                kill_on_processing_context_exit=True,
+            asyncio.create_task(
+                run(
+                    params.command,
+                    params.params,
+                    params.sandbox,
+                    params.artifacts,
+                    params.metadata,
+                    kill_on_processing_context_exit=True,
+                )
             )
             for params in [interactor, solution]
         )
-        return typing.cast(
+        await processing_context.wait_all_processes_in_context(wait_for=2)
+        logs = typing.cast(
             Tuple[Optional[RunLog], Optional[RunLog]],
             tuple(await asyncio.gather(*runs)),
         )
+        return logs
 
 
 def _normalize_checked_words(s: str) -> Tuple[str, ...]:

rbx/resources/packagers/boca/interactive/c

@@ -146,8 +146,15 @@ echo "solution \$SFPID -> \$ECSF" >&2
 echo "interactor exitcode \$ECINT" >&2
 echo "solution exitcode \$ECSF" >&2
 
+RTE=0
+if [[ \$ECSF -eq -13 ]]; then
+  RTE=0
+elif [[ \$ECSF -ne 0 ]] && cat stderr0 | grep -q "wrong output format Unexpected end of file"; then
+  RTE=1
+fi
+
 ret=0
-if [[ \$ECINT -ge 1 ]] && [[ \$ECINT -le 4 ]]; then
+if [[ \$ECINT -ge 1 ]] && [[ \$ECINT -le 4 ]] && [[ \$RTE -eq 0 ]]; then
   echo "testlib exitcode \$ECINT" >stdout0
   ret=0
 elif [[ \$ECSF -ne 0 ]]; then

rbx/resources/packagers/boca/interactive/cc

@@ -146,8 +146,15 @@ echo "solution \$SFPID -> \$ECSF" >&2
 echo "interactor exitcode \$ECINT" >&2
 echo "solution exitcode \$ECSF" >&2
 
+RTE=0
+if [[ \$ECSF -eq -13 ]]; then
+  RTE=0
+elif [[ \$ECSF -ne 0 ]] && cat stderr0 | grep -q "wrong output format Unexpected end of file"; then
+  RTE=1
+fi
+
 ret=0
-if [[ \$ECINT -ge 1 ]] && [[ \$ECINT -le 4 ]]; then
+if [[ \$ECINT -ge 1 ]] && [[ \$ECINT -le 4 ]] && [[ \$RTE -eq 0 ]]; then
   echo "testlib exitcode \$ECINT" >stdout0
   ret=0
 elif [[ \$ECSF -ne 0 ]]; then

rbx/resources/packagers/boca/interactive/cpp

@@ -146,8 +146,15 @@ echo "solution \$SFPID -> \$ECSF" >&2
 echo "interactor exitcode \$ECINT" >&2
 echo "solution exitcode \$ECSF" >&2
 
+RTE=0
+if [[ \$ECSF -eq -13 ]]; then
+  RTE=0
+elif [[ \$ECSF -ne 0 ]] && cat stderr0 | grep -q "wrong output format Unexpected end of file"; then
+  RTE=1
+fi
+
 ret=0
-if [[ \$ECINT -ge 1 ]] && [[ \$ECINT -le 4 ]]; then
+if [[ \$ECINT -ge 1 ]] && [[ \$ECINT -le 4 ]] && [[ \$RTE -eq 0 ]]; then
   echo "testlib exitcode \$ECINT" >stdout0
   ret=0
 elif [[ \$ECSF -ne 0 ]]; then

rbx/resources/packagers/boca/interactive/java

@@ -159,8 +159,15 @@ echo "solution \$SFPID -> \$ECSF" >&2
 echo "interactor exitcode \$ECINT" >&2
 echo "solution exitcode \$ECSF" >&2
 
+RTE=0
+if [[ \$ECSF -eq -13 ]]; then
+  RTE=0
+elif [[ \$ECSF -ne 0 ]] && cat stderr0 | grep -q "wrong output format Unexpected end of file"; then
+  RTE=1
+fi
+
 ret=0
-if [[ \$ECINT -ge 1 ]] && [[ \$ECINT -le 4 ]]; then
+if [[ \$ECINT -ge 1 ]] && [[ \$ECINT -le 4 ]] && [[ \$RTE -eq 0 ]]; then
   echo "testlib exitcode \$ECINT" >stdout0
   ret=0
 elif [[ \$ECSF -ne 0 ]]; then

rbx/resources/packagers/boca/interactive/kt

@@ -150,8 +150,15 @@ echo "solution \$SFPID -> \$ECSF" >&2
 echo "interactor exitcode \$ECINT" >&2
 echo "solution exitcode \$ECSF" >&2
 
+RTE=0
+if [[ \$ECSF -eq -13 ]]; then
+  RTE=0
+elif [[ \$ECSF -ne 0 ]] && cat stderr0 | grep -q "wrong output format Unexpected end of file"; then
+  RTE=1
+fi
+
 ret=0
-if [[ \$ECINT -ge 1 ]] && [[ \$ECINT -le 4 ]]; then
+if [[ \$ECINT -ge 1 ]] && [[ \$ECINT -le 4 ]] && [[ \$RTE -eq 0 ]]; then
   echo "testlib exitcode \$ECINT" >stdout0
   ret=0
 elif [[ \$ECSF -ne 0 ]]; then