rbx.cp 0.5.61__py3-none-any.whl → 0.5.62__py3-none-any.whl

rbx/box/ui/css/app.tcss

@@ -63,8 +63,11 @@ FileLog > Log {
         background: transparent;
 }
 
-TestExplorerScreen {
-        #test-metadata {
+TestExplorerScreen, RunTestExplorerScreen {
+        #test-box-switcher {
+                height: 1fr;
+        }
+        #test-metadata, #test-box-metadata {
                 min-height: 3;
                 height: auto;
         }
@@ -76,6 +79,15 @@ TestExplorerScreen {
         #test-list {
                 width: 1fr;
         }
+        TestBoxWidget, TwoSidedTestBoxWidget {
+                height: 1fr;
+                #test-box-1 {
+                        width: 1fr;
+                }
+                #test-box-2 {
+                        width: 1fr;
+                }
+        }
         FileLog {
                 border: solid $accent;
                 padding: 0 1;

rbx/box/ui/main.py

@@ -5,14 +5,12 @@ from textual.containers import Center
 from textual.screen import Screen
 from textual.widgets import Footer, Header, OptionList
 
-from rbx.box.ui.screens.build import BuildScreen
-from rbx.box.ui.screens.run import RunScreen
+from rbx.box.ui.screens.run_explorer import RunExplorerScreen
 from rbx.box.ui.screens.test_explorer import TestExplorerScreen
 
 SCREEN_OPTIONS = [
-    ('Run solutions against define testsets.', RunScreen),
-    ('Build tests.', BuildScreen),
-    ('Explore tests.', TestExplorerScreen),
+    ('Explore tests built by `rbx build`.', TestExplorerScreen),
+    ('Explore results of a past `rbx run`.', RunExplorerScreen),
 ]
 
 

rbx/box/ui/screens/error.py

@@ -0,0 +1,19 @@
+from textual.app import ComposeResult
+from textual.screen import Screen
+from textual.widgets import Footer, Header, Label
+
+
+class ErrorScreen(Screen):
+    BINDINGS = [('q', 'app.pop_screen', 'Quit')]
+
+    def __init__(self, message: str):
+        super().__init__()
+        self.message = message
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Footer()
+        yield Label(self.message)
+
+    def on_mount(self):
+        self.query_one(Label).border_title = 'Error'

rbx/box/ui/screens/run.py

@@ -81,20 +81,12 @@ class SolutionReportScreen(Screen):
         if self.log_display_state is not None:
             self.query_one(LogDisplay).load(self.log_display_state)
 
-    def _find_solution_index_in_skeleton(self, sol: Solution) -> int:
-        for i, solution in enumerate(self.skeleton.solutions):
-            if solution.path == sol.path:
-                return i
-        raise
-
     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]
-        )
-        group = self.skeleton.find_group_skeleton(item.group_name)
+        sol_idx_in_skeleton = self.skeleton.find_solution_skeleton_index(item.solution)
+        assert sol_idx_in_skeleton is not None
+        group = self.skeleton.find_group_skeleton(item.testcase_entry.group)
         assert group is not None
-        tc = group.testcases[item.testcase_index]
+        tc = group.testcases[item.testcase_entry.index]
 
         textual.log(len(list(self.query(DataTable))), sol_idx_in_skeleton)
         table = self.query(DataTable)[sol_idx_in_skeleton]

rbx/box/ui/screens/run_explorer.py

@@ -1,5 +1,81 @@
+from typing import Optional
+
+from textual.app import ComposeResult
+from textual.reactive import reactive
 from textual.screen import Screen
+from textual.widgets import Footer, Header, Label, ListItem, ListView
+
+from rbx.box.solutions import SolutionReportSkeleton
+from rbx.box.ui.screens.error import ErrorScreen
+from rbx.box.ui.screens.run_test_explorer import RunTestExplorerScreen
+from rbx.box.ui.screens.selector import SelectorScreen
+from rbx.box.ui.utils.run_ui import get_skeleton, get_solution_markup, has_run
 
 
 class RunExplorerScreen(Screen):
