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

rbx/box/checkers.py

@@ -91,8 +91,10 @@ def _check_pre_output(run_log: Optional[RunLog]) -> CheckerResult:
 
     if run_log.exitstatus in [SandboxBase.EXIT_SIGNAL, SandboxBase.EXIT_NONZERO_RETURN]:
         return CheckerResult(outcome=Outcome.RUNTIME_ERROR)
-    if run_log.exitstatus in [SandboxBase.EXIT_TIMEOUT, SandboxBase.EXIT_TIMEOUT_WALL]:
+    if run_log.exitstatus == SandboxBase.EXIT_TIMEOUT:
         return CheckerResult(outcome=Outcome.TIME_LIMIT_EXCEEDED)
+    if run_log.exitstatus == SandboxBase.EXIT_TIMEOUT_WALL:
+        return CheckerResult(outcome=Outcome.IDLENESS_LIMIT_EXCEEDED)
     if run_log.exitstatus == SandboxBase.EXIT_MEMORY_LIMIT_EXCEEDED:
         return CheckerResult(outcome=Outcome.MEMORY_LIMIT_EXCEEDED)
     if run_log.exitstatus == SandboxBase.EXIT_SANDBOX_ERROR:
@@ -103,7 +105,7 @@ def _check_pre_output(run_log: Optional[RunLog]) -> CheckerResult:
 
 
 def _convert_tle(result: CheckerResult, run_log: Optional[RunLog]) -> CheckerResult:
