rbx.cp 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

rbx/box/remote.py

@@ -27,6 +27,16 @@ class Expander(ABC):
         pass
 
 
+class MainExpander(Expander):
+    def expand(self, path: pathlib.Path) -> Optional[pathlib.Path]:
+        if str(path) != '@main':
+            return None
+        sol = package.get_main_solution()
+        if sol is None:
+            return None
+        return sol.path
+
+
 class BocaExpander(Expander):
     BOCA_REGEX = re.compile(r'\@boca\/(\d+)(?:\-(\d+))?')
 
@@ -69,6 +79,7 @@ class BocaExpander(Expander):
 
 
 REGISTERED_EXPANDERS: List['Expander'] = [
+    MainExpander(),
     BocaExpander(),
 ]
 
@@ -132,6 +143,9 @@ def _expand_paths(paths: List[pathlib.Path]) -> List[pathlib.Path]:
             continue
         expanded = _expand_path(path)
         if expanded is None:
+            console.console.print(
+                f'[warning]Remote solution [item]{path}[/item] could not be expanded. Skipping.[/warning]'
+            )
             continue
         res.append(expanded)
     return res
@@ -149,3 +163,8 @@ def expand_file(file: str) -> pathlib.Path:
         )
         raise typer.Exit(1)
     return res[0]
+
+
+def is_path_remote(path: pathlib.Path) -> bool:
+    remote_dir = package.get_problem_remote_dir()
+    return path.resolve().is_relative_to(remote_dir.resolve())

rbx/box/sanitizers/warning_stack.py

@@ -4,7 +4,7 @@ import shutil
 
 from rbx import console
 from rbx.box.schema import CodeItem
-from rbx.grading.judge.storage import Storage
+from rbx.grading.judge.cacher import FileCacher
 from rbx.grading.steps import GradingFileOutput
 
 
@@ -18,7 +18,7 @@ class WarningStack:
         self.warnings.add(code.path)
 
     def add_sanitizer_warning(
-        self, storage: Storage, code: CodeItem, reference: GradingFileOutput
+        self, cacher: FileCacher, code: CodeItem, reference: GradingFileOutput
     ):
         if code.path in self.sanitizer_warnings:
             return
@@ -26,7 +26,7 @@ class WarningStack:
             code.path.with_suffix(code.path.suffix + '.log')
         )
         dest_path.parent.mkdir(parents=True, exist_ok=True)
-        f = reference.get_file(storage)
+        f = reference.get_file(cacher)
         if f is None:
             return
         with dest_path.open('wb') as fout:

rbx/box/solutions.py

@@ -13,6 +13,7 @@ import rich.markup
 import rich.table
 import rich.text
 import typer
+from ordered_set import OrderedSet
 from pydantic import BaseModel
 
 from rbx import console, utils
