rbx.cp 0.5.0__py3-none-any.whl

rbx/box/ui/captured_log.py

@@ -0,0 +1,372 @@
+import asyncio
+import copy
+import dataclasses
+import fcntl
+import os
+import pty
+import re
+import signal
+import struct
+import termios
+from typing import Callable, List, Optional
+
+import pyte
+import textual
+from pyte.screens import Char
+from rich.color import ColorParseError
+from rich.segment import Segment
+from rich.style import Style
+from rich.text import Text
+from textual import events
+from textual.app import DEFAULT_COLORS
+from textual.design import ColorSystem
+from textual.geometry import Size
+from textual.scroll_view import ScrollView
+from textual.strip import Strip
+
+
+class PyteDisplay:
+    lines: List[List[Segment]]
+
+    def __init__(self, lines):
+        self.lines = lines
+
+    @property
+    def virtual_height(self):
+        return len(self.lines)
+
+
+@dataclasses.dataclass
+class LogDisplayState:
+    screen: pyte.Screen
+    exitcode: Optional[int]
+
+
+@dataclasses.dataclass
+class Emulator:
+    communicate_task: asyncio.Task
+    send_task: asyncio.Task
+    wait_task: asyncio.Task
+    pid: int
+    callback: Optional[Callable] = None
+
+    def disconnect(self):
+        self.communicate_task.cancel()
+        self.send_task.cancel()
+        self.wait_task.cancel()
+        try:
+            os.kill(self.pid, signal.SIGTERM)
+        except OSError:
+            # Process does not exist anymore.
+            pass
+
+
+class LogDisplay(ScrollView, can_focus=True):
+    DEFAULT_CSS = """
+    LogDisplay {
+        background: $background;
+    }
+    """
+    emulator: Optional[Emulator]
+    exitcode: Optional[int]
+
+    def __init__(
+        self,
+        default_colors: Optional[str] = 'textual',
+        max_lines: int = 1000,
+        name: Optional[str] = None,
+        id: Optional[str] = None,
+        classes: Optional[str] = None,
+    ):
+        super().__init__(name=name, id=id, classes=classes)
+
+        self.emulator = None
+        self.default_colors = default_colors
+        if default_colors == 'textual':
+            self.textual_colors = self.detect_textual_colors()
+
+        self.virtual_size = Size(80, max_lines)
+        self._max_lines = max_lines
+        self._display = PyteDisplay([Text()])
+        self._screen = pyte.Screen(self.virtual_size.width, self._max_lines)
+        self.stream = pyte.Stream(self._screen)
+
+        self.recv_queue = asyncio.Queue()
+        self.send_queue = asyncio.Queue()
+        self.exitcode = None
+
+    async def on_resize(self, _event: events.Resize):
+        if self.emulator is None:
+            return
+
+        # Update only width.
+        self.virtual_size = Size(
+            width=self.size.width - 2,  # Account for scroll bar.
+            height=self.virtual_size.height,
+        )
+        await self.send_queue.put(
+            ['set_size', self._max_lines, self.virtual_size.width]
+        )
+        self._screen.resize(self._max_lines, self.virtual_size.width)
+        self.update_display()
+
+    def update_display(self):
+        lines: List[List[Segment]] = []
+        for y in range(self._screen.lines):
+            line = self._screen.buffer[y]
+            line_segments = []
+            accumulated_text = []
+            for x in range(self._screen.columns):
+                char: Char = line[x]
+                if x > 0 and (not self.char_style_cmp(char, line[x - 1])):
+                    text = ''.join(accumulated_text)
+                    line_segments.append(
+                        Segment(text, style=self.char_rich_style(line[x - 1]))
+                    )
+                    accumulated_text = []
+                accumulated_text.append(char.data)
+            if accumulated_text:
+                text = ''.join(accumulated_text)
+                line_segments.append(
+                    Segment(
+                        text, style=self.char_rich_style(line[self._screen.columns - 1])
+                    )
+                )
+            lines.append(line_segments)
+
+        # Remove empty lines from the back.
+        while lines:
+            last_line = lines[-1]
+            text = ''.join(seg.text for seg in last_line)
+            if text.strip():
+                break
+            lines.pop()
+
+        self._display = PyteDisplay(lines)
+        self.virtual_size = Size(
+            width=self.size.width - 2,  # Account for possible vertical scrollbar.
+            height=self._display.virtual_height,
+        )
+        self.refresh()
+
+    def disconnect(self):
+        if self.emulator is None:
+            return
+        cb = self.emulator.callback
+        self.emulator.disconnect()
+        self.emulator = None
+        self.recv_queue = asyncio.Queue()
+        self.send_queue = asyncio.Queue()
+        if cb is not None:
+            cb()
+        self.recv_task.cancel()
+
+    async def recv(self):
+        while True:
+            msg = await self.recv_queue.get()
+            cmd = msg[0]
+            if cmd == 'setup':
+                await self.send_queue.put(
+                    [
+                        'set_size',
+                        self.virtual_size.height,
+                        self.virtual_size.width,
+                    ]
+                )
+            elif cmd == 'stdout':
+                chars = msg[1]
+                self.stream.feed(chars)
+                self.update_display()
+            elif cmd == 'disconnect':
+                self.disconnect()
+
+    def char_rich_style(self, char: Char) -> Style:
+        """Returns a rich.Style from the pyte.Char."""
+
+        foreground = self.detect_color(char.fg)
+        background = self.detect_color(char.bg)
+        if self.default_colors == 'textual':
+            if background == 'default':
+                background = self.textual_colors['background']
+            if foreground == 'default':
+                foreground = self.textual_colors['foreground']
+
+        style: Optional[Style]
+        try:
+            style = Style(
+                color=foreground,
+                bgcolor=background,
+                bold=char.bold,
+            )
+        except ColorParseError as error:
+            textual.log.warning('color parse error:', error)
+            style = None
+
+        return style or Style()
+
+    def char_style_cmp(self, given: Char, other: Char) -> bool:
+        """Compares two pyte.Chars and returns if these are the same.
+
+        Returns:
+            True    if char styles are the same
+            False   if char styles differ
+        """
+
+        if (
+            given.fg == other.fg
+            and given.bg == other.bg
+            and given.bold == other.bold
+            and given.italics == other.italics
+            and given.underscore == other.underscore
+            and given.strikethrough == other.strikethrough
+            and given.reverse == other.reverse
+            and given.blink == other.blink
+        ):
+            return True
+
+        return False
+
+    def char_style_default(self, char: Char) -> bool:
+        """Returns True if the given char has a default style."""
+
+        if (
+            char.fg == 'default'
+            and char.bg == 'default'
+            and char.bold is False
+            and char.italics is False
+            and char.underscore is False
+            and char.strikethrough is False
+            and char.reverse is False
+            and char.blink is False
+        ):
+            return True
+
+        return False
+
+    def detect_color(self, color: str) -> str:
+        """Tries to detect the correct Rich-Color based on a color name.
+
+        * Returns #<color> if <color> is a hex-definition without "#"
+        * Fixes wrong ANSI color names.
+
+        Examples:
+          * htop is using "brown" => not an ANSI color
+        """
+
+        if color == 'brown':
+            return 'yellow'
+
+        if color == 'brightblack':
+            # fish tabbing through recommendations
+            return '#808080'
+        if color == 'brightwhite':
+            return '#FFFFFF'
+
+        if re.match('[0-9a-f]{6}', color, re.IGNORECASE):
+            return f'#{color}'
+
+        return color
+
+    def detect_textual_colors(self) -> dict:
+        """Returns the currently used colors of textual depending on dark-mode."""
+
+        if self.app.dark:
+            color_system: ColorSystem = DEFAULT_COLORS['dark']
+        else:
+            color_system: ColorSystem = DEFAULT_COLORS['light']
+
+        return color_system.generate()
+
+    def render_line(self, y: int) -> Strip:
+        scroll_x, scroll_y = self.scroll_offset
+        y += scroll_y
+        if y >= len(self._display.lines):
+            return Strip.blank(self.size.width)
+        line = self._display.lines[y]
+        strip = Strip(line).crop(scroll_x, scroll_x + self.size.width)
+        return strip
+
+    def export(self):
+        return LogDisplayState(screen=copy.copy(self._screen), exitcode=self.exitcode)
+
+    def load(self, state: LogDisplayState):
+        self.disconnect()
+        self._screen = state.screen
+        self.stream = pyte.Stream(self._screen)
+        self.exitcode = state.exitcode
+        self.update_display()
+
+    async def capture(self, argv: List[str]) -> int:
+        self.exitcode = None
+        self.recv_task = asyncio.create_task(self.recv())
+
+        loop = asyncio.get_running_loop()
+        send_queue = self.recv_queue
+        recv_queue = self.send_queue
+        event = asyncio.Event()
+
+        pid, fd = pty.fork()
+        if pid == 0:  # Child
+            os.execvp(argv[0], argv)
+
+        pout = os.fdopen(fd, 'w+b', 0)
+        data: Optional[str] = None
+
+        def on_output():
+            nonlocal data
+            try:
+                data = pout.read(65536).decode()  # Read non-blocking.
+            except Exception:
+                data = None
+                loop.remove_reader(pout)
+            event.set()
+
+        async def cleanup():
+            try:
+                loop.remove_reader(pout)
+                _, exitstatus = os.waitpid(pid, os.WNOHANG)
+                exitcode = os.waitstatus_to_exitcode(exitstatus)
+                self.exitcode = exitcode
+            except ChildProcessError:
+                self.exitcode = -1
+            await send_queue.put(['disconnect', 1])
+
+        async def communicate():
+            await send_queue.put(['setup', {}])
+
+            while True:
+                msg = await recv_queue.get()
+                if msg[0] == 'set_size':
+                    winsize = struct.pack('HH', msg[1], msg[2])
+                    fcntl.ioctl(fd, termios.TIOCSWINSZ, winsize)
+
+        async def send():
+            while True:
+                await event.wait()
+                event.clear()
+                if data is None:
+                    await cleanup()
+                else:
+                    await send_queue.put(['stdout', data])
+
+        async def wait():
+            while True:
+                try:
+                    if os.waitpid(pid, os.WNOHANG) != (0, 0):
+                        await cleanup()
+                except ChildProcessError:
+                    break
+                await asyncio.sleep(0.5)
+
+        finish = asyncio.Event()
+        self.emulator = Emulator(
+            asyncio.create_task(communicate()),
+            asyncio.create_task(send()),
+            asyncio.create_task(wait()),
+            pid=pid,
+            callback=lambda: finish.set(),
+        )
+        loop.add_reader(pout, on_output)
+        await finish.wait()
+        assert self.exitcode is not None
+        return self.exitcode

