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

rbx/box/checkers.py

@@ -1,6 +1,6 @@
 import pathlib
 import signal
-from typing import Optional
+from typing import List, Optional
 
 import typer
 
@@ -53,6 +53,12 @@ def compile_interactor(progress: Optional[StatusProgress] = None) -> str:
     return digest
 
 
+def _any_failed(logs: List[Optional[RunLog]]) -> bool:
+    return any(
+        log is None or log.exitstatus == SandboxBase.EXIT_SANDBOX_ERROR for log in logs
+    )
+
+
 def _check_pre_output(run_log: Optional[RunLog]) -> CheckerResult:
     pkg = package.find_problem_package_or_die()
 
@@ -283,6 +289,10 @@ async def check_communication(
         # No relevant error was found.
         return None
 
+    # 0. If any of the sandboxes failed, we should return an error.
+    if _any_failed([run_log, interactor_run_log]):
+        return CheckerResult(outcome=Outcome.INTERNAL_ERROR)
+
     # 1. If the solution received SIGPIPE or was terminated, it means the
     # interactor exited before it. Thus, check the interactor, as it might have
     # returned a checker verdict.

rbx/box/cli.py

@@ -130,6 +130,14 @@ def ui():
     ui_pkg.start()
 
 
+@app.command('serve', hidden=True)
+def serve():
+    from textual_serve.server import Server
+
+    server = Server('rbx ui', port=8081)
+    server.serve()
+
+
 @app.command(
     'edit, e',
     rich_help_panel='Configuration',

rbx/box/contest/schema.py

@@ -1,7 +1,7 @@
 import pathlib
 from typing import Dict, List, Optional
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from rbx.box.schema import NameField, Primitive, expand_var
 from rbx.box.statements.schema import (
@@ -121,11 +121,60 @@ If not specified, will expect the problem to be in ./{short_name}/ folder.""",
 
     color: Optional[str] = Field(
         default=None,
-        description="""Hex-based color that represents this problem in the contest.""",
-        pattern=r'^[A-Za-z0-9]+$',
-        max_length=6,
+        description="""
+Color that represents this problem in the contest.
+
+Can be a hex color (#abcdef or #abc format), or a color name among available X11 colors.
+
+See https://en.wikipedia.org/wiki/X11_color_names for the list of supported color names.
+""",
     )
 
+    colorName: Optional[str] = Field(
+        default=None,
+        description="""
+A custom color name for the color provided by this problem.
+
+If not provided, will try to infer a color name from the color provided.
+""",
+        pattern=r'^[a-zA-Z]+$',
+    )
+
+    @model_validator(mode='after')
+    def check_color(self):
+        from colour import Color
+
+        if self.color is None:
+            return self
+
+        Color(self.color)
+        return self
+
+    @property
+    def hex_color(self) -> Optional[str]:
+        from colour import Color
+
+        if self.color is None:
+            return None
+
+        return Color(self.color).hex_l
+
+    @property
+    def color_name(self) -> Optional[str]:
+        if self.colorName is not None:
+            return self.colorName
+
+        if self.color is None:
+            return None
+
+        from colour import Color
+
+        color = Color(self.color)
+        web_color = color.web
+        if web_color.startswith('#'):
+            return 'unknown'
+        return web_color
+
     def get_path(self) -> pathlib.Path:
         return self.path or pathlib.Path(self.short_name)
 

rbx/box/naming.py

@@ -1,27 +1,42 @@
-from typing import Optional
+from typing import Optional, Tuple
 
 from rbx.box import package
 from rbx.box.contest import contest_package
+from rbx.box.contest.schema import ContestProblem
 
 
-def get_problem_shortname() -> Optional[str]:
+def get_problem_entry_in_contest() -> Optional[Tuple[int, ContestProblem]]:
     contest = contest_package.find_contest_package()
     if contest is None:
         return None
     problem_path = package.find_problem()
     contest_path = contest_package.find_contest()
 
-    for problem in contest.problems:
+    for i, problem in enumerate(contest.problems):
         if problem.path is None:
             continue
         if (problem_path / 'problem.rbx.yml').samefile(
             contest_path / problem.path / 'problem.rbx.yml'
         ):
-            return problem.short_name
-
+            return i, problem
     return None
 
 
+def get_problem_shortname() -> Optional[str]:
+    entry = get_problem_entry_in_contest()
+    if entry is None:
+        return None
+    _, problem = entry
+    return problem.short_name
+
+
+def get_problem_index() -> Optional[int]:
+    entry = get_problem_entry_in_contest()
+    if entry is None:
+        return None
+    return entry[0]
+
+
 def get_problem_name_with_contest_info() -> str:
     problem = package.find_problem_package_or_die()
     contest = contest_package.find_contest_package()

rbx/box/packaging/boca/upload.py

@@ -0,0 +1,247 @@
+import datetime
+import hashlib
+import os
+import pathlib
+import re
+import typing
+from typing import Any, NoReturn, Optional, Tuple
+
+import dateparser
+import mechanize
+import typer
+from bs4 import BeautifulSoup
+
+from rbx import console
+from rbx.box import naming
+
+ALERT_REGEX = re.compile(r'\<script[^\>]*\>\s*alert\(\'([^\']+)\'\);?\s*\<\/script\>')
+UPLOAD_LOG_REGEX = re.compile(r'Problem (\d+) \([^\)]+\) updated')
+
+
+def _parse_env_var(var: str, override: Optional[str]) -> str:
+    if override is not None:
+        return override
+    value = os.environ.get(var)
+    if value is None:
+        console.console.print(
+            f'[error][item]{var}[/item] is not set. Set it as an environment variable.[/error]'
+        )
+        raise typer.Exit(1)
+    return value
+
+
+class BocaUploader:
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+    ):
+        self.base_url = _parse_env_var('BOCA_BASE_URL', base_url)
+        self.username = _parse_env_var('BOCA_USERNAME', username)
+        self.password = _parse_env_var('BOCA_PASSWORD', password)
+
+        self.br = mechanize.Browser()
+        self.br.set_handle_robots(False)
+        self.br.addheaders = [  # type: ignore
+            (
+                'User-agent',
+                'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.1) Gecko/2008071615 Fedora/3.0.1-1.fc9 Firefox/3.0.1',
+            )
+        ]
+
+    def error(self, message: str) -> NoReturn:
+        console.console.print(
+            f'[error]{message} (at [item]{self.base_url}[/item])[/error]',
+        )
+        raise typer.Exit(1)
+
+    def raw_error(self, message: str) -> NoReturn:
+        console.console.print(f'[error]{message}[/error]')
+        raise typer.Exit(1)
+
+    def log_response_alert(self, response: Any, message: str) -> Tuple[Any, str]:
+        if response is None:
+            self.raw_error(
+                f'{message} ([item]{self.base_url}[/item]):\nNo response received.'
+            )
+        html = response.read().decode()
+        alert = ALERT_REGEX.search(html)
+        if alert:
+            self.raw_error(
+                f'{message} ([item]{self.base_url}[/item]):\n{alert.group(1)}'
+            )
+        return response, html
+
+    def check_logs_for_update(self, problem_id: int) -> bool:
+        _, html = self.open(
+            f'{self.base_url}/admin/log.php',
+            error_msg='Error while checking whether package upload was successful',
+        )
+
+        soup = BeautifulSoup(html, 'html.parser')
+        table = soup.select_one('table:nth-of-type(3)')
+        if table is None:
+            self.raw_error(
+                'Error while checking whether package upload was successful:\nNo logs table found.'
+            )
+        rows = table.select('tr:not(:first-child)')
+        for row in rows:
+            # Check whether the log line is recent.
+            date_cell = row.select('td:nth-of-type(5)')
+            if date_cell is None:
+                continue
+            date = date_cell[0].text.strip()
+
+            parsed_date = dateparser.parse(date)
+            if parsed_date is None:
+                console.console.print(
+                    f'Error while checking whether package upload was successful:\nCould not parse date [item]{date}[/item].'
+                )
+                raise typer.Exit(1)
+            if parsed_date < datetime.datetime.now(
+                datetime.timezone.utc
+            ) - datetime.timedelta(minutes=5):
+                continue
+
+            # Check if the log line contains the problem id.
+            log_cell = row.select('td:nth-of-type(6)')
+            if log_cell is None:
+                continue
+            log_line = log_cell[0].text.strip()
+            match = UPLOAD_LOG_REGEX.match(log_line)
+            if match is None:
+                continue
+            found_id = int(match.group(1))
+            if found_id == problem_id:
+                return True
+        return False
+
+    def check_submit(self, response: Any, problem_id: int) -> bool:
+        if response is None:
+            self.raw_error(
+                'Error while submitting problem to BOCA website:\nNo response received.'
+            )
+        html = response.read().decode()
+        alert = ALERT_REGEX.search(html)
+        if alert:
+            msg = alert.group(1)
+            if 'Violation' in msg:
+                return False
+            self.raw_error(
+                f'Error while submitting problem to BOCA website:\n{alert.group(1)}'
+            )
+        return self.check_logs_for_update(problem_id)
+
+    def open(self, url: str, error_msg: Optional[str] = None):
+        if error_msg is None:
+            error_msg = f'Error while opening [item]{url}[/item]'
+        response = self.br.open(url)
+        return self.log_response_alert(response, error_msg)
+
+    def login(self):
+        _, html = self.open(
+            f'{self.base_url}', error_msg='Error while opening BOCA login page'
+        )
+
+        needle = "js_myhash(document.form1.password.value)+'"
+        start = html.index(needle)
+        start_salt = start + len(needle)
+        end_salt = html.index("'", start_salt)
+        salt = html[start_salt:end_salt]
+        console.console.print(f'Using salt [item]{salt}[/item]')
+
+        pwd_hash = hashlib.sha256(self.password.encode()).hexdigest()
+        pwd_hash = hashlib.sha256((pwd_hash + salt).encode()).hexdigest()
+
+        login_url = f'{self.base_url}?name={self.username}&password={pwd_hash}'
+        self.open(login_url, error_msg='Error while logging in to BOCA')
+
+    def upload(self, file: pathlib.Path) -> bool:
+        self.open(
+            f'{self.base_url}/admin/problem.php',
+            error_msg='Error while opening BOCA problem upload page',
+        )
+        try:
+            form = self.br.select_form(name='form1')
+        except mechanize.FormNotFoundError:
+            self.error(
+                'Problem upload form not found in BOCA website. This might happen when the login failed.'
+            )
+
+        form = typing.cast(mechanize.HTMLForm, self.br.form)
+        form.set_all_readonly(False)
+
+        problem_index = naming.get_problem_index()
+        if problem_index is None:
+            console.console.print(
+                'It seems this problem is not part of a contest. Cannot upload it to BOCA.'
+            )
+            raise typer.Exit(1)
+
+        problem_shortname = naming.get_problem_shortname()
+        assert problem_shortname is not None
+        entry = naming.get_problem_entry_in_contest()
+        assert entry is not None
+        _, problem_entry = entry
+
+        hex_color = problem_entry.hex_color
+        if hex_color is None:
+            form['colorname'] = 'black'
+            form['color'] = '000000'
+        else:
+            assert problem_entry.color_name is not None
+            form['colorname'] = problem_entry.color_name.lower()
+            form['color'] = hex_color[1:]
+
+        form['problemnumber'] = f'{problem_index + 1}'
+        form['problemname'] = problem_shortname
+        form['confirmation'] = 'confirm'
+        form['autojudge_new_sel'] = ['all']
+        form['Submit3'] = 'Send'
+
+        with file.open('rb') as f:
+            form.add_file(
+                f,
+                filename=file.name,
+                name='probleminput',
+                content_type='application/zip',
+            )
+            response = self.br.submit()
+
+        return self.check_submit(response, problem_index + 1)
+
+    def login_and_upload(self, file: pathlib.Path):
+        RETRIES = 3
+
+        tries = 0
+        ok = False
+        while tries < RETRIES:
+            tries += 1
+
+            console.console.print('Logging in to BOCA...')
+            self.login()
+            console.console.print('Uploading problem to BOCA...')
+            if not self.upload(file):
+                console.console.print(
+                    f'[warning]Potentially transient error while uploading problem to BOCA. Retrying ({tries}/{RETRIES})...[/warning]'
+                )
+                continue
+
+            ok = True
+            console.console.print(
+                '[success]Problem sent to BOCA. [item]rbx[/item] cannot determine the upload succeeded, check the website to be sure.[/success]'
+            )
+            break
+
+        if not ok:
+            console.console.print(
+                '[error]Persistent error while uploading problem to BOCA website.[/error]'
+            )
+            console.console.print(
+                '[warning]This might be caused by PHP max upload size limit (which usually defaults to 2MBF).[/warning]'
+            )
+            console.console.print(
+                '[warning]Check [item]https://www.php.net/manual/en/ini.core.php#ini.sect.file-uploads[/item] for more information.[/warning]'
+            )
+            raise typer.Exit(1)

rbx/box/packaging/main.py

@@ -93,10 +93,22 @@ async def polygon(
 @syncer.sync
 async def boca(
     verification: environment.VerificationParam,
+    upload: bool = typer.Option(
+        False,
+        '--upload',
+        '-u',
+        help='If set, will upload the package to BOCA.',
+    ),
 ):
     from rbx.box.packaging.boca.packager import BocaPackager
 
-    await run_packager(BocaPackager, verification=verification)
+    result_path = await run_packager(BocaPackager, verification=verification)
+
+    if upload:
+        from rbx.box.packaging.boca.upload import BocaUploader
+
+        uploader = BocaUploader('http://137.184.1.39/boca', 'admin', 'boca')
+        uploader.login_and_upload(result_path)
 
 
 @app.command('moj', help='Build a package for MOJ.')

rbx/box/solutions.py

@@ -77,6 +77,7 @@ class GroupSkeleton(BaseModel):
 
 class SolutionReportSkeleton(BaseModel):
     solutions: List[Solution]
+    entries: List[TestcaseEntry]
     groups: List[GroupSkeleton]
     limits: Dict[str, Limits]
 
@@ -245,10 +246,16 @@ def _get_report_skeleton(
     for group in pkg.testcases:
         testcases = find_built_testcases(group)
         groups.append(GroupSkeleton(name=group.name, testcases=testcases))
+    entries = [
+        TestcaseEntry(group=group.name, index=i)
+        for group in groups
+        for i in range(len(group.testcases))
+    ]
     return SolutionReportSkeleton(
         solutions=solutions,
         groups=groups,
         limits=limits,
+        entries=entries,
     )
 
 
@@ -349,7 +356,7 @@ def run_solutions(
     timelimit_override: Optional[int] = None,
     sanitized: bool = False,
 ) -> RunSolutionResult:
-    return RunSolutionResult(
+    result = RunSolutionResult(
         skeleton=_get_report_skeleton(
             tracked_solutions,
             verification=verification,
@@ -364,6 +371,10 @@ def run_solutions(
             sanitized=sanitized,
         ),
     )
+    skeleton_file = package.get_problem_runs_dir() / 'skeleton.yml'
+    skeleton_file.parent.mkdir(parents=True, exist_ok=True)
+    skeleton_file.write_text(utils.model_to_yaml(result.skeleton))
+    return result
 
 
 async def _generate_testcase_interactively(

rbx/box/tasks.py

@@ -272,11 +272,13 @@ async def _run_communication_solution_on_testcase(
 
         log_path.write_text(model_to_yaml(eval))
 
+        interactor_log_path = output_path.with_suffix('.int.log')
+        interactor_log_path.unlink(missing_ok=True)
         if interactor_run_log is not None:
-            interactor_log_path = output_path.with_suffix('.int.log')
             interactor_log_path.write_text(model_to_yaml(interactor_run_log))
+        solution_log_path = output_path.with_suffix('.sol.log')
+        solution_log_path.unlink(missing_ok=True)
         if run_log is not None:
-            solution_log_path = output_path.with_suffix('.sol.log')
             solution_log_path.write_text(model_to_yaml(run_log))
         return eval
 

rbx/box/testcase_extractors.py

@@ -96,6 +96,9 @@ class GeneratorScriptEntry(BaseModel):
     path: pathlib.Path
     line: int
 
+    def __str__(self) -> str:
+        return f'{self.path}:{self.line}'
+
 
 class GenerationMetadata(BaseModel):
     copied_to: Testcase

rbx/box/ui/captured_log.py

@@ -18,8 +18,6 @@ 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
@@ -95,6 +93,13 @@ class LogDisplay(ScrollView, can_focus=True):
         self.send_queue = asyncio.Queue()
         self.exitcode = None
 
+    def _resize(self):
+        self.virtual_size = Size(
+            width=self.size.width - 2,  # Account for scroll bar.
+            height=self.virtual_size.height,
+        )
+        self._screen.resize(self._max_lines, self.virtual_size.width)
+
     async def on_resize(self, _event: events.Resize):
         if self.emulator is None:
             return
@@ -161,6 +166,9 @@ class LogDisplay(ScrollView, can_focus=True):
             cb()
         self.recv_task.cancel()
 
+    def on_unmount(self):
+        self.disconnect()
+
     async def recv(self):
         while True:
             msg = await self.recv_queue.get()
@@ -270,12 +278,7 @@ class LogDisplay(ScrollView, can_focus=True):
     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()
+        return self.app.current_theme.to_color_system().generate()
 
     def render_line(self, y: int) -> Strip:
         scroll_x, scroll_y = self.scroll_offset
@@ -312,6 +315,8 @@ class LogDisplay(ScrollView, can_focus=True):
         pout = os.fdopen(fd, 'w+b', 0)
         data: Optional[str] = None
 
+        self._resize()
+
         def on_output():
             nonlocal data
             try:

rbx/box/ui/css/app.tcss

@@ -7,18 +7,42 @@ Screen {
         align: center middle;
 }
 
+ListView {
+        border: solid $accent 100%;
+        padding: 0 1;
+        background: transparent;
+}
+
 SelectionList {
         border-title-color: $accent;
 }
 
+OptionList {
+        border: solid $accent;
+}
+
 Button {
         width: 1fr;
         background: $accent;
+        color: $secondary;
 }
 
 #report-grid {
         layout: grid;
-        grid-size: 2 2;
+        grid-size: 2;
+}
+
+RunScreen {
+        align: center middle;
+        #run-settings {
+                border: thick $background 40%;
+        }
+}
+
+LogDisplay {
+        width: 1fr;
+        padding: 0 1;
+        border: solid $accent;
 }
 
 DataTable {
@@ -27,7 +51,7 @@ DataTable {
 
 DataTable > .datatable--cursor {
         color: $text;
-        background: $accent;
+        background-tint: $accent 10%;
 }
 
 DataTable:blur > .datatable--cursor {
@@ -35,14 +59,29 @@ DataTable:blur > .datatable--cursor {
         background: transparent;
 }
 
-RunScreen {
-        align: center middle;
-        #run-settings {
-                border: thick $background 40%;
+FileLog > Log {
+        background: transparent;
+}
+
+TestExplorerScreen {
+        #test-metadata {
+                min-height: 3;
+                height: auto;
+        }
+        #test-list-container {
+                min-width: 20;
+                max-width: 40;
+                height: 1fr;
         }
-        LogDisplay {
+        #test-list {
                 width: 1fr;
+        }
+        FileLog {
+                border: solid $accent;
                 padding: 0 1;
+        }
+        RichLog {
                 border: solid $accent;
+                padding: 0 1;
         }
-}
+}

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'])