-    pass
+    BINDINGS = [('s', 'compare_with', 'Compare with')]
+
+    skeleton: reactive[Optional[SolutionReportSkeleton]] = reactive(
+        None, recompose=True
+    )
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Footer()
+
+        items = []
+        if self.skeleton:
+            items = [
+                Label(get_solution_markup(self.skeleton, sol), markup=True)
+                for i, sol in enumerate(self.skeleton.solutions)
+            ]
+        run_list = ListView(*[ListItem(item) for item in items], id='run-list')
+        run_list.border_title = 'Runs'
+        yield run_list
+
+    def on_mount(self):
+        if not has_run():
+            self.app.switch_screen(ErrorScreen('No runs found. Run `rbx run` first.'))
+            return
+
+        self.skeleton = get_skeleton()
+
+    def on_list_view_selected(self, event: ListView.Selected):
+        selected_index = event.list_view.index
+        if selected_index is None:
+            return
+        if self.skeleton is None:
+            return
+        self.app.push_screen(
+            RunTestExplorerScreen(
+                self.skeleton, self.skeleton.solutions[selected_index]
+            )
+        )
+
+    def action_compare_with(self):
+        if self.skeleton is None:
+            return
+        list_view = self.query_one('#run-list', ListView)
+        if list_view.index is None:
+            return
+        test_solution = self.skeleton.solutions[list_view.index]
+
+        options = [
+            ListItem(Label(f'{sol.path}', markup=False))
+            for sol in self.skeleton.solutions
+        ]
+
+        def on_selected(index: Optional[int]):
+            if index is None:
+                return
+            if self.skeleton is None:
+                return
+            base_solution = self.skeleton.solutions[index]
+            self.app.push_screen(
+                RunTestExplorerScreen(self.skeleton, test_solution, base_solution)
+            )
+
+        self.app.push_screen(
+            SelectorScreen(options, title='Select a solution to compare against'),
+            callback=on_selected,
+        )

rbx/box/ui/screens/run_test_explorer.py

@@ -0,0 +1,155 @@
+from typing import List, Optional
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+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.solutions import SolutionReportSkeleton, SolutionSkeleton
+from rbx.box.testcase_extractors import (
+    GenerationTestcaseEntry,
+    extract_generation_testcases,
+)
+from rbx.box.ui.utils.run_ui import (
+    get_run_testcase_markup,
+    get_run_testcase_metadata_markup,
+)
+from rbx.box.ui.widgets.file_log import FileLog
+from rbx.box.ui.widgets.test_output_box import TestcaseRenderingData
+from rbx.box.ui.widgets.two_sided_test_output_box import TwoSidedTestBoxWidget
+
+
+class RunTestExplorerScreen(Screen):
+    BINDINGS = [
+        ('q', 'app.pop_screen', 'Quit'),
+        ('1', 'show_output', 'Show output'),
+        ('2', 'show_stderr', 'Show stderr'),
+        ('3', 'show_log', 'Show log'),
+        ('m', 'toggle_metadata', 'Toggle metadata'),
+        ('s', 'toggle_side_by_side', 'Toggle sxs'),
+    ]
+
+    side_by_side: reactive[bool] = reactive(False)
+    diff_with_data: reactive[Optional[TestcaseRenderingData]] = reactive(
+        default=None,
+    )
+
+    def __init__(
+        self,
+        skeleton: SolutionReportSkeleton,
+        solution: SolutionSkeleton,
+        diff_solution: Optional[SolutionSkeleton] = None,
+    ):
+        super().__init__()
+        self.skeleton = skeleton
+        self.solution = solution
+        self.diff_solution = diff_solution
+        self.set_reactive(RunTestExplorerScreen.side_by_side, diff_solution is not None)
+
+        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 TwoSidedTestBoxWidget(id='test-output')
+
+    async def on_mount(self):
+        self.query_one('#test-list').border_title = 'Tests'
+        self.query_one('#test-input').border_title = 'Input'
+
+        await self._update_tests()
+
+    def _get_rendering_data(
+        self, solution: SolutionSkeleton, entry: GenerationTestcaseEntry
+    ) -> TestcaseRenderingData:
+        rendering_data = TestcaseRenderingData.from_one_path(
+            solution.get_entry_prefix(entry.group_entry)
+        )
+        rendering_data.rich_content = get_run_testcase_metadata_markup(
+            self.skeleton, solution, entry.group_entry
+        )
+        return rendering_data
+
+    def _update_selected_test(self, index: Optional[int]):
+        input = self.query_one('#test-input', FileLog)
+        output = self.query_one('#test-output', TwoSidedTestBoxWidget)
+
+        if index is None:
+            input.path = None
+            output.reset()
+            return
+        entry = self._entries[index]
+        input.path = entry.metadata.copied_to.inputPath
+        output.data = self._get_rendering_data(self.solution, entry)
+
+        if self.diff_solution is not None:
+            self.diff_with_data = self._get_rendering_data(self.diff_solution, entry)
+        else:
+            self.diff_with_data = TestcaseRenderingData.from_one_path(
+                entry.group_entry.get_prefix_path()
+            )
+
+    async def _update_tests(self):
+        self.watch(
+            self.query_one('#test-list', ListView),
+            'index',
+            self._update_selected_test,
+        )
+
+        self._entries = await extract_generation_testcases(self.skeleton.entries)
+
+        test_markups = [
+            get_run_testcase_markup(self.solution, entry.group_entry)
+            for entry in self._entries
+        ]
+
+        await self.query_one('#test-list', ListView).clear()
+        await self.query_one('#test-list', ListView).extend(
+            [ListItem(Label(name, markup=True)) for name in test_markups]
+        )
+
+    def has_diffable_solution(self) -> bool:
+        return self.diff_solution is not None or package.get_main_solution() is not None
+
+    def action_show_output(self):
+        self.query_one('#test-output', TwoSidedTestBoxWidget).show_output()
+
+    def action_show_stderr(self):
+        self.query_one('#test-output', TwoSidedTestBoxWidget).show_stderr()
+
+    def action_show_log(self):
+        self.query_one('#test-output', TwoSidedTestBoxWidget).show_log()
+
+    def action_toggle_metadata(self):
+        self.query_one('#test-output', TwoSidedTestBoxWidget).toggle_metadata()
+
+    def action_toggle_side_by_side(self):
+        self.side_by_side = not self.side_by_side
+
+    def watch_side_by_side(self, side_by_side: bool):
+        widget = self.query_one('#test-output', TwoSidedTestBoxWidget)
+
+        if side_by_side:
+            if not self.has_diffable_solution():
+                self.app.notify(
+                    'Found no solution to compare against', severity='error'
+                )
+                return
+            widget.diff_with_data = self.diff_with_data
+        else:
+            widget.diff_with_data = None
+
+    def watch_diff_with_data(self, diff_with_data: Optional[TestcaseRenderingData]):
+        if not self.has_diffable_solution():
+            return
+        if not self.side_by_side:
+            return
+        widget = self.query_one('#test-output', TwoSidedTestBoxWidget)
+        widget.diff_with_data = diff_with_data