rbx/box/ui/css/app.tcss

@@ -0,0 +1,48 @@
+Screen {
+        background: $background;
+        color: $text;
+}
+
+rbxApp > Screen {
+        align: center middle;
+}
+
+SelectionList {
+        border-title-color: $accent;
+}
+
+Button {
+        width: 1fr;
+        background: $accent;
+}
+
+#report-grid {
+        layout: grid;
+        grid-size: 2 2;
+}
+
+DataTable {
+        border: solid $accent 100%;
+}
+
+DataTable > .datatable--cursor {
+        color: $text;
+        background: $accent;
+}
+
+DataTable:blur > .datatable--cursor {
+        color: $text;
+        background: transparent;
+}
+
+RunScreen {
+        align: center middle;
+        #run-settings {
+                border: thick $background 40%;
+        }
+        LogDisplay {
+                width: 1fr;
+                padding: 0 1;
+                border: solid $accent;
+        }
+}

rbx/box/ui/main.py

@@ -0,0 +1,38 @@
+from typing import Type
+
+from textual.app import App, ComposeResult
+from textual.containers import Center
+from textual.screen import Screen
+from textual.widgets import Footer, Header, OptionList
+
+from rbx.box.ui.run import RunScreen
+
+SCREEN_OPTIONS = [
+    ('Run solutions against define testsets.', RunScreen),
+]
+
+
+class rbxApp(App):
+    TITLE = 'rbx'
+    CSS_PATH = 'css/app.tcss'
+    BINDINGS = [('q', 'quit', 'Quit')]
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Footer()
+        with Center(id='main'):
+            yield OptionList(*(opt[0] for opt in SCREEN_OPTIONS))
+
+    def on_mount(self):
+        self.query_one(OptionList).border_title = 'Select a flow'
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected):
+        self.show_screen(SCREEN_OPTIONS[event.option_index][1])
+
+    def show_screen(self, screen_cls: Type[Screen]):
+        self.push_screen(screen_cls())
+
+
+def start():
+    app = rbxApp()
+    app.run()

