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

rbx/box/remote.py

@@ -5,7 +5,7 @@ from typing import List, Optional, Tuple, Union
 
 import typer
 
-from rbx import console
+from rbx import console, utils
 from rbx.box import cd, package
 from rbx.box.formatting import href, ref
 
@@ -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,12 +79,13 @@ class BocaExpander(Expander):
 
 
 REGISTERED_EXPANDERS: List['Expander'] = [
+    MainExpander(),
     BocaExpander(),
 ]
 
 
 def _relative_to_pkg(path: pathlib.Path) -> pathlib.Path:
-    return path.resolve().relative_to(pathlib.Path.cwd())
+    return utils.abspath(path).relative_to(pathlib.Path.cwd())
 
 
 def _try_cacheable_paths(
@@ -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 utils.abspath(path).is_relative_to(utils.abspath(remote_dir))

rbx/box/retries.py

@@ -5,6 +5,7 @@ import tempfile
 from contextlib import contextmanager
 from typing import Awaitable, Callable, List, Optional
 
+from rbx import utils
 from rbx.box import package
 from rbx.box.setter_config import RepeatsConfig, get_setter_config
 from rbx.grading.steps import Evaluation, Outcome
@@ -59,8 +60,8 @@ class FileToRecover:
 
 def _move_to_temp_dir(path: pathlib.Path, temp_dir: pathlib.Path) -> FileToRecover:
     problem_path = package.find_problem()
-    path = path.resolve()
-    temp_dir = temp_dir.resolve()
+    path = utils.abspath(path)
+    temp_dir = utils.abspath(temp_dir)
     relative = path.relative_to(problem_path)
 
     temp_path = temp_dir / relative

rbx/box/sanitizers/warning_stack.py

@@ -2,9 +2,9 @@ import functools
 import pathlib
 import shutil
 
-from rbx import console
+from rbx import console, utils
 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:
@@ -60,7 +60,7 @@ def _get_warning_runs_dir(root: pathlib.Path) -> pathlib.Path:
 
 
 def get_warning_stack() -> WarningStack:
-    current_root = pathlib.Path.cwd().resolve()
+    current_root = utils.abspath(pathlib.Path.cwd())
     return _get_warning_stack(current_root)
 
 

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
@@ -53,6 +54,7 @@ from rbx.box.testcase_utils import (
     parse_interaction,
     print_interaction,
 )
+from rbx.grading import grading_context
 from rbx.grading.limits import Limits
 from rbx.grading.steps import (
     Evaluation,
@@ -245,7 +247,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 +262,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 +395,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,
@@ -497,7 +499,7 @@ async def _generate_testcase_interactively(
             console.console.print(testcase.inputPath.read_text())
         else:
             console.console.print(
-                f'Input was written to [item]{testcase.inputPath.resolve()}[/item]'
+                f'Input was written to [item]{utils.abspath(testcase.inputPath)}[/item]'
             )
         console.console.print()
 
@@ -605,7 +607,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 +647,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,
@@ -659,23 +661,28 @@ async def run_and_print_interactive_solutions(
         tracked_solutions,
         verification=verification,
     )
-    testcase = await _generate_testcase_interactively(
-        progress=progress,
-        generator=generator,
-        testcase_entry=testcase_entry,
-        check=check,
-        custom_output=custom_output,
-        sanitized=sanitized,
-        print=print,
-    )
-    items = _run_interactive_solutions(
-        testcase,
-        skeleton=skeleton,
-        progress=progress,
-        verification=verification,
-        check=check,
-        sanitized=sanitized,
-    )
+
+    should_cache = testcase_entry is not None
+    with grading_context.cache_level(
+        grading_context.CacheLevel.CACHE_COMPILATION, when=not should_cache
+    ):
+        testcase = await _generate_testcase_interactively(
+            progress=progress,
+            generator=generator,
+            testcase_entry=testcase_entry,
+            check=check,
+            custom_output=custom_output,
+            sanitized=sanitized,
+            print=print,
+        )
+        items = _run_interactive_solutions(
+            testcase,
+            skeleton=skeleton,
+            progress=progress,
+            verification=verification,
+            check=check,
+            sanitized=sanitized,
+        )
 
     for item in items:
         sol = skeleton.find_solution_skeleton(item.solution)
@@ -739,7 +746,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 +774,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/statements/build_statements.py

@@ -6,7 +6,7 @@ from typing import Annotated, Any, Dict, List, Optional, Tuple
 import syncer
 import typer
 
-from rbx import annotations, console
+from rbx import annotations, console, utils
 from rbx.box import environment, naming, package
 from rbx.box.formatting import href
 from rbx.box.schema import Package, expand_any_vars
@@ -46,7 +46,7 @@ def get_environment_languages_for_statement() -> List[StatementCodeLanguage]:
         res.append(
             StatementCodeLanguage(
                 id=language.name,
-                name=language.readable_name or language.name,
+                name=language.readableName or language.name,
                 command=cmd or '',
             )
         )
@@ -173,7 +173,7 @@ def get_relative_assets(
     relative_to: pathlib.Path,
     assets: List[str],
 ) -> List[Tuple[pathlib.Path, pathlib.Path]]:
-    relative_to = relative_to.resolve()
+    relative_to = utils.abspath(relative_to)
     if not relative_to.is_dir():
         relative_to = relative_to.parent
     res = []
@@ -192,7 +192,7 @@ def get_relative_assets(
                 raise typer.Exit(1)
             res.extend(get_relative_assets(relative_to, list(map(str, globbed))))
             continue
-        if not relative_path.resolve().is_relative_to(relative_to):
+        if not utils.abspath(relative_path).is_relative_to(relative_to):
             console.console.print(
                 f'[error]Asset [item]{asset}[/item] is not relative to your statement.[/error]'
             )
@@ -200,8 +200,8 @@ def get_relative_assets(
 
         res.append(
             (
-                relative_path.resolve(),
-                relative_path.resolve().relative_to(relative_to),
+                utils.abspath(relative_path),
+                utils.abspath(relative_path).relative_to(relative_to),
             )
         )
 

rbx/box/statements/builders.py

@@ -319,7 +319,7 @@ class rbxTeXBuilder(StatementBuilder):
         params = typing.cast(rbxToTeX, params)
         if not params.template:
             return []
-        return [((root / params.template).resolve(), params.template)]
+        return [(utils.abspath(root / params.template), params.template)]
 
     def build(
         self,

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
@@ -7,25 +9,20 @@ import syncer
 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 import console, utils
+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,
@@ -330,7 +311,7 @@ def print_stress_report(report: StressReport):
     console.console.print(f'Found [item]{len(report.findings)}[/item] testcases.')
 
     findings_dir = package.get_problem_runs_dir() / '.stress' / 'findings'
-    console.console.print(f'Findings: {findings_dir.resolve()}')
+    console.console.print(f'Findings: {utils.abspath(findings_dir)}')
     console.console.print()
 
     for i, finding in enumerate(report.findings):

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)