rbx/box/ui/screens/selector.py

@@ -0,0 +1,26 @@
+from typing import List, Optional
+
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.widgets import ListItem, ListView
+
+
+class SelectorScreen(ModalScreen[int]):
+    BINDINGS = [('q', 'cancel', 'Cancel')]
+
+    def __init__(self, options: List[ListItem], title: Optional[str] = None):
+        super().__init__()
+        self.options = options
+        self.title = title
+
+    def compose(self) -> ComposeResult:
+        list_view = ListView(*self.options)
+        if self.title:
+            list_view.border_title = self.title
+        yield list_view
+
+    def on_list_view_selected(self, event: ListView.Selected):
+        self.dismiss(event.list_view.index)
+
+    def action_cancel(self):
+        self.dismiss(None)

rbx/box/ui/screens/test_explorer.py

@@ -11,12 +11,16 @@ from rbx.box.testcase_extractors import (
 )
 from rbx.box.ui.widgets.file_log import FileLog
 from rbx.box.ui.widgets.rich_log_box import RichLogBox
+from rbx.box.ui.widgets.test_output_box import TestBoxWidget, TestcaseRenderingData
 
 
 class TestExplorerScreen(Screen):
     BINDINGS = [
         ('q', 'app.pop_screen', 'Quit'),
         ('m', 'toggle_metadata', 'Toggle metadata'),
+        ('1', 'show_output', 'Show output'),
+        ('2', 'show_stderr', 'Show stderr'),
+        ('3', 'show_log', 'Show log'),
     ]
 
     def __init__(self):
@@ -31,13 +35,12 @@ class TestExplorerScreen(Screen):
                 yield ListView(id='test-list')
             with Vertical(id='test-details'):
                 yield FileLog(id='test-input')