rbx/box/ui/run.py

@@ -0,0 +1,209 @@
+import pathlib
+from typing import Optional, Set
+
+import textual
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Center, Container, Grid
+from textual.coordinate import Coordinate
+from textual.screen import Screen
+from textual.widgets import Button, DataTable, Footer, Header, SelectionList
+from textual.widgets.selection_list import Selection
+
+from rbx import console
+from rbx.box import package
+from rbx.box.schema import Solution
+from rbx.box.solutions import (
+    EvaluationItem,
+    SolutionReportSkeleton,
+    get_evals_formatted_time,
+    get_testcase_markup_verdict,
+    run_solutions,
+)
+from rbx.box.ui.captured_log import LogDisplay, LogDisplayState
+
+
+def _build_solution_selection_label(sol: Solution) -> Text:
+    main = package.get_main_solution()
+    outcome = sol.outcome if main is None or main.path != sol.path else 'MAIN'
+
+    style = sol.outcome.style()
+    text = Text(f'{sol.path}')
+    text.append(f' {outcome}', style=style)
+    return text
+
+
+class SolutionReportScreen(Screen):
+    skeleton: SolutionReportSkeleton
+
+    BINDINGS = [('q', 'app.pop_screen', 'Quit')]
+
+    def __init__(
+        self,
+        skeleton: SolutionReportSkeleton,
+        log_display_state: Optional[LogDisplayState] = None,
+    ):
+        super().__init__()
+        self.skeleton = skeleton
+        self.log_display_state = log_display_state
+
+    def compose(self) -> ComposeResult:
+        textual.log(self.skeleton)
+        yield Header()
+        yield Footer()
+        with Grid(id='report-grid'):
+            for _ in self.skeleton.solutions:
+                yield DataTable(
+                    cursor_type='row', cursor_foreground_priority='renderable'
+                )
+        if self.log_display_state is not None:
+            yield LogDisplay()
+
+    def on_mount(self):
+        self.query_one(
+            '#build-output', Container
+        ).border_title = 'Test generation and validation'
+        for solution, table in zip(
+            self.skeleton.solutions,
+            self.query(DataTable),
+        ):
+            table.border_title = str(solution.path)
+            table.border_subtitle = _build_solution_selection_label(solution)
+            table.add_columns('group', 'test', '?', 'time')
+
+            for group in self.skeleton.groups:
+                for i, tc in enumerate(group.testcases):
+                    table.add_row(group.name, i, '', '', key=str(tc.inputPath))
+
+        self.query_one(DataTable).focus()
+
+        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
+
+    def process(self, item: EvaluationItem):
+        textual.log(item)
+        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)
+        assert group is not None
+        tc = group.testcases[item.testcase_index]
+
+        textual.log(len(list(self.query(DataTable))), sol_idx_in_skeleton)
+        table = self.query(DataTable)[sol_idx_in_skeleton]
+        row_idx = table.get_row_index(str(tc.inputPath))
+
+        table.update_cell_at(
+            Coordinate(row=row_idx, column=2),
+            get_testcase_markup_verdict(item.eval),
+            update_width=True,
+        )
+        table.update_cell_at(
+            Coordinate(row=row_idx, column=3),
+            get_evals_formatted_time([item.eval]),
+            update_width=True,
+        )
+
+
+class RunScreen(Screen):
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Footer()
+        with Center(id='run-settings'):
+            pkg = package.find_problem_package_or_die()
+            solutions = package.get_solutions()
+            yield SelectionList[pathlib.Path](
+                *(
+                    Selection(_build_solution_selection_label(sol), sol.path, True)
+                    for sol in solutions
+                ),
+                id='run-sols',
+            )
+            yield SelectionList[str](
+                *(
+                    Selection(testgroup.name, testgroup.name, initial_state=True)
+                    for testgroup in pkg.testcases
+                ),
+                id='run-testgroups',
+            )
+            yield SelectionList[str](
+                Selection(
+                    'Generate expected outputs and run checker',
+                    'check',
+                    initial_state=True,
+                ),
+                id='run-config',
+            )
+            yield Button('Run')
+            yield LogDisplay()
+
+    def on_mount(self):
+        sols = self.query_one('#run-sols', SelectionList)
+        sols.border_title = 'Select solutions to run'
+        sols.focus()
+
+        testgroups = self.query_one('#run-testgroups', SelectionList)
+        testgroups.border_title = 'Select which testgroups to execute'
+
+        config = self.query_one('#run-config', SelectionList)
+        config.border_title = 'Configure the execution'
+
+    def on_screen_resume(self):
+        self.query_one('#run-sols', SelectionList).focus()
+
+    def on_button_pressed(self, _: Button.Pressed):
+        self.action_run()
+
+    @textual.work(thread=True)
+    def _run_solutions(self, tracked_solutions: Set[str], check: bool):
+        main_solution = package.get_main_solution()
+        if check and main_solution is None:
+            console.console.print(
+                '[warning]No main solution found, running without checkers.[/warning]'
+            )
+            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('early quit')
+            return
+
+        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 = self.app.call_from_thread(mount_report_widget)
+
+        def process(item: EvaluationItem):
+            new_screen.process(item)
+
+        for item in res.items:
+            self.app.call_from_thread(process, item)
+
+    def action_run(self):
+        sols = self.query_one('#run-sols', SelectionList)
+        config = self.query_one('#run-config', SelectionList)
+
+        tracked_solutions = set(str(sol) for sol in sols.selected)
+        check = 'check' in config.selected
+
+        self._run_solutions(tracked_solutions, check)