@@ -245,7 +246,7 @@ async def convert_list_of_solution_evaluations_to_dict(
 
 
 def _get_solutions_for_skeleton(
-    tracked_solutions: Optional[Set[str]] = None,
+    tracked_solutions: Optional[Iterable[str]] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
 ) -> List[Solution]:
     pkg = package.find_problem_package_or_die()
@@ -260,7 +261,7 @@ def _get_solutions_for_skeleton(
 
 
 def _get_report_skeleton(
-    tracked_solutions: Optional[Set[str]] = None,
+    tracked_solutions: Optional[Iterable[str]] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
     timelimit_override: Optional[int] = None,
 ) -> SolutionReportSkeleton:
@@ -393,7 +394,7 @@ def print_best_output(output_files: List[pathlib.Path], empty_warning: bool = Fa
 
 def run_solutions(
     progress: Optional[StatusProgress] = None,
-    tracked_solutions: Optional[Set[str]] = None,
+    tracked_solutions: Optional[Iterable[str]] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
     check: bool = True,
     timelimit_override: Optional[int] = None,
@@ -605,7 +606,7 @@ def _run_interactive_solutions(
 
 
 def _get_interactive_skeleton(
-    tracked_solutions: Optional[Set[str]] = None,
+    tracked_solutions: Optional[Iterable[str]] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
 ) -> SolutionReportSkeleton:
     solutions = _get_solutions_for_skeleton(tracked_solutions, verification)
@@ -645,7 +646,7 @@ def _get_interactive_skeleton(
 
 async def run_and_print_interactive_solutions(
     progress: Optional[StatusProgress] = None,
-    tracked_solutions: Optional[Set[str]] = None,
+    tracked_solutions: Optional[Iterable[str]] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
     generator: Optional[GeneratorCall] = None,
     testcase_entry: Optional[TestcaseEntry] = None,
@@ -739,7 +740,12 @@ def expand_solutions_with_source(sols: List[str]) -> List[Tuple[Solution, bool]]
     path_sols = remote.expand_files(sols)
 
     # Ensure sols exist.
-    path_sols = [sol for sol in path_sols if sol.is_file()]
+    for sol in path_sols:
+        if not sol.is_file():
+            console.console.print(
+                f'[error]Solution [item]{sol}[/item] could not be found.[/error]'
+            )
+            raise typer.Exit(1)
 
     seen_sols = set()
     res: List[Tuple[Solution, bool]] = []
@@ -762,7 +768,7 @@ def expand_solutions(sols: List[str]) -> List[Solution]:
 
 
 async def pick_solutions(
-    tracked_solutions: Optional[Set[str]],
+    tracked_solutions: Optional[OrderedSet[str]],
     extra_solutions: Optional[List[str]] = None,
 ) -> List[str]:
     pkg = package.find_problem_package_or_die()

rbx/box/stats.py

@@ -78,6 +78,14 @@ def print_package_stats(root: pathlib.Path = pathlib.Path()) -> int:
     return cache_size + build_size
 
 
+def print_global_stats() -> int:
+    cache_size = get_cache_size()
+    console.console.print(
+        f'[status]Global cache size[/status]: [item]{get_formatted_memory(cache_size)}[/item]'
+    )
+    return cache_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
@@ -87,6 +95,8 @@ def print_reachable_package_stats(root: pathlib.Path = pathlib.Path()) -> None:
     for pkg in problem_packages:
         total_size += print_package_stats(pkg)
         console.console.print()
+
+    total_size += print_global_stats()
     console.console.print(
         f'[status]Total size[/status]: [item]{get_formatted_memory(total_size)}[/item]'
     )

rbx/box/stresses.py

@@ -1,3 +1,5 @@
+import pathlib
+import shutil
 import time
 from shutil import rmtree
 from typing import List, Optional
@@ -8,24 +10,19 @@ import typer
 from pydantic import BaseModel
 
 from rbx import console
-from rbx.box import checkers, generators, package, validators
-from rbx.box.code import SanitizationLevel, compile_item, run_item
+from rbx.box import checkers, generators, package, tasks, validators
+from rbx.box.code import SanitizationLevel, compile_item
 from rbx.box.generators import (
     GenerationMetadata,
     expand_generator_call,
     generate_standalone,
 )
-from rbx.box.retries import Retrier
 from rbx.box.schema import CodeItem, GeneratorCall, Stress, TaskType, Testcase
 from rbx.box.solutions import compile_solutions, get_outcome_style_verdict
 from rbx.box.stressing import finder_parser
 from rbx.grading.steps import (
-    DigestOrDest,
-    DigestOrSource,
     Evaluation,
     Outcome,
-    TestcaseIO,
-    TestcaseLog,
 )
 from rbx.utils import StatusProgress
 
@@ -61,11 +58,6 @@ async def run_stress(
     sanitized: bool = False,
 ) -> StressReport:
     pkg = package.find_problem_package_or_die()
-    if pkg.type == TaskType.COMMUNICATION:
-        console.console.print(
-            '[error]Communication problems do not support stress testing.[/error]'
-        )
-        raise typer.Exit(1)
 
     if finder:
         if generator_call is None:
@@ -90,6 +82,8 @@ async def run_stress(
     call = stress.generator
     generator = package.get_generator(call.name)
 
+    if progress:
+        progress.update('Compiling generator...')
     try:
         generator_digest = compile_item(generator, sanitized=SanitizationLevel.PREFER)
     except:
@@ -109,11 +103,18 @@ async def run_stress(
     solutions_digest = compile_solutions(
         tracked_solutions=set(str(solution.path) for solution in solutions),
         sanitized=sanitized,
+        progress=progress,
     )
     if progress:
         progress.update('Compiling finders...')
     finders_digest = {str(finder.path): _compile_finder(finder) for finder in finders}
 
+    interactor_digest = None
+    if pkg.type == TaskType.COMMUNICATION:
+        interactor_digest = checkers.compile_interactor(progress=progress)
+
+    if progress:
+        progress.update('Compiling validator...')
     compiled_validator = validators.compile_main_validator()
 
     # Erase old stress directory
@@ -158,47 +159,40 @@ async def run_stress(
             else None,
         )
 
-        @async_lru.alru_cache
+        @async_lru.alru_cache(maxsize=None)
         async def run_solution_fn(
             solution: str,
-            retry_index: Optional[int] = None,
+            checker_digest: Optional[str] = None,
             input_path=input_path,
-        ) -> TestcaseLog:
+            output_path: Optional[pathlib.Path] = None,
+        ) -> Evaluation:
             index = solution_indices[solution]
             sol = solutions[index]
-            output_path = input_path.with_stem(f'{index}').with_suffix('.out')
-            stderr_path = output_path.with_suffix('.err')
-
-            run_log = await run_item(
-                sol,
-                DigestOrSource.create(solutions_digest[sol.path]),
-                stdin=DigestOrSource.create(input_path),
-                stdout=DigestOrDest.create(output_path),
-                stderr=DigestOrDest.create(stderr_path),
-                retry_index=retry_index,
-            )
-
-            return TestcaseLog(
-                **(run_log.model_dump() if run_log is not None else {}),
-                stdout_absolute_path=output_path.absolute(),
-                stderr_absolute_path=stderr_path.absolute(),
+            return await tasks.run_solution_on_testcase(
+                solutions[index],
+                compiled_digest=solutions_digest[sol.path],
+                checker_digest=checker_digest,
+                interactor_digest=interactor_digest,
+                testcase=Testcase(inputPath=input_path, outputPath=output_path),
+                output_dir=input_path.parent,
+                filestem=f'{index}',
+                is_stress=True,
             )
 
         # Get main solution output.
         expected_output_path = empty_path
         if needs_expected_output:
-            main_testcase_log = await run_solution_fn(str(solutions[0].path))
-            main_checker_result = checkers.check_with_no_output(main_testcase_log)
-            if main_checker_result.outcome != Outcome.ACCEPTED:
+            eval = await run_solution_fn(str(solutions[0].path))
+            if eval.result.outcome != Outcome.ACCEPTED:
                 console.console.print(
                     '[error]Error while generating main solution output.[/error]'
                 )
                 console.console.print(f'Input written at [item]{input_path}[/item]')
                 console.console.print(
-                    f'Output written at [item]{main_testcase_log.stdout_absolute_path}[/item]'
+                    f'Output written at [item]{eval.log.stdout_absolute_path}[/item]'
                 )
                 console.console.print(
-                    f'Stderr written at [item]{main_testcase_log.stderr_absolute_path}[/item]'
+                    f'Stderr written at [item]{eval.log.stderr_absolute_path}[/item]'
                 )
                 console.console.print()
                 console.console.print(
@@ -206,44 +200,31 @@ async def run_stress(
                     "use the two-way modifier in your finder expression (':2')."
                 )
                 raise typer.Exit(1)
-            expected_output_path = main_testcase_log.stdout_absolute_path
+            if eval.log.stdout_absolute_path is not None:
+                expected_output_path = input_path.with_suffix('.ans')
+                shutil.copyfile(eval.log.stdout_absolute_path, expected_output_path)
+            else:
+                expected_output_path = None
 
-        @async_lru.alru_cache
+        @async_lru.alru_cache(maxsize=None)
         async def run_solution_and_checker_fn(
             call: finder_parser.FinderCall,
-            input_path=input_path,
             expected_output_path=expected_output_path,
         ) -> finder_parser.FinderResult:
-            async def run_fn(retry_index: int) -> Evaluation:
+            async def run_fn() -> Evaluation:
                 solution = call.solution
                 checker = call.checker
 
-                testcase_log = await run_solution_fn(solution, retry_index=retry_index)
-                assert testcase_log.stdout_absolute_path is not None
-
-                if checker is None:
-                    checker_result = checkers.check_with_no_output(testcase_log)
-                else:
-                    checker_digest = finders_digest[checker.path]
-                    checker_result = await checkers.check(
-                        checker_digest,
-                        testcase_log,
-                        Testcase(inputPath=input_path, outputPath=expected_output_path),
-                        program_output=testcase_log.stdout_absolute_path,
-                    )
-
-                return Evaluation(
-                    result=checker_result,
-                    testcase=TestcaseIO(
-                        index=0,
-                        input=input_path,
-                        output=expected_output_path,
-                    ),
-                    log=testcase_log,
+                checker_digest = (
+                    finders_digest[checker.path] if checker is not None else None
+                )
+                return await run_solution_fn(
+                    solution,
+                    checker_digest=checker_digest,
+                    output_path=expected_output_path,
                 )
 
-            retrier = Retrier(is_stress=True)
-            eval = await retrier.repeat(run_fn)
+            eval = await run_fn()
 
             return finder_parser.FinderResult(
                 solution=call.solution,

rbx/box/stressing/finder_parser.py

@@ -10,6 +10,7 @@ import typer
 from rbx import console
 from rbx.box import package
 from rbx.box.schema import CodeItem, ExpectedOutcome
+from rbx.box.solutions import expand_solutions
 from rbx.grading.steps import CheckerResult, Outcome, RunLog, TestcaseLog
 
 LARK_GRAMMAR = r"""
@@ -26,11 +27,12 @@ negation: _NOT "(" disjunction ")"
 // Expressions
 logical: eval matcher expected_outcome -> matching
        | eval equality (eval | outcome) -> equating
+       | eval -> eval_only
 
-eval: "[" solution checking? "]"
+eval: "[" solution checking? "]" | solution
 
 // Eval
-solution: _filename | WILDCARD
+solution: _solution_filename | WILDCARD
 checking: "ON"i (checking_mode? checker | ":nil")
 checking_mode: MODE ":"
 MODE: "2" | "3"
@@ -55,6 +57,7 @@ WILDCARD: "$"
 
 // File name
 _filename: FILENAME | "\"" FILENAME "\""
+_solution_filename: _filename | "@" _filename
 FILENAME: /[\/A-Za-z0-9\-_\.]/+
 
 // Names (Variables)
@@ -217,20 +220,7 @@ def get_all_solutions(tree: lark.ParseTree) -> List[str]:
 
 def get_all_solution_items(tree: lark.ParseTree) -> List[CodeItem]:
     solution_names = get_all_solutions(tree)
-    res = []
-
-    for solution_name in solution_names:
-        found_solution = package.get_solution_or_nil(solution_name)
-        if found_solution is None:
-            res.append(
-                CodeItem(
-                    path=pathlib.Path(solution_name),
-                    language=None,
-                    compilationFiles=None,
-                )
-            )
-            continue
-        res.append(found_solution)
+    res = typing.cast(List[CodeItem], expand_solutions(solution_names))
 
     main_solution = package.get_main_solution()
     if main_solution is None:
@@ -391,6 +381,11 @@ class FinderTreeRunner(lark.Transformer):
 
         return FinderOutcome(truth_value=truth_value, results=results)
 
+    def eval_only(self, eval_result: FinderResult) -> FinderOutcome:
+        return self.matching(
+            eval_result, is_positive=True, expected_outcome=ExpectedOutcome.INCORRECT
+        )
+
     def negation(self, value: FinderOutcome) -> FinderOutcome:
         return dataclasses.replace(value, truth_value=not value.truth_value)
 

rbx/box/tasks.py

@@ -5,7 +5,8 @@ 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, get_retrier_config
-from rbx.box.schema import Solution, Testcase
+from rbx.box.schema import CodeItem, Testcase
+from rbx.grading import profiling
 from rbx.grading.judge.sandbox import SandboxBase
 from rbx.grading.limits import Limits
 from rbx.grading.steps import (
@@ -39,7 +40,7 @@ def get_limits_for_language(
 
 
 async def run_solution_on_testcase(
-    solution: Solution,
+    solution: CodeItem,
     compiled_digest: str,
     checker_digest: Optional[str],
     testcase: Testcase,
@@ -52,6 +53,8 @@ async def run_solution_on_testcase(
     use_timelimit: bool = True,
     capture_pipes: bool = False,
     nruns: int = 0,
+    filestem: Optional[str] = None,
+    is_stress: bool = False,
 ) -> Evaluation:
     if interactor_digest is not None:
         return await _run_communication_solution_on_testcase(
@@ -68,6 +71,8 @@ async def run_solution_on_testcase(
             use_timelimit=use_timelimit,
             capture_pipes=capture_pipes,
             nruns=nruns,
+            filestem=filestem,
+            is_stress=is_stress,
         )
 
     async def run_fn(retry_index: int) -> Evaluation:
@@ -85,29 +90,32 @@ async def run_solution_on_testcase(
             assert testcase.outputPath is not None
             output_path = testcase.outputPath
         else:
-            output_path = output_dir / testcase.inputPath.with_suffix('.out').name
+            stem = filestem or testcase.inputPath.stem
+            output_path = output_dir / pathlib.PosixPath(stem).with_suffix('.out')
         error_path = output_path.with_suffix('.err')
         log_path = output_path.with_suffix('.log')
         eval_path = output_path.with_suffix('.eval')
         output_path.parent.mkdir(parents=True, exist_ok=True)
 
-        run_log = await run_item(
-            solution,
-            DigestOrSource.create(compiled_digest),
-            stdin=DigestOrSource.create(testcase.inputPath),
-            stdout=DigestOrDest.create(output_path),
-            stderr=DigestOrDest.create(error_path),
-            extra_config=extra_config,
-            retry_index=retry_index,
-        )
+        with profiling.PushContext('tasks.run_solution_on_testcase'):
+            run_log = await run_item(
+                solution,
+                DigestOrSource.create(compiled_digest),
+                stdin=DigestOrSource.create(testcase.inputPath),
+                stdout=DigestOrDest.create(output_path),
+                stderr=DigestOrDest.create(error_path),
+                extra_config=extra_config,
+                retry_index=retry_index,
+            )
 
         if checker_digest is not None:
-            checker_result = await checkers.check(
-                checker_digest,
-                run_log,
-                testcase,
-                program_output=output_path,
-            )
+            with profiling.PushContext('tasks.run_solution_on_testcase.check'):
+                checker_result = await checkers.check(
+                    checker_digest,
+                    run_log,
+                    testcase,
+                    program_output=output_path,
+                )
         else:
             checker_result = checkers.check_with_no_output(run_log)
 
@@ -134,7 +142,7 @@ async def run_solution_on_testcase(
     if not use_retries:
         return await run_fn(0)
 
-    retrier = Retrier(get_retrier_config(nruns))
+    retrier = Retrier(get_retrier_config(nruns), is_stress=is_stress)
     return await retrier.repeat(run_fn)
 
 
@@ -156,7 +164,7 @@ def _get_execution_config(
 
 
 async def _run_communication_solution_on_testcase(
-    solution: Solution,
+    solution: CodeItem,
     compiled_digest: str,
     interactor_digest: str,
     checker_digest: Optional[str],
@@ -169,6 +177,8 @@ async def _run_communication_solution_on_testcase(
     use_timelimit: bool = True,
     capture_pipes: bool = False,
     nruns: int = 0,
+    filestem: Optional[str] = None,
+    is_stress: bool = False,
 ) -> Evaluation:
     capture_pipes = capture_pipes or state.STATE.debug_logs
 
@@ -200,7 +210,8 @@ async def _run_communication_solution_on_testcase(
             assert testcase.outputPath is not None
             output_path = testcase.outputPath
         else:
-            output_path = output_dir / testcase.inputPath.with_suffix('.out').name
+            stem = filestem or testcase.inputPath.stem
+            output_path = output_dir / pathlib.PosixPath(stem).with_suffix('.out')
         solution_error_path = output_path.with_suffix('.sol.err')
         interactor_error_path = output_path.with_suffix('.int.err')
         log_path = output_path.with_suffix('.log')
@@ -294,5 +305,5 @@ async def _run_communication_solution_on_testcase(
     if not use_retries:
         return await run_fn(0)
 
-    retrier = Retrier(get_retrier_config(nruns))
+    retrier = Retrier(get_retrier_config(nruns), is_stress=is_stress)
     return await retrier.repeat(run_fn)

rbx/box/tooling/boca/scraper.py

@@ -364,7 +364,7 @@ class BocaScraper:
         return final_path
 
 
-@functools.lru_cache
+@functools.cache
 def get_boca_scraper(
     base_url: Optional[str] = None,
     username: Optional[str] = None,