-                yield FileLog(id='test-output')
+                yield TestBoxWidget(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
@@ -53,17 +56,20 @@ class TestExplorerScreen(Screen):
 
     def _update_selected_test(self, index: Optional[int]):
         input = self.query_one('#test-input', FileLog)
-        output = self.query_one('#test-output', FileLog)
+        output = self.query_one('#test-output', TestBoxWidget)
         metadata = self.query_one('#test-metadata', RichLog)
 
         if index is None:
             input.path = None
-            output.path = None
+            output.reset()
             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
+
+        output.data = TestcaseRenderingData.from_one_path(
+            entry.metadata.copied_to.outputPath
+        )
 
         metadata.clear()
         metadata.write(
@@ -98,3 +104,12 @@ class TestExplorerScreen(Screen):
         await self.query_one('#test-list', ListView).extend(
             [ListItem(Label(name)) for name in test_names]
         )
+
+    def action_show_output(self):
+        self.query_one('#test-output', TestBoxWidget).show_output()
+
+    def action_show_stderr(self):
+        self.query_one('#test-output', TestBoxWidget).show_stderr()
+
+    def action_show_log(self):
+        self.query_one('#test-output', TestBoxWidget).show_log()

rbx/box/ui/utils/run_ui.py

@@ -0,0 +1,95 @@
+import typing
+from typing import List, Optional
+
+from rbx import utils
+from rbx.box import package, solutions
+from rbx.box.solutions import SolutionReportSkeleton, SolutionSkeleton
+from rbx.box.testcase_utils import TestcaseEntry
+from rbx.grading.steps import Evaluation
+
+
+def has_run() -> bool:
+    return (package.get_problem_runs_dir() / 'skeleton.yml').is_file()
+
+
+def get_skeleton() -> SolutionReportSkeleton:
+    skeleton_path = package.get_problem_runs_dir() / 'skeleton.yml'
+    return utils.model_from_yaml(
+        SolutionReportSkeleton,
+        skeleton_path.read_text(),
+    )
+
+
+def get_solution_eval(
+    solution: SolutionSkeleton, entry: TestcaseEntry
+) -> Optional[Evaluation]:
+    path = solution.get_entry_prefix(entry).with_suffix('.eval')
+    if not path.is_file():
+        return None
+    return utils.model_from_yaml(Evaluation, path.read_text())
+
+
+def get_solution_evals(
+    skeleton: SolutionReportSkeleton, solution: SolutionSkeleton
+) -> List[Optional[Evaluation]]:
+    return [get_solution_eval(solution, entry) for entry in skeleton.entries]
+
+
+def get_solution_evals_or_null(
+    skeleton: SolutionReportSkeleton, solution: SolutionSkeleton
+) -> Optional[List[Evaluation]]:
+    evals = get_solution_evals(skeleton, solution)
+    if any(e is None for e in evals):
+        return None
+    return typing.cast(List[Evaluation], evals)
+
+
+def get_solution_markup(
+    skeleton: SolutionReportSkeleton, solution: SolutionSkeleton
+) -> str:
+    header = f'[b $accent]{solution.path}[/b $accent] ({solution.path})'
+
+    evals = get_solution_evals_or_null(skeleton, solution)
+    report = solutions.get_solution_outcome_report(
+        solution, evals or [], skeleton.verification, subset=False
+    )
+    if evals is None:
+        return header + '\n' + report.get_verdict_markup(incomplete=True)
+    return header + '\n' + report.get_outcome_markup()
+
+
+def get_run_testcase_markup(solution: SolutionSkeleton, entry: TestcaseEntry) -> str:
+    eval = get_solution_eval(solution, entry)
+    if eval is None:
+        return f'{entry}'
+    testcase_markup = solutions.get_testcase_markup_verdict(eval)
+    return f'{testcase_markup} {entry}'
+
+
+def _get_checker_msg_last_line(eval: Evaluation) -> Optional[str]:
+    if eval.result.message is None:
+        return None
+    return eval.result.message.rstrip().split('\n')[-1]
+
+
+def get_run_testcase_metadata_markup(
+    skeleton: SolutionReportSkeleton, solution: SolutionSkeleton, entry: TestcaseEntry
+) -> Optional[str]:
+    eval = get_solution_eval(solution, entry)
+    if eval is None:
+        return None
+    time_str = solutions.get_capped_evals_formatted_time(
+        solution, [eval], skeleton.verification
+    )
+    memory_str = solutions.get_evals_formatted_memory([eval])
+
+    checker_msg = _get_checker_msg_last_line(eval)
+
+    lines = []
+    lines.append(
+        f'[b]{solutions.get_full_outcome_markup_verdict(eval.result.outcome)}[/b]'
+    )
+    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}')
+    return '\n'.join(lines)

rbx/box/ui/widgets/file_log.py

@@ -54,10 +54,12 @@ class FileLog(Widget, can_focus=False):
         log.clear()
 
         if path is None:
+            self.border_subtitle = '(no file selected)'
             return
 
         if not path.is_file():
-            self.query_one(Log).write(f'File {path} does not exist')
+            path_str = str(path.relative_to(pathlib.Path.cwd()))
+            self.border_subtitle = f'{path_str} (does not exist)'
             return
 
         self._load_file(path)

rbx/box/ui/widgets/test_output_box.py

@@ -0,0 +1,104 @@
+import dataclasses
+import pathlib
+from typing import Optional
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import ContentSwitcher
+
+from rbx.box.ui.widgets.file_log import FileLog
+from rbx.box.ui.widgets.rich_log_box import RichLogBox
+
+
+@dataclasses.dataclass
+class TestcaseRenderingData:
+    input_path: Optional[pathlib.Path] = None
+    output_path: Optional[pathlib.Path] = None
+    stderr_path: Optional[pathlib.Path] = None
+    log_path: Optional[pathlib.Path] = None
+    rich_content: Optional[str] = None
+
+    @classmethod
+    def from_one_path(cls, path: pathlib.Path) -> 'TestcaseRenderingData':
+        return cls(
+            input_path=path.with_suffix('.in'),
+            output_path=path.with_suffix('.out'),
+            stderr_path=path.with_suffix('.err'),
+            log_path=path.with_suffix('.log'),
+        )
+
+
+class TestBoxWidget(Widget, can_focus=False):
+    data: reactive[TestcaseRenderingData] = reactive(
+        default=lambda: TestcaseRenderingData(),
+        bindings=True,
+    )
+
+    @dataclasses.dataclass
+    class Logs:
+        output: FileLog
+        stderr: FileLog
+        log: FileLog
+
+    def logs(self) -> Logs:
+        return self.Logs(
+            output=self.query_one('#test-box-output', FileLog),
+            stderr=self.query_one('#test-box-stderr', FileLog),
+            log=self.query_one('#test-box-log', FileLog),
+        )
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            with ContentSwitcher(initial='test-box-output', id='test-box-switcher'):
+                yield FileLog(id='test-box-output')
+                yield FileLog(id='test-box-stderr')
+                yield FileLog(id='test-box-log')
+            yield RichLogBox(id='test-box-metadata')
+
+    def on_mount(self):
+        logs = self.logs()
+        logs.output.border_title = 'Output'
+        logs.stderr.border_title = 'Stderr'
+        logs.log.border_title = 'Log'
+
+        metadata = self.query_one('#test-box-metadata', RichLogBox)
+        metadata.display = False
+        metadata.border_title = 'Metadata'
+        metadata.wrap = True
+        metadata.markup = True
+        metadata.clear()
+        metadata.write('No metadata')
+
+        self.watch_data(self.data)
+
+    def watch_data(self, data: TestcaseRenderingData):
+        logs = self.logs()
+        logs.output.path = data.output_path
+        logs.stderr.path = data.stderr_path
+        logs.log.path = data.log_path
+
+        metadata = self.query_one('#test-box-metadata', RichLogBox)
+        metadata.clear()
+        if data.rich_content is not None:
+            metadata.write(data.rich_content)
+        else:
+            metadata.write('No metadata')
+
+    def reset(self):
+        self.data = TestcaseRenderingData()
+
+    def show_output(self):
+        self.query_one(ContentSwitcher).current = 'test-box-output'
+
+    def show_stderr(self):
+        self.query_one(ContentSwitcher).current = 'test-box-stderr'
+
+    def show_log(self):
+        self.query_one(ContentSwitcher).current = 'test-box-log'
+
+    def toggle_metadata(self):
+        metadata = self.query_one('#test-box-metadata', RichLogBox)
+        metadata.display = not metadata.display
+        metadata.refresh()