rbx.cp 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

rbx/box/presets/lock_schema.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import List
 
 from pydantic import BaseModel
 
@@ -11,7 +11,6 @@ class LockedAsset(TrackedAsset):
 
 class PresetLock(BaseModel):
     name: str
-    uri: Optional[str] = None
 
     @property
     def preset_name(self) -> str:

rbx/box/presets/schema.py

@@ -1,8 +1,10 @@
 import pathlib
 from typing import List, Optional
 
+import typer
 from pydantic import BaseModel, Field
 
+from rbx import console
 from rbx.box.presets.fetch import PresetFetchInfo, get_preset_fetch_info
 
 
@@ -32,8 +34,9 @@ class Preset(BaseModel):
     # Name of the preset, or a GitHub repository containing it.
     name: str = NameField()
 
-    # URI of the preset to be fetched.
-    uri: Optional[str] = None
+    # URI of the preset to be fetched. Uniquely identifies the preset.
+    # Should usually be a GitHub repository.
+    uri: str
 
     # Path to the environment file that will be installed with this preset.
     # When copied to the box environment, the environment will be named `name`.
@@ -52,8 +55,13 @@ class Preset(BaseModel):
 
     @property
     def fetch_info(self) -> PresetFetchInfo:
-        if self.uri is None:
-            return PresetFetchInfo(name=self.name)
         res = get_preset_fetch_info(self.uri)
-        assert res is not None
+        if res is None:
+            console.console.print(
+                f'[error]Preset URI [item]{self.uri}[/item] is not valid.[/error]'
+            )
+            console.console.print(
+                '[error]Please check that the URI is correct and that the directory/asset really exists.[/error]'
+            )
+            raise typer.Exit(1)
         return res

rbx/box/retries.py

@@ -90,6 +90,14 @@ def _move_logs_to_temp_dir(
     return recover
 
 
+def get_retrier_config(nruns: int = 0) -> RepeatsConfig:
+    if nruns == 0:
+        return get_setter_config().repeats
+    repeats = get_setter_config().repeats.model_copy(deep=True)
+    repeats.reps = nruns
+    return repeats
+
+
 class Retrier:
     def __init__(self, config: Optional[RepeatsConfig] = None, is_stress: bool = False):
         self.config = config or get_setter_config().repeats

rbx/box/schema.py

@@ -233,6 +233,17 @@ Testlib and jngen are already included by default.
     )
 
 
+class Interactor(CodeItem):
+    model_config = ConfigDict(extra='forbid')
+
+    legacy: bool = Field(
+        default=False,
+        description="""
+Whether this interactor is a legacy interactor and needs a checker to be specified.
+""",
+    )
+
+
 class Testcase(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
@@ -458,7 +469,7 @@ class Package(BaseModel):
         default=None, description='The checker for this problem.'
     )
 
-    interactor: Optional[CodeItem] = Field(
+    interactor: Optional[Interactor] = Field(
         default=None, description='The interactor for this problem.'
     )
 
@@ -569,7 +580,9 @@ that is correct and used as reference -- and should have the `accepted` outcome.
                     'Interactor is not allowed for batch problems. Change the task type to COMMUNICATION.',
                 )
         if self.type == TaskType.COMMUNICATION:
