rbx.cp 0.5.65__py3-none-any.whl → 0.5.67__py3-none-any.whl

rbx/box/solutions.py

@@ -16,7 +16,7 @@ import typer
 from pydantic import BaseModel
 
 from rbx import console, utils
-from rbx.box import checkers, environment, package, state
+from rbx.box import checkers, environment, package, remote, state
 from rbx.box.code import (
     SanitizationLevel,
     compile_item,
@@ -130,7 +130,7 @@ class RunSolutionResult:
 
 def is_fast(solution: Solution) -> bool:
     # If solution has TLE tag, it is considered slow.
-    return not solution.outcome.match(Outcome.TIME_LIMIT_EXCEEDED)
+    return not solution.outcome.is_slow()
 
 
 def get_matching_solutions(expected_outcome: ExpectedOutcome) -> List[Solution]:
@@ -159,12 +159,10 @@ def compile_solutions(
 
     compiled_solutions = {}
 
-    for solution in pkg.solutions:
-        if (
-            tracked_solutions is not None
-            and str(solution.path) not in tracked_solutions
-        ):
-            continue
+    if tracked_solutions is None:
+        tracked_solutions = set(str(sol.path) for sol in pkg.solutions)
+
+    for solution in expand_solutions(list(tracked_solutions)):
         if progress:
             progress.update(f'Compiling solution {href(solution.path)}...')
         try:
@@ -254,11 +252,7 @@ def _get_solutions_for_skeleton(
         if verification.value >= VerificationLevel.ALL_SOLUTIONS.value or is_fast(sol)
     ]
     if tracked_solutions is not None:
-        solutions = [
-            solution
-            for solution in solutions
-            if str(solution.path) in tracked_solutions
-        ]
+        solutions = expand_solutions(list(tracked_solutions))
     return solutions
 
 
@@ -726,28 +720,42 @@ def _get_solution_repr(sol: Solution) -> List[Tuple[str, str]]:
     ]
 
 
-async def expand_solutions(sols: List[str]) -> List[Solution]:
+def expand_solutions_with_source(sols: List[str]) -> List[Tuple[Solution, bool]]:
     pkg = package.find_problem_package_or_die()
-    seen_sols = set(str(sol.path) for sol in pkg.solutions)
+    pkg_sols = {str(sol.path): sol for sol in pkg.solutions}
 
-    # Dedup sols.
-    sols = [sol for sol in sols if str(sol) not in seen_sols]
+    # Download remote sols.
+    sols = remote.expand_files(sols)
 
     # Ensure sols exist.
     sols = [sol for sol in sols if pathlib.Path(sol).is_file()]
 
-    return [
-        Solution(path=pathlib.Path(sol), outcome=ExpectedOutcome.ACCEPTED)
-        for sol in sols
-    ]
+    seen_sols = set()
+    res: List[Tuple[Solution, bool]] = []
+    for sol in sols:
+        if sol in seen_sols:
+            # This solution was already added.
+            continue
+        if sol in pkg_sols:
+            # This solution is in the package.
+            res.append((pkg_sols[sol], False))
+        else:
+            # This solution is fetched from some source.
+            res.append(
+                (Solution(path=pathlib.Path(sol), outcome=ExpectedOutcome.ANY), True)
+            )
+        seen_sols.add(sol)
+    return res
+
+
+def expand_solutions(sols: List[str]) -> List[Solution]:
+    return [sol for sol, _ in expand_solutions_with_source(sols)]
 
 
 async def pick_solutions(
     tracked_solutions: Optional[Set[str]],
-    extra_solutions: Optional[Iterable[Solution]] = None,
+    extra_solutions: Optional[List[str]] = None,
 ) -> List[str]:
-    extra_sols = set(extra_solutions) if extra_solutions is not None else set()
-
     pkg = package.find_problem_package_or_die()
     # Store in a separate list to maintain order with the package declaration.
     import questionary
@@ -763,13 +771,15 @@ async def pick_solutions(
 
     seen_sols = set(str(sol.path) for sol in pkg.solutions)
 
-    if extra_sols:
+    if extra_solutions is not None:
         # Add only new solutions.
         choices.extend(
             questionary.Choice(
-                title=_get_solution_repr(sol), value=str(sol.path), checked=True
+                title=_get_solution_repr(sol),
+                value=str(sol.path),
+                checked=True,
             )
-            for sol in extra_sols
+            for sol in expand_solutions(extra_solutions)
             if str(sol.path) not in seen_sols
         )
 
@@ -784,7 +794,7 @@ def get_outcome_style_verdict(outcome: Outcome) -> str:
         return 'green'
     if outcome == Outcome.WRONG_ANSWER:
         return 'red'
-    if outcome == Outcome.TIME_LIMIT_EXCEEDED:
+    if outcome.is_slow():
         return 'yellow'
     if outcome == Outcome.RUNTIME_ERROR:
         return 'blue'
@@ -797,7 +807,7 @@ def get_outcome_markup_verdict(outcome: Outcome) -> str:
     res = '✓'
     if outcome != Outcome.ACCEPTED:
         res = '✗'
-    if outcome == Outcome.TIME_LIMIT_EXCEEDED:
+    if outcome.is_slow():
         res = '⧖'
     if outcome == Outcome.RUNTIME_ERROR:
         res = '✗'
@@ -827,6 +837,19 @@ def get_full_testcase_markup_verdict(eval: Evaluation) -> str:
 def _get_evals_time_in_ms(evals: List[Evaluation]) -> int:
     if not evals:
         return 0
+    evals_with_ile = [
+        eval for eval in evals if eval.result.outcome == Outcome.IDLENESS_LIMIT_EXCEEDED
+    ]
+    for eval in evals_with_ile:
+        # Try every way of estimating a ILE max timelimit.
+        if eval.log.metadata is None:
+            continue
+        if eval.log.metadata.limits is not None:
+            expanded_tl = eval.log.metadata.limits.get_expanded_tl()
+            if expanded_tl is not None:
+                return expanded_tl
+        if eval.log.metadata.timeLimit is not None:
+            return eval.log.metadata.timeLimit
     return max(int((eval.log.time or 0.0) * 1000) for eval in evals)
 
 
@@ -847,7 +870,10 @@ def get_capped_evals_formatted_time(
     pkg = package.find_problem_package_or_die()
 
     max_time = _get_evals_time_in_ms(evals)
-    has_tle = any(eval.result.outcome == Outcome.TIME_LIMIT_EXCEEDED for eval in evals)
+    has_tle = any(eval.result.outcome.is_slow() for eval in evals)
+    has_ile = any(
+        eval.result.outcome == Outcome.IDLENESS_LIMIT_EXCEEDED for eval in evals
+    )
     timelimits = [
         eval.log.metadata.limits.get_expanded_tl()
         for eval in evals
@@ -865,7 +891,7 @@ def get_capped_evals_formatted_time(
             # Using double TL for verification.
             tl = tl * 2
 
-    if has_tle and max_time >= tl:
+    if has_tle and max_time >= tl or has_ile:
         return f'>{tl} ms'
     return f'{max_time} ms'
 
@@ -950,8 +976,7 @@ def get_solution_outcome_report(
         ):
             no_tle_bad_verdicts.add(eval.result.no_tle_outcome)
         has_plain_tle = has_plain_tle or (
-            eval.result.outcome == Outcome.TIME_LIMIT_EXCEEDED
-            and eval.result.no_tle_outcome is None
+            eval.result.outcome.is_slow() and eval.result.no_tle_outcome is None
         )
         has_sanitizer_warnings = (
             has_sanitizer_warnings or eval.result.sanitizer_warnings
@@ -984,9 +1009,7 @@ def get_solution_outcome_report(
             report_got_verdicts = {Outcome.ACCEPTED}
 
     evals_time = _get_evals_time_in_ms(evals)
-    expected_outcome_is_tle = solution.outcome.match(
-        Outcome.TIME_LIMIT_EXCEEDED
-    ) and not solution.outcome.match(Outcome.ACCEPTED)
+    expected_outcome_is_tle = solution.outcome.matches_tle_and_is_incorrect()
     if (
         # Running verification with double TL.
         verification.value >= VerificationLevel.FULL.value

rbx/box/stresses.py

@@ -8,7 +8,7 @@ import typer
 from pydantic import BaseModel
 
 from rbx import console
-from rbx.box import checkers, package, validators
+from rbx.box import checkers, generators, package, validators
 from rbx.box.code import SanitizationLevel, compile_item, run_item
 from rbx.box.generators import (
     GenerationMetadata,
@@ -51,10 +51,10 @@ def _compile_finder(finder: CodeItem) -> str:
 
 
 async def run_stress(
-    name: str,
     timeoutInSeconds: int,
+    name: Optional[str] = None,
     finder: Optional[str] = None,
-    args: Optional[str] = None,
+    generator_call: Optional[str] = None,
     findingsLimit: int = 1,
     verbose: bool = False,
     progress: Optional[StatusProgress] = None,
@@ -68,12 +68,23 @@ async def run_stress(
         raise typer.Exit(1)
 
     if finder:
+        if generator_call is None:
+            console.console.print(
+                '[error]Generator arguments are required for stress testing. Specify them through the [item]-g[/item] flag.[/error]'
+            )
+            raise typer.Exit(1)
+        generator = generators.get_call_from_string(generator_call)
         stress = Stress(
-            name=f'{name}',
-            generator=GeneratorCall(name=name, args=args or ''),
+            name=f'{generator.name}',
+            generator=generator,
             finder=finder,
         )
     else:
+        if name is None:
+            console.console.print(
+                '[error]Invalid stress test paramaters. Either provide a stress test name, or provide a finder expression (-f) and generator arguments (-g).[/error]'
+            )
+            raise typer.Exit(1)
         stress = package.get_stress(name)
 
     call = stress.generator
@@ -258,7 +269,7 @@ async def run_stress(
 
         if internal_error_results:
             console.console.print(
-                f'[error]Checkers failed during stress test [item]{name}[/item] with args [info]{expanded_generator_call.name} {expanded_generator_call.args}[/info][/error]'
+                f'[error]Checkers failed during stress test [item]{stress.name}[/item] with args [info]{expanded_generator_call.name} {expanded_generator_call.args}[/info][/error]'
             )
             for internal_error_result in internal_error_results:
                 assert internal_error_result.checker is not None

rbx/box/ui/css/app.tcss

@@ -1,10 +1,11 @@
 Screen {
         background: $background;
         color: $text;
+        align: center middle;
 }
 
-Screen {
-        align: center middle;
+ModalScreen {
+        background: $background 65%;
 }
 
 ListView {
@@ -21,6 +22,16 @@ OptionList {
         border: solid $accent;
 }
 
+DiffBox {
+        border: solid $accent;
+        height: 1fr;
+        width: 1fr;
+        RichLog {
+                height: 1fr;
+                width: 1fr;
+        }
+}
+
 Button {
         width: 1fr;
         background: $accent;
@@ -96,4 +107,27 @@ TestExplorerScreen, RunTestExplorerScreen {
                 border: solid $accent;
                 padding: 0 1;
         }
+}
+
+#rich-dialog {
+        max-width: 80;
+        height: auto;
+        max-height: 5;
+
+        RichLog {
+                border: solid $accent;
+                padding: 0 1;
+        }
+}
+
+#selector-dialog {
+        max-width: 80;
+        height: auto;
+}
+
+#run-tips {
+        border: solid $accent;
+        padding: 0 1;
+        height: auto;
+        text-align: center;
 }

rbx/box/ui/main.py

@@ -1,3 +1,4 @@
+import pathlib
 from typing import Type
 
 from textual.app import App, ComposeResult
@@ -5,6 +6,8 @@ from textual.containers import Center
 from textual.screen import Screen
 from textual.widgets import Footer, Header, OptionList
 
+from rbx.box import remote
+from rbx.box.ui.screens.differ import DifferScreen
 from rbx.box.ui.screens.run_explorer import RunExplorerScreen
 from rbx.box.ui.screens.test_explorer import TestExplorerScreen
 
@@ -35,6 +38,27 @@ class rbxApp(App):
         self.push_screen(screen_cls())
 
 
+class rbxDifferApp(App):
+    TITLE = 'rbx differ'
+    CSS_PATH = 'css/app.tcss'
+    BINDINGS = [('q', 'quit', 'Quit')]
+
+    def __init__(self, path1: pathlib.Path, path2: pathlib.Path):
+        super().__init__()
+        self.path1 = path1
+        self.path2 = path2
+
+    def on_mount(self):
+        self.push_screen(DifferScreen(self.path1, self.path2))
+
+
 def start():
     app = rbxApp()
     app.run()
+
+
+def start_differ(path1: pathlib.Path, path2: pathlib.Path):
+    path1, path2 = remote.expand_files([path1, path2])
+
+    app = rbxDifferApp(path1, path2)
+    app.run()

rbx/box/ui/screens/differ.py

@@ -0,0 +1,29 @@
+import pathlib
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import Screen
+from textual.widgets import Footer, Header
+
+from rbx.box.ui.widgets.diff_box import DiffBox
+
+
+class DifferScreen(Screen):
+    BINDINGS = [
+        ('q', 'quit', 'Quit'),
+    ]
+
+    def __init__(self, path1: pathlib.Path, path2: pathlib.Path):
+        super().__init__()
+        self.path1 = path1
+        self.path2 = path2
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Footer()
+        with Vertical():
+            yield DiffBox()
+
+    def on_mount(self):
+        diff = self.query_one(DiffBox)
+        diff.paths = (self.path1, self.path2)

rbx/box/ui/screens/rich_log_modal.py

@@ -0,0 +1,29 @@
+from typing import Optional
+
+from textual.app import ComposeResult
+from textual.containers import Container
+from textual.screen import ModalScreen
+
+from rbx.box.ui.widgets.rich_log_box import RichLogBox
+
+
+class RichLogModal(ModalScreen[None]):
+    BINDINGS = [
+        ('q', 'app.pop_screen', 'Close'),
+        ('g', 'app.pop_screen', 'Close'),
+    ]
+
+    def __init__(self, log: str, title: Optional[str] = None):
+        super().__init__()
+        self._log = log
+        self._title = title
+
+    def compose(self) -> ComposeResult:
+        with Container(id='rich-dialog'):
+            box = RichLogBox(markup=True)
+            if self._title:
+                box.border_title = self._title
+            yield box
+
+    async def on_mount(self):
+        self.query_one(RichLogBox).write(self._log)

rbx/box/ui/screens/run_explorer.py

@@ -1,15 +1,19 @@
 from typing import Optional
 
 from textual.app import ComposeResult
+from textual.containers import 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.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
 from rbx.box.ui.screens.selector import SelectorScreen
 from rbx.box.ui.utils.run_ui import get_skeleton, get_solution_markup, has_run
+from rbx.box.ui.widgets.rich_log_box import RichLogBox
 
 
 class RunExplorerScreen(Screen):
@@ -29,9 +33,22 @@ class RunExplorerScreen(Screen):
                 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
+        with Vertical():
+            run_list = ListView(*[ListItem(item) for item in items], id='run-list')
+            run_list.border_title = 'Runs'
+            yield run_list
+
+            tips = RichLogBox(id='run-tips')
+            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 -d run[/bold blue] command to capture the interaction between the processes and see them here.'
+                )
+            yield tips
 
     def on_mount(self):
         if not has_run():

rbx/box/ui/screens/run_test_explorer.py

@@ -13,7 +13,9 @@ from rbx.box.testcase_extractors import (
     GenerationTestcaseEntry,
     extract_generation_testcases,
 )
+from rbx.box.ui.screens.rich_log_modal import RichLogModal
 from rbx.box.ui.utils.run_ui import (
+    get_metadata_markup,
     get_run_testcase_markup,
     get_run_testcase_metadata_markup,
 )
@@ -30,6 +32,7 @@ class RunTestExplorerScreen(Screen):
         ('3', 'show_log', 'Show log'),
         ('m', 'toggle_metadata', 'Toggle metadata'),
         ('s', 'toggle_side_by_side', 'Toggle sxs'),
+        ('g', 'toggle_test_metadata', 'Toggle test metadata'),
     ]
 
     side_by_side: reactive[bool] = reactive(False)
@@ -62,6 +65,11 @@ class RunTestExplorerScreen(Screen):
                 yield TwoSidedTestBoxWidget(id='test-output')
 
     async def on_mount(self):
+        self.title = str(self.solution.path)
+
+        if self.diff_solution is not None:
+            self.title = f'{self.title} vs. {self.diff_solution.path}'
+
         self.query_one('#test-list').border_title = 'Tests'
         self.query_one('#test-input').border_title = 'Input'
 
@@ -164,3 +172,15 @@ class RunTestExplorerScreen(Screen):
             return
         widget = self.query_one('#test-output', TwoSidedTestBoxWidget)
         widget.diff_with_data = diff_with_data
+
+    def action_toggle_test_metadata(self):
+        list_view = self.query_one('#test-list', ListView)
+        if list_view.index is None:
+            return
+        entry = self._entries[list_view.index]
+        self.app.push_screen(
+            RichLogModal(
+                get_metadata_markup(entry),
+                title='Testcase metadata',
+            )
+        )

rbx/box/ui/screens/selector.py

@@ -1,6 +1,7 @@
 from typing import List, Optional
 
 from textual.app import ComposeResult
+from textual.containers import Container
 from textual.screen import ModalScreen
 from textual.widgets import ListItem, ListView
 
@@ -14,10 +15,11 @@ class SelectorScreen(ModalScreen[int]):
         self.title = title
 
     def compose(self) -> ComposeResult:
-        list_view = ListView(*self.options)
-        if self.title:
-            list_view.border_title = self.title
-        yield list_view
+        with Container(id='selector-dialog'):
+            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)

rbx/box/ui/screens/test_explorer.py

@@ -11,6 +11,7 @@ from rbx.box.testcase_extractors import (
     GenerationTestcaseEntry,
     extract_generation_testcases_from_groups,
 )
+from rbx.box.ui.utils.run_ui import get_metadata_markup
 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
@@ -78,19 +79,7 @@ class TestExplorerScreen(Screen):
         )
 
         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}'
-            )
+        metadata.write(get_metadata_markup(entry))
 
     async def _update_tests(self):
         self.watch(

rbx/box/ui/utils/run_ui.py

@@ -4,6 +4,7 @@ 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_extractors import GenerationTestcaseEntry
 from rbx.box.testcase_utils import TestcaseEntry
 from rbx.grading.steps import Evaluation
 
@@ -93,3 +94,15 @@ def get_run_testcase_metadata_markup(
     if checker_msg is not None:
         lines.append(f'[b]Checker:[/b] {checker_msg}')
     return '\n'.join(lines)
+
+
+def get_metadata_markup(entry: GenerationTestcaseEntry) -> str:
+    lines = []
+    lines.append(f'[b]{entry.group_entry.group}[/b] / [b]{entry.group_entry.index}[/b]')
+    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}')
+    if entry.metadata.generator_script is not None:
+        lines.append(f'[b]Gen. script:[/b] {entry.metadata.generator_script}')
+    return '\n'.join(lines)

rbx/box/ui/widgets/diff_box.py

@@ -0,0 +1,38 @@
+import difflib
+import pathlib
+from typing import Optional, Tuple
+
+from rich.markdown import Markdown
+from textual.app import ComposeResult
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import RichLog
+
+
+def compute_diff(file1: pathlib.Path, file2: pathlib.Path) -> str:
+    lines1 = file1.read_text().splitlines(keepends=True)
+    lines2 = file2.read_text().splitlines(keepends=True)
+    return ''.join(difflib.ndiff(lines1, lines2))
+
+
+class DiffBox(Widget, can_focus=False):
+    paths: reactive[Optional[Tuple[pathlib.Path, pathlib.Path]]] = reactive(None)
+
+    def __init__(self):
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        md = RichLog()
+        md.border_title = 'Differ'
+        yield md
+
+    async def watch_paths(self, paths: Optional[Tuple[pathlib.Path, pathlib.Path]]):
+        log = self.query_one(RichLog)
+        log.clear()
+        if paths is None:
+            return
+        file1, file2 = paths
+        md = Markdown(
+            f'```diff\n{compute_diff(file1, file2)}\n```', code_theme='monokai'
+        )
+        log.write(md)

rbx/box/unit.py

@@ -14,6 +14,7 @@ from rbx.box.schema import (
     ValidatorOutcome,
     ValidatorTest,
 )
+from rbx.grading.steps import Outcome
 from rbx.utils import StatusProgress
 
 
@@ -148,8 +149,6 @@ async def run_validator_unit_tests(progress: StatusProgress):
 
 async def run_checker_unit_tests(progress: StatusProgress):
     pkg = package.find_problem_package_or_die()
-    if not pkg.unitTests.checker:
-        return
 
     if not package.get_checker():
         console.console.print(
@@ -183,6 +182,39 @@ async def run_checker_unit_tests(progress: StatusProgress):
             skip_run_log=True,
         )
 
+        if test.answer is not None:
+            ans_result = await checkers.check(
+                compiled_digest,
+                run_log=None,
+                testcase=Testcase(
+                    inputPath=test.input or empty_file,
+                    outputPath=test.answer,
+                ),
+                program_output=test.answer,
+                skip_run_log=True,
+            )
+
+            if ans_result.outcome != Outcome.ACCEPTED:
+                console.console.print(
+                    f'[error]FAIL[/error] Unit test [item]#{i + 1}[/item] ({test.running_tests_formatted_string()})'
+                )
+                console.console.print(
+                    '[error]Error validating the [item].ans[/item] file.'
+                )
+                console.console.print(
+                    '[error]While checking your [item].ans[/item] against itself, the checker returned the following error:[/error]'
+                )
+                console.console.print(
+                    f'  [status]Verdict[/status] {ans_result.outcome.name}'
+                )
+                console.console.print(
+                    f'  [status]Message[/status] {ans_result.message}'
+                )
+                console.console.print(
+                    '[error]Please fix your [item].ans[/item] file and try again, or double-check that your checker is correct.[/error]'
+                )
+                continue
+
         markup = (
             '[success]OK[/success]'
             if test.outcome.match(result.outcome)