-    if result.outcome == Outcome.TIME_LIMIT_EXCEEDED:
+    if result.outcome.is_slow():
         # This already is a TLE outcome.
         return result
     is_sanitized = (

rbx/box/cli.py

@@ -32,7 +32,6 @@ from rbx.box.packaging import main as packaging
 from rbx.box.schema import CodeItem, ExpectedOutcome, TestcaseGroup
 from rbx.box.solutions import (
     estimate_time_limit,
-    expand_solutions,
     get_exact_matching_solutions,
     get_matching_solutions,
     pick_solutions,
@@ -137,6 +136,13 @@ def ui():
     ui_pkg.start()
 
 
+@app.command('diff', hidden=True)
+def diff(path1: pathlib.Path, path2: pathlib.Path):
+    from rbx.box.ui import main as ui_pkg
+
+    ui_pkg.start_differ(path1, path2)
+
+
 @app.command('serve', hidden=True)
 def serve():
     from textual_serve.server import Server
@@ -243,7 +249,7 @@ async def run(
         tracked_solutions = set(
             await pick_solutions(
                 tracked_solutions,
-                extra_solutions=await expand_solutions(solutions or []),
+                extra_solutions=solutions,
             )
         )
         if not tracked_solutions:
@@ -479,7 +485,7 @@ async def irun(
         tracked_solutions = set(
             await pick_solutions(
                 tracked_solutions,
-                extra_solutions=await expand_solutions(solutions or []),
+                extra_solutions=solutions,
             )
         )
         if not tracked_solutions:
@@ -546,18 +552,17 @@ def create(
 @syncer.sync
 async def stress(
     name: Annotated[
-        str,
+        Optional[str],
         typer.Argument(
-            help='Name of the stress test to run (specified in problem.rbx.yml), '
-            'or the generator to run, in case -g is specified.'
+            help='Name of the stress test to run (specified in problem.rbx.yml).'
         ),
-    ],
+    ] = None,
     generator_args: Annotated[
         Optional[str],
         typer.Option(
             '--generator',
             '-g',
-            help='Run generator [name] with these args.',
+            help='Generator call to use to generate a single test for execution.',
         ),
     ] = None,
     finder: Annotated[
@@ -604,9 +609,9 @@ async def stress(
 
     with utils.StatusProgress('Running stress...') as s:
         report = await stresses.run_stress(
-            name,
             timeout,
-            args=generator_args,
+            name=name,
+            generator_call=generator_args,
             finder=finder,
             findingsLimit=findings,
             progress=s,

rbx/box/compile.py

@@ -3,7 +3,7 @@ import pathlib
 import typer
 
 from rbx import annotations, console
-from rbx.box import code, package
+from rbx.box import code, package, remote
 from rbx.box.code import SanitizationLevel
 from rbx.box.sanitizers import warning_stack
 from rbx.box.schema import CodeItem
@@ -35,6 +35,8 @@ def _compile(item: CodeItem, sanitized: SanitizationLevel, warnings: bool):
 def any(path: str, sanitized: bool = False, warnings: bool = False):
     pkg = package.find_problem_package_or_die()
 
+    path = str(remote.expand_file(path))
+
     solution = package.get_solution_or_nil(path)
     if solution is not None:
         _compile(

rbx/box/formatting.py

@@ -1,10 +1,14 @@
 import os
 import pathlib
-from typing import Optional
+from typing import Any, Optional
 
 from rbx.box import setter_config
 
 
+def ref(text: Any) -> str:
+    return f'[item]{text}[/item]'
+
+
 def href(url: os.PathLike[str], text: Optional[str] = None, style: str = 'item') -> str:
     custom_text = False
     if text is None:

rbx/box/generators.py

@@ -110,7 +110,10 @@ def get_all_built_testcases() -> Dict[str, List[Testcase]]:
 
 
 def get_call_from_string(call_str: str) -> GeneratorCall:
-    name, args = call_str.split(None, 1)
+    try:
+        name, args = call_str.split(None, 1)
+    except ValueError:
+        return GeneratorCall(name=call_str, args='')
     return GeneratorCall(name=name, args=args)
 
 
@@ -317,10 +320,7 @@ async def generate_output_for_testcase(
         capture_pipes=True,
     )
 
-    if (
-        eval.result.outcome == Outcome.TIME_LIMIT_EXCEEDED
-        and eval.result.no_tle_outcome == Outcome.ACCEPTED
-    ):
+    if eval.result.outcome.is_slow() and eval.result.no_tle_outcome == Outcome.ACCEPTED:
         console.console.print(
             f'[warning]Testcase [item]{testcase.inputPath}[/item] finished in TLE, but test was generated successfully.[/warning]'
         )

rbx/box/package.py

@@ -21,6 +21,7 @@ from rbx.box.schema import (
     Package,
     Solution,
     Stress,
+    TaskType,
     TestcaseGroup,
     TestcaseSubgroup,
 )
@@ -32,6 +33,7 @@ from rbx.grading.judge.storage import FilesystemStorage, Storage
 
 YAML_NAME = 'problem.rbx.yml'
 _DEFAULT_CHECKER = 'wcmp.cpp'
+_NOOP_CHECKER = 'noop.cpp'
 TEMP_DIR = None
 CACHE_STEP_VERSION = 1
 
@@ -150,6 +152,19 @@ def get_problem_cache_dir(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
     return cache_dir
 
 
+@functools.cache
+def get_problem_remote_dir(
+    platform: Optional[str] = None, root: pathlib.Path = pathlib.Path()
+) -> pathlib.Path:
+    remote_dir = get_problem_cache_dir(root) / '.remote'
+    remote_dir.mkdir(parents=True, exist_ok=True)
+
+    if platform is not None:
+        remote_dir = remote_dir / platform
+        remote_dir.mkdir(parents=True, exist_ok=True)
+    return remote_dir
+
+
 @functools.cache
 def get_problem_storage_dir(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
     storage_dir = get_problem_cache_dir(root) / '.storage'
@@ -277,13 +292,19 @@ def get_validator_or_nil(root: pathlib.Path = pathlib.Path()) -> Optional[CodeIt
     return package.validator
 
 
+@functools.cache
+def get_default_checker(root: pathlib.Path = pathlib.Path()) -> CodeItem:
+    package = find_problem_package_or_die(root)
+    if package.type == TaskType.COMMUNICATION:
+        return CodeItem(path=get_builtin_checker(_NOOP_CHECKER).absolute())
+    return CodeItem(path=get_builtin_checker(_DEFAULT_CHECKER).absolute())
+
+
 @functools.cache
 def get_checker(root: pathlib.Path = pathlib.Path()) -> CodeItem:
     package = find_problem_package_or_die(root)
 
-    return package.checker or CodeItem(
-        path=get_builtin_checker(_DEFAULT_CHECKER).absolute()
-    )
+    return package.checker or get_default_checker(root)
 
 
 @functools.cache

rbx/box/packaging/boca/upload.py

@@ -4,6 +4,7 @@ import hashlib
 import os
 import pathlib
 import re
+import shutil
 import typing
 from typing import Any, NoReturn, Optional, Tuple
 
@@ -248,13 +249,51 @@ class BocaUploader:
                 '[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]'
+                '[warning]This might be caused by PHP max upload size limit (which usually defaults to 2MB).[/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)
 
+    def download_run(self, run_number: int, site_number: int, into_dir: pathlib.Path):
+        url = f'{self.base_url}/admin/runedit.php?runnumber={run_number}&runsitenumber={site_number}'
+        _, html = self.open(
+            url,
+            error_msg=f'Error while downloading BOCA run [item]{run_number}-{site_number}[/item]',
+        )
+
+        soup = BeautifulSoup(html, 'html.parser')
+        rows = soup.select('tr')
+
+        href: Optional[str] = None
+        filename: Optional[pathlib.Path] = None
+
+        for row in rows:
+            row_text = row.select('td')[0].text.strip().lower()
+            if row_text != "team's code:":
+                continue
+            link_col = row.select_one('td:nth-of-type(2) a:nth-of-type(1)')
+            if link_col is None:
+                continue
+            href = str(link_col.attrs['href'])
+            filename = pathlib.Path(link_col.text.strip())
+            break
+
+        if href is None or filename is None:
+            self.raw_error(
+                "Error while downloading run:\nNo link to team's code found."
+            )
+
+        link = self.br.find_link(url=href)
+        tmp_file, _ = self.br.retrieve(link.absolute_url)
+        if tmp_file is None:
+            self.raw_error('Error while downloading run:\nDownloaded file is None.')
+        final_path = into_dir / filename.with_stem(f'{run_number}-{site_number}')
+        final_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.move(tmp_file, final_path)
+        return final_path
+
 
 @functools.lru_cache
 def get_boca_uploader(

rbx/box/presets/__init__.py

@@ -3,7 +3,6 @@ import shutil
 import tempfile
 from typing import Annotated, Iterable, List, Optional, Sequence, Union
 
-import questionary
 import rich
 import rich.prompt
 import typer
@@ -498,6 +497,8 @@ def copy_local_preset(
     if preset_remote_uri is None:
         return
 
+    import questionary
+
     add_submodule = questionary.confirm(
         'The preset is installed from a remote Git repository. Do you want to add it as a submodule of your project?',
         default=False,

rbx/box/remote.py

@@ -0,0 +1,151 @@
+import pathlib
+import re
+from abc import ABC, abstractmethod
+from typing import List, Optional, Tuple, Union
+
+import typer
+
+from rbx import console
+from rbx.box import cd, package
+from rbx.box.formatting import href, ref
+
+PathLike = Union[str, pathlib.Path]
+
+
+class Expander(ABC):
+    def get_remote_path(self, path: pathlib.Path) -> pathlib.Path:
+        return package.get_problem_remote_dir() / path
+
+    def cacheable_paths(self, path: pathlib.Path) -> List[pathlib.Path]:
+        return []
+
+    def cacheable_globs(self, path: pathlib.Path) -> List[str]:
+        return []
+
+    @abstractmethod
+    def expand(self, path: pathlib.Path) -> Optional[pathlib.Path]:
+        pass
+
+
+class BocaExpander(Expander):
+    BOCA_REGEX = re.compile(r'\@boca\/(\d+)(?:\-(\d+))?')
+
+    def get_match(self, path_str: str) -> Optional[Tuple[int, int]]:
+        match = self.BOCA_REGEX.match(path_str)
+        if match is None:
+            return None
+        run_number = int(match.group(1))
+        site_number = int(match.group(2)) if match.group(2) is not None else 1
+        return run_number, site_number
+
+    def get_boca_folder(self) -> pathlib.Path:
+        return self.get_remote_path(pathlib.Path('boca'))
+
+    def get_boca_path(self, run_number: int, site_number: int) -> pathlib.Path:
+        return self.get_boca_folder() / f'{run_number}-{site_number}'
+
+    def cacheable_globs(self, path: pathlib.Path) -> List[str]:
+        match = self.get_match(str(path))
+        if match is None:
+            return []
+        run_number, site_number = match
+        return [str(self.get_boca_path(run_number, site_number)) + '.*']
+
+    def expand(self, path: pathlib.Path) -> Optional[pathlib.Path]:
+        from rbx.box.packaging.boca import upload as boca_upload
+
+        match = self.get_match(str(path))
+        if match is None:
+            return None
+        run_number, site_number = match
+
+        boca_uploader = boca_upload.get_boca_uploader()
+        boca_uploader.login()
+        sol_path = boca_uploader.download_run(
+            run_number, site_number, self.get_boca_folder()
+        )
+        console.console.print(f'Downloaded {href(sol_path)} from BOCA...')
+        return sol_path
+
+
+REGISTERED_EXPANDERS: List['Expander'] = [
+    BocaExpander(),
+]
+
+
+def _relative_to_pkg(path: pathlib.Path) -> pathlib.Path:
+    return path.resolve().relative_to(pathlib.Path.cwd())
+
+
+def _try_cacheable_paths(
+    path: pathlib.Path, expander: Expander
+) -> Optional[pathlib.Path]:
+    cached_paths = expander.cacheable_paths(path)
+    for cached_path in cached_paths:
+        if cached_path.exists():
+            return _relative_to_pkg(cached_path)
+    return None
+
+
+def _try_cacheable_globs(
+    path: pathlib.Path, expander: Expander
+) -> Optional[pathlib.Path]:
+    cached_globs = expander.cacheable_globs(path)
+    for cached_glob in cached_globs:
+        rel_glob = _relative_to_pkg(pathlib.Path(cached_glob))
+        globbed = list(pathlib.Path.cwd().glob(str(rel_glob)))
+        if not globbed:
+            continue
+        return _relative_to_pkg(globbed[0])
+    return None
+
+
+def _try_cache(path: pathlib.Path, expander: Expander) -> Optional[pathlib.Path]:
+    cached = _try_cacheable_paths(path, expander)
+    if cached is not None:
+        return cached
+    return _try_cacheable_globs(path, expander)
+
+
+def _expand_path(path: pathlib.Path) -> Optional[pathlib.Path]:
+    if not cd.is_problem_package():
+        console.console.print(
+            f'Skipping expansion of {ref(path)} because we are not in a problem package.'
+        )
+        raise typer.Exit(1)
+
+    for expander in REGISTERED_EXPANDERS:
+        cached = _try_cache(path, expander)
+        if cached is not None:
+            return cached
+        expanded = expander.expand(path)
+        if expanded is not None:
+            return _relative_to_pkg(expanded)
+    return None
+
+
+def _expand_paths(paths: List[pathlib.Path]) -> List[pathlib.Path]:
+    res = []
+    for path in paths:
+        if not str(path).startswith('@'):
+            res.append(path)
+            continue
+        expanded = _expand_path(path)
+        if expanded is None:
+            continue
+        res.append(expanded)
+    return res
+
+
+def expand_files(files: List[str]) -> List[pathlib.Path]:
+    return _expand_paths([pathlib.Path(file) for file in files])
+
+
+def expand_file(file: str) -> pathlib.Path:
+    res = expand_files([file])
+    if len(res) != 1:
+        console.console.print(
+            f'Could not expand {ref(file)} because it is not a valid expansion.'
+        )
+        raise typer.Exit(1)
+    return res[0]

rbx/box/retries.py

@@ -18,10 +18,7 @@ def _both_accepted(eval_a: Evaluation, eval_b: Evaluation) -> bool:
 
 
 def _any_tle(eval_a: Evaluation, eval_b: Evaluation) -> bool:
-    return (
-        eval_a.result.outcome == Outcome.TIME_LIMIT_EXCEEDED
-        or eval_b.result.outcome == Outcome.TIME_LIMIT_EXCEEDED
-    )
+    return eval_a.result.outcome.is_slow() or eval_b.result.outcome.is_slow()
 
 
 def _get_faster(eval_a: Evaluation, eval_b: Evaluation) -> Evaluation:
@@ -130,13 +127,10 @@ class Retrier:
 
     def should_repeat(self, eval: Evaluation) -> bool:
         if self.is_stress:
-            if (
-                eval.result.outcome == Outcome.TIME_LIMIT_EXCEEDED
-                and self.retries_for_stress > 0
-            ):
+            if eval.result.outcome.is_slow() and self.retries_for_stress > 0:
                 self.retries_for_stress -= 1
                 return True
-        if eval.result.outcome == Outcome.TIME_LIMIT_EXCEEDED and self.retries > 0:
+        if eval.result.outcome.is_slow() and self.retries > 0:
             self.retries -= 1
             return True
         if self.reps > 0:

rbx/box/schema.py

@@ -57,6 +57,9 @@ def expand_var(value: Primitive) -> Primitive:
 
 
 class ExpectedOutcome(AutoEnum):
+    ANY = alias('any')  # type: ignore
+    """Expected outcome for any outcome."""
+
     ACCEPTED = alias('accepted', 'ac', 'correct')  # type: ignore
     """Expected outcome for correct solutions (AC)."""
 
@@ -97,6 +100,8 @@ class ExpectedOutcome(AutoEnum):
     Especially useful for environments where TLE and RTE are indistinguishable."""
 
     def style(self) -> str:
+        if self == ExpectedOutcome.ANY:
+            return 'orange'
         if self == ExpectedOutcome.ACCEPTED:
             return 'green'
         if self == ExpectedOutcome.WRONG_ANSWER:
@@ -114,29 +119,39 @@ class ExpectedOutcome(AutoEnum):
     def is_slow(self) -> bool:
         return self in [ExpectedOutcome.TIME_LIMIT_EXCEEDED, ExpectedOutcome.TLE_OR_RTE]
 
+    def matches_tle_and_is_incorrect(self) -> bool:
+        return self.match(Outcome.TIME_LIMIT_EXCEEDED) and not self.match(
+            Outcome.ACCEPTED
+        )
+
     def match(self, outcome: Outcome) -> bool:
+        if self == ExpectedOutcome.ANY:
+            return True
         if self == ExpectedOutcome.ACCEPTED:
             return outcome == Outcome.ACCEPTED
         if self == ExpectedOutcome.ACCEPTED_OR_TLE:
-            return outcome in {Outcome.ACCEPTED, Outcome.TIME_LIMIT_EXCEEDED}
+            return outcome in {Outcome.ACCEPTED} or outcome.is_slow()
         if self == ExpectedOutcome.WRONG_ANSWER:
             return outcome == Outcome.WRONG_ANSWER
         if self == ExpectedOutcome.INCORRECT:
-            return outcome in {
-                Outcome.WRONG_ANSWER,
-                Outcome.RUNTIME_ERROR,
-                Outcome.MEMORY_LIMIT_EXCEEDED,
-                Outcome.TIME_LIMIT_EXCEEDED,
-                Outcome.OUTPUT_LIMIT_EXCEEDED,
-            }
+            return (
+                outcome
+                in {
+                    Outcome.WRONG_ANSWER,
+                    Outcome.RUNTIME_ERROR,
+                    Outcome.MEMORY_LIMIT_EXCEEDED,
+                    Outcome.OUTPUT_LIMIT_EXCEEDED,
+                }
+                or outcome.is_slow()
+            )
         if self == ExpectedOutcome.RUNTIME_ERROR:
             return outcome == Outcome.RUNTIME_ERROR
         if self == ExpectedOutcome.TIME_LIMIT_EXCEEDED:
-            return outcome == Outcome.TIME_LIMIT_EXCEEDED
+            return outcome.is_slow()
         if self == ExpectedOutcome.MEMORY_LIMIT_EXCEEDED:
             return outcome == Outcome.MEMORY_LIMIT_EXCEEDED
         if self == ExpectedOutcome.TLE_OR_RTE:
-            return outcome in {Outcome.TIME_LIMIT_EXCEEDED, Outcome.RUNTIME_ERROR}
+            return outcome in {Outcome.RUNTIME_ERROR} or outcome.is_slow()
         if self == ExpectedOutcome.OUTPUT_LIMIT_EXCEEDED:
             return outcome == Outcome.OUTPUT_LIMIT_EXCEEDED
         return False