-            if self.checker is not None:
+            if self.checker is not None and (
+                self.interactor is None or not self.interactor.legacy
+            ):
                 raise PydanticCustomError(
                     'CHECKER_NOT_ALLOWED',
                     'Checkers should not be specified for communication problems.',

rbx/box/solutions.py

@@ -192,6 +192,7 @@ def _run_solution(
     progress: Optional[StatusProgress] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
     timelimit_override: Optional[int] = None,
+    nruns: int = 0,
 ) -> List[Deferred[Evaluation]]:
     group = package.get_testgroup(group_name)
     testcases = find_built_testcases(group)
@@ -217,6 +218,7 @@ def _run_solution(
                 testcase_index=i,
                 verification=verification,
                 timelimit_override=timelimit_override,
+                nruns=nruns,
             )
 
         res.append(Deferred(run_fn))
@@ -315,6 +317,7 @@ def _produce_solution_items(
     check: bool = True,
     timelimit_override: Optional[int] = None,
     sanitized: bool = False,
+    nruns: int = 0,
 ) -> List[EvaluationItem]:
     pkg = package.find_problem_package_or_die()
 
@@ -348,6 +351,7 @@ def _produce_solution_items(
                 progress=progress,
                 verification=verification,
                 timelimit_override=timelimit_override,
+                nruns=nruns,
             )
         ):
             res.append(
@@ -394,6 +398,7 @@ def run_solutions(
     check: bool = True,
     timelimit_override: Optional[int] = None,
     sanitized: bool = False,
+    nruns: int = 0,
 ) -> RunSolutionResult:
     skeleton = _get_report_skeleton(
         tracked_solutions,
@@ -409,6 +414,7 @@ def run_solutions(
             check=check,
             timelimit_override=timelimit_override,
             sanitized=sanitized,
+            nruns=nruns,
         ),
     )
     return result
@@ -684,7 +690,7 @@ async def run_and_print_interactive_solutions(
             console.console.print(get_testcase_markup_verdict(eval), end=' ')
             _print_solution_header(sol, console.console)
             _print_solution_outcome(
-                sol, [eval], console.console, verification, subset=True
+                sol, skeleton, [eval], console.console, verification, subset=True
             )
 
         stdout_path = eval.log.stdout_absolute_path
@@ -912,6 +918,7 @@ class SolutionOutcomeReport(BaseModel):
     solution: Solution
     evals: List[Evaluation]
     ok: bool
+    message: Optional[Tuple[TestcaseEntry, str]]
     expectedOutcome: Optional[ExpectedOutcome]
     gotVerdicts: Set[Outcome]
     runUnderDoubleTl: bool
@@ -949,15 +956,22 @@ class SolutionOutcomeReport(BaseModel):
             res += '\n[bold yellow]WARNING[/bold yellow] The solution had sanitizer errors or warnings, marked with [bold yellow]*[/bold yellow]. See their stderr for more details.'
         return res
 
-    def get_outcome_markup(self) -> str:
+    def get_outcome_markup(self, print_message: bool = True) -> str:
         res = self.get_verdict_markup_with_warnings()
         res += f'\nTime: {get_capped_evals_formatted_time(self.solution, self.evals, self.verification)}'
         res += f'\nMemory: {get_evals_formatted_memory(self.evals)}'
+        if print_message and self.message is not None:
+            tc, msg = self.message
+            if msg:
+                if len(msg) > 100:
+                    msg = msg[:100] + '... (truncated)'
+                res += f'\nMessage for {tc}: {msg}'
         return res
 
 
 def get_solution_outcome_report(
     solution: Solution,
+    skeleton: SolutionReportSkeleton,
     evals: List[Evaluation],
     verification: VerificationLevel = VerificationLevel.NONE,
     subset: bool = False,
@@ -969,7 +983,8 @@ def get_solution_outcome_report(
     bad_verdicts = set()
     no_tle_bad_verdicts = set()
     has_sanitizer_warnings = False
-    for eval in evals:
+    message: Optional[Tuple[TestcaseEntry, str]] = None
+    for eval, entry in zip(evals, skeleton.entries):
         all_verdicts.add(eval.result.outcome)
         if eval.result.outcome != Outcome.ACCEPTED:
             bad_verdicts.add(eval.result.outcome)
@@ -984,6 +999,16 @@ def get_solution_outcome_report(
         has_sanitizer_warnings = (
             has_sanitizer_warnings or eval.result.sanitizer_warnings
         )
+        if (
+            eval.result.outcome
+            in [
+                Outcome.WRONG_ANSWER,
+                Outcome.JUDGE_FAILED,
+            ]
+            and message is None
+        ):
+            message = (entry, eval.result.message)
+
     unmatched_bad_verdicts = set(
         v for v in bad_verdicts if not solution.outcome.match(v)
     )
@@ -1042,6 +1067,7 @@ def get_solution_outcome_report(
         solution=solution,
         evals=evals,
         ok=not has_failed,
+        message=message,
         expectedOutcome=report_expected_outcome,
         gotVerdicts=report_got_verdicts,
         runUnderDoubleTl=report_run_under_double_tl,
@@ -1053,13 +1079,17 @@ def get_solution_outcome_report(
 
 def _print_solution_outcome(
     solution: Solution,
+    skeleton: SolutionReportSkeleton,
     evals: List[Evaluation],
     console: rich.console.Console,
     verification: VerificationLevel = VerificationLevel.NONE,
     subset: bool = False,
+    print_message: bool = True,
 ) -> bool:
-    report = get_solution_outcome_report(solution, evals, verification, subset)
-    console.print(report.get_outcome_markup())
+    report = get_solution_outcome_report(
+        solution, skeleton, evals, verification, subset
+    )
+    console.print(report.get_outcome_markup(print_message))
     return report.ok
 
 
@@ -1343,6 +1373,7 @@ async def _print_detailed_run_report(
         _print_solution_header(solution, console)
         cur_ok = _print_solution_outcome(
             solution,
+            result.skeleton,
             all_evals,
             console,
             verification=verification,
@@ -1404,44 +1435,70 @@ async def print_run_report(
         )
 
     ok = True
+    single_solution = len(result.skeleton.solutions) == 1
 
     for solution in result.skeleton.solutions:
         _print_solution_header(solution, console)
+        if single_solution:
+            console.print()
         solution_evals = []
         for group in result.skeleton.groups:
-            console.print(f'[bold][status]{group.name}[/status][/bold] ', end='')
+            if not single_solution:
+                console.print(f'[bold][status]{group.name}[/status][/bold] ', end='')
             group_evals = []
             for i, _ in enumerate(group.testcases):
                 eval = structured_evaluations[str(solution.path)][group.name][i]
                 if eval is None:
                     continue
                 eval = await eval()
-                console.print(f'{i}/', end='')
-                console.print(get_testcase_markup_verdict(eval), end='')
-                if eval.result.sanitizer_warnings:
-                    console.print('[warning]*[/warning]', end='')
-                console.print('', end=' ')
+                if single_solution:
+                    console.print(get_testcase_markup_verdict(eval), end=' ')
+                    console.print(f'{group.name}/{i}', end='')
+                    if eval.result.sanitizer_warnings:
+                        console.print('[warning]*[/warning]', end='')
+                    time = get_capped_evals_formatted_time(
+                        solution, [eval], verification
+                    )
+                    memory = get_evals_formatted_memory([eval])
+                    console.print(f' ({time}, {memory})', end='')
+                    checker_msg = eval.result.message
+                    if checker_msg:
+                        console.print(f': [i]{checker_msg}[/i]', end='')
+                else:
+                    console.print(f'{i}/', end='')
+                    console.print(get_testcase_markup_verdict(eval), end='')
+                    if eval.result.sanitizer_warnings:
+                        console.print('[warning]*[/warning]', end='')
+
+                console.print('', end='\n' if single_solution else ' ')
                 group_evals.append(eval)
                 solution_evals.append(eval)
 
+            if single_solution:
+                console.print(f'  [status]{group.name}[/status]', end=' ')
             console.print(
                 f'({get_capped_evals_formatted_time(solution, group_evals, verification)}, {get_evals_formatted_memory(group_evals)})',
                 end='',
             )
             console.print()
+            if single_solution:
+                console.print()
 
         cur_ok = _print_solution_outcome(
             solution,
+            result.skeleton,
             solution_evals,
             console,
             verification=verification,
+            print_message=not single_solution,
         )
         ok = ok and cur_ok
         console.print()
 
-    await _print_timing(
-        console, result.skeleton, structured_evaluations, verification=verification
-    )
+    if not single_solution:
+        await _print_timing(
+            console, result.skeleton, structured_evaluations, verification=verification
+        )
 
     return ok
 

rbx/box/stats.py

@@ -0,0 +1,92 @@
+import pathlib
+from typing import Iterable, List, Tuple
+
+from rbx import console
+from rbx.box.cd import (
+    find_all_ancestor_packages,
+    is_contest_package,
+    is_problem_package,
+)
+from rbx.box.contest.contest_package import find_contest, find_contest_package_or_die
+from rbx.box.formatting import get_formatted_memory
+
+
+def find_problem_packages_from_contest(
+    root: pathlib.Path = pathlib.Path(),
+) -> Iterable[pathlib.Path]:
+    contest_path = find_contest(root)
+    contest = find_contest_package_or_die(contest_path)
+    for problem in contest.problems:
+        yield contest_path / problem.get_path()
+
+
+def find_all_reachable_packages(
+    root: pathlib.Path = pathlib.Path(),
+) -> List[pathlib.Path]:
+    packages = find_all_ancestor_packages(root)
+
+    for package in list(packages):
+        if is_contest_package(package):
+            packages.extend(find_problem_packages_from_contest(package))
+    return packages
+
+
+def find_and_group_all_reachable_packages(
+    root: pathlib.Path = pathlib.Path(),
+) -> Tuple[List[pathlib.Path], List[pathlib.Path]]:
+    packages = find_all_reachable_packages(root)
+    contest_packages = set(pkg for pkg in packages if is_contest_package(pkg))
+    problem_packages = set(pkg for pkg in packages if is_problem_package(pkg))
+    return sorted(contest_packages), sorted(problem_packages)
+
+
+def get_dir_size(path: pathlib.Path) -> int:
+    if not path.is_dir():
+        return 0
+    return sum(
+        f.stat().st_size
+        for f in path.glob('**/*')
+        if f.is_file() and not f.is_symlink()
+    )
+
+
+def get_cache_size(root: pathlib.Path = pathlib.Path()) -> int:
+    cache_dir = root / '.box'
+    return get_dir_size(cache_dir)
+
+
+def get_build_size(root: pathlib.Path = pathlib.Path()) -> int:
+    build_dir = root / 'build'
+    return get_dir_size(build_dir)
+
+
+def print_package_stats(root: pathlib.Path = pathlib.Path()) -> int:
+    if is_contest_package(root):
+        console.console.print(f'[status]Contest package[/status]: [item]{root}[/item]')
+    else:
+        console.console.print(f'[status]Problem package[/status]: [item]{root}[/item]')
+
+    cache_size = get_cache_size(root)
+    build_size = get_build_size(root)
+    console.console.print(
+        f'[status]Cache size[/status]: [item]{get_formatted_memory(cache_size)}[/item]'
+    )
+    console.console.print(
+        f'[status]Build size[/status]: [item]{get_formatted_memory(build_size)}[/item]'
+    )
+
+    return cache_size + build_size
+
+
+def print_reachable_package_stats(root: pathlib.Path = pathlib.Path()) -> None:
+    contest_packages, problem_packages = find_and_group_all_reachable_packages(root)
+    total_size = 0
+    for pkg in contest_packages:
+        total_size += print_package_stats(pkg)
+        console.console.print()
+    for pkg in problem_packages:
+        total_size += print_package_stats(pkg)
+        console.console.print()
+    console.console.print(
+        f'[status]Total size[/status]: [item]{get_formatted_memory(total_size)}[/item]'
+    )

rbx/box/tasks.py

@@ -4,7 +4,7 @@ from typing import Optional
 from rbx.box import checkers, package, state
 from rbx.box.code import CommunicationItem, run_communication, run_item
 from rbx.box.environment import EnvironmentSandbox, ExecutionConfig, VerificationLevel
-from rbx.box.retries import Retrier
+from rbx.box.retries import Retrier, get_retrier_config
 from rbx.box.schema import Solution, Testcase
 from rbx.grading.judge.sandbox import SandboxBase
 from rbx.grading.limits import Limits
@@ -51,6 +51,7 @@ async def run_solution_on_testcase(
     use_retries: bool = True,
     use_timelimit: bool = True,
     capture_pipes: bool = False,
+    nruns: int = 0,
 ) -> Evaluation:
     if interactor_digest is not None:
         return await _run_communication_solution_on_testcase(
@@ -66,6 +67,7 @@ async def run_solution_on_testcase(
             use_retries=use_retries,
             use_timelimit=use_timelimit,
             capture_pipes=capture_pipes,
+            nruns=nruns,
         )
 
     async def run_fn(retry_index: int) -> Evaluation:
@@ -132,7 +134,7 @@ async def run_solution_on_testcase(
     if not use_retries:
         return await run_fn(0)
 
-    retrier = Retrier()
+    retrier = Retrier(get_retrier_config(nruns))
     return await retrier.repeat(run_fn)
 
 
@@ -166,6 +168,7 @@ async def _run_communication_solution_on_testcase(
     use_retries: bool = True,
     use_timelimit: bool = True,
     capture_pipes: bool = False,
+    nruns: int = 0,
 ) -> Evaluation:
     capture_pipes = capture_pipes or state.STATE.debug_logs
 
@@ -291,5 +294,5 @@ async def _run_communication_solution_on_testcase(
     if not use_retries:
         return await run_fn(0)
 
-    retrier = Retrier()
+    retrier = Retrier(get_retrier_config(nruns))
     return await retrier.repeat(run_fn)

rbx/box/ui/utils/run_ui.py

@@ -52,7 +52,7 @@ def get_solution_markup(
 
     evals = get_solution_evals_or_null(skeleton, solution)
     report = solutions.get_solution_outcome_report(
-        solution, evals or [], skeleton.verification, subset=False
+        solution, skeleton, evals or [], skeleton.verification, subset=False
     )
     if evals is None:
         return header + '\n' + report.get_verdict_markup(incomplete=True)

rbx/grading/judge/sandbox.py

@@ -25,17 +25,29 @@ MERGE_STDERR = pathlib.PosixPath('/dev/stdout')
 
 # Thread-safe version of asyncio.Event.
 class Event_ts(asyncio.Event):
+    def __init__(self):
+        super().__init__()
+        self._inherited_loop = asyncio.get_event_loop()
+
     def get_loop(self):
-        if self._loop is None:
-            return asyncio.get_event_loop()
-        else:
-            return self._loop
+        if self._inherited_loop is None:
+            return None
+        if self._inherited_loop.is_closed():
+            return None
+        return self._inherited_loop
+
+    def set_loop(self, loop):
+        self._inherited_loop = loop
 
     def set(self):
-        self.get_loop().call_soon_threadsafe(super().set)
+        loop = self.get_loop()
+        if loop is not None:
+            loop.call_soon_threadsafe(super().set)
 
     def clear(self):
-        self.get_loop().call_soon_threadsafe(super().clear)
+        loop = self.get_loop()
+        if loop is not None:
+            loop.call_soon_threadsafe(super().clear)
 
 
 def wait_without_std(
@@ -245,7 +257,7 @@ class SandboxBase(abc.ABC):
 
         self.params = params or SandboxParams()
         self.pid = None
-        self._pid_event = Event_ts()
+        self.pid_event = Event_ts()
 
         # Set common environment variables.
         # Specifically needed by Python, that searches the home for
@@ -352,7 +364,7 @@ class SandboxBase(abc.ABC):
 
         """
         self.pid = pid
-        self._pid_event.set()
+        self.pid_event.set()
 
     async def get_pid(self) -> int:
         """Return the PID of the sandboxed process.
@@ -362,13 +374,13 @@ class SandboxBase(abc.ABC):
         return (int): the PID of the sandboxed process.
 
         """
-        await self._pid_event.wait()
+        await self.pid_event.wait()
         assert self.pid is not None
         return self.pid
 
     def clear_pid(self):
         """Clear the PID of the sandboxed process."""
-        self._pid_event.clear()
+        self.pid_event.clear()
         self.pid = None
 
     def use_pgid(self) -> bool:

rbx/grading/steps.py

@@ -709,6 +709,7 @@ async def run(
     if is_java_like_command(get_exe_from_command(command)):
         sandbox.params.address_space = None
 
+    sandbox.pid_event.set_loop(asyncio.get_event_loop())
     if not await asyncio.to_thread(sandbox.execute_without_std, cmd):
         console.print(
             '[error]Sandbox crashed while processing command:[/error]',

rbx/resources/presets/default/problem/problem.rbx.yml

@@ -40,6 +40,17 @@ stresses:
       name: "gen"
       args: "[1..<MAX_N>] @" # `@` generates a random string
     finder: "[sols/wa.cpp] ~ INCORRECT"
+unitTests:
+  validator:
+    - glob: "unit/validator/valid*.in"
+      outcome: "VALID"
+    - glob: "unit/validator/invalid*.in"
+      outcome: "INVALID"
+  checker:
+    - glob: "unit/checker/ac*"
+      outcome: "ACCEPTED"
+    - glob: "unit/checker/wa*"
+      outcome: "WRONG_ANSWER"
 vars:
   "MAX_N": 1000000000 # Can be used in the validator, in stress tests and in the statement.
 

rbx/resources/presets/default/problem/random.txt

@@ -1,2 +1,4 @@
 gen 123456
-gen 12345678
+gen 12345678
+# Obtained by running `rbx stress -g 'gen [1..<MAX_N>] @' -f '[sols/wa.cpp] ~ INCORRECT'`
+gen 149403982 b139a2bd

rbx/resources/presets/default/problem/rbx.h

@@ -0,0 +1,92 @@
+#ifndef _RBX_H
+#define _RBX_H
+#include <optional>
+#include <stdexcept>
+#include <string>
+
+std::optional<std::string> getStringVar(std::string name) {
+  
+  return std::nullopt;
+}
+
+std::optional<int> getIntVar(std::string name) {
+    if (name == "MAX_N") {
+    return 1000000000;
+  }
+
+  return std::nullopt;
+}
+
+std::optional<float> getFloatVar(std::string name) {
+  
+  return std::nullopt;
+}
+
+std::optional<bool> getBoolVar(std::string name) {
+  
+  return std::nullopt;
+}
+
+template <typename T> T getVar(std::string name);
+
+template <> int getVar<int>(std::string name) {
+  auto opt = getIntVar(name);
+  if (!opt.has_value()) {
+    throw std::runtime_error("Variable " + name +
+                             " is not an integer or could not be found");
+  }
+  return opt.value();
+}
+
+template <> float getVar<float>(std::string name) {
+  auto opt = getFloatVar(name);
+  if (!opt.has_value()) {
+    auto intOpt = getIntVar(name);
+    if (intOpt.has_value()) {
+      opt = (float)intOpt.value();
+    }
+  }
+  if (!opt.has_value()) {
+    throw std::runtime_error("Variable " + name +
+                             " is not a float or could not be found");
+  }
+  return opt.value();
+}
+
+template <> double getVar<double>(std::string name) {
+  return getVar<float>(name);
+}
+
+template <> std::string getVar<std::string>(std::string name) {
+  auto opt = getStringVar(name);
+  if (!opt.has_value()) {
+    auto intOpt = getIntVar(name);
+    if (intOpt.has_value()) {
+      opt = std::to_string(intOpt.value());
+    }
+  }
+  if (!opt.has_value()) {
+    auto floatOpt = getFloatVar(name);
+    if (floatOpt.has_value()) {
+      opt = std::to_string(floatOpt.value());
+    }
+  }
+  if (!opt.has_value()) {
+    throw std::runtime_error("Variable " + name +
+                             " is not a string or could not be found");
+  }
+  return opt.value();
+}
+
+template <> bool getVar<bool>(std::string name) {
+  auto opt = getBoolVar(name);
+  if (!opt.has_value()) {
+    opt = getIntVar(name) != 0;
+  }
+  if (!opt.has_value()) {
+    throw std::runtime_error("Variable " + name +
+                             " is not a boolean or could not be found");
+  }
+  return opt.value();
+}
+#endif