rbx.cp 0.5.16__py3-none-any.whl → 0.5.18__py3-none-any.whl

rbx/box/deferred.py

@@ -0,0 +1,26 @@
+from typing import Awaitable, Callable, Generic, Optional, TypeVar
+
+T = TypeVar('T')
+U = TypeVar('U')
+
+
+class Deferred(Generic[T]):
+    def __init__(self, func: Callable[[], Awaitable[T]]):
+        self.func = func
+        self.cache: Optional[T] = None
+
+    def __call__(self) -> Awaitable[T]:
+        async def async_wrapper():
+            if self.cache is None:
+                self.cache = await self.func()
+            return self.cache
+
+        return async_wrapper()
+
+    def peek(self) -> Optional[T]:
+        return self.cache
+
+    def wrap_with(
+        self, wrapper: Callable[[Awaitable[T]], Awaitable[U]]
+    ) -> 'Deferred[U]':
+        return Deferred(lambda: wrapper(self()))

rbx/box/extensions.py

@@ -5,16 +5,8 @@ from pydantic import BaseModel, Field
 from rbx.box.packaging.boca.extension import BocaExtension, BocaLanguageExtension
 
 
-# List of extensions defined in-place.
-class MacExtension(BaseModel):
-    gpp_alternative: Optional[str] = None
-
-
 # Extension abstractions.
 class Extensions(BaseModel):
-    mac: Optional[MacExtension] = Field(
-        None, description='Extension for setting mac-only configuration.'
-    )
     boca: Optional[BocaExtension] = Field(
         None, description='Environment-level extensions for BOCA packaging.'
     )

rbx/box/generators.py

@@ -8,7 +8,7 @@ import typer
 
 from rbx import console
 from rbx.box import checkers, package, testcases, validators
-from rbx.box.code import compile_item, run_item
+from rbx.box.code import SanitizationLevel, compile_item, run_item
 from rbx.box.environment import (
     EnvironmentSandbox,
     ExecutionConfig,
@@ -32,7 +32,7 @@ from rbx.utils import StatusProgress
 
 
 def _compile_generator(generator: CodeItem) -> str:
-    return compile_item(generator)
+    return compile_item(generator, sanitized=SanitizationLevel.PREFER)
 
 
 def _get_group_input(
@@ -322,7 +322,7 @@ def generate_standalone(
     # Get generator item
     generator = package.get_generator(call.name)
     if generator_digest is None:
-        generator_digest = compile_item(generator)
+        generator_digest = _compile_generator(generator)
 
     generation_log = run_item(
         generator,
@@ -351,7 +351,9 @@ def generate_standalone(
     # Run validator, if it is available.
     if validator is not None and validate:
         if validator_digest is None:
-            validator_digest = compile_item(validator)
+            validator_tp = validators.compile_main_validator()
+            assert validator_tp is not None
+            _, validator_digest = validator_tp
         ok, message, *_ = validators.validate_test(output, validator, validator_digest)
         if not ok:
             console.console.print(

rbx/box/main.py

@@ -3,10 +3,11 @@ from gevent import monkey
 
 monkey.patch_all()
 
+
+import asyncio
 import tempfile
 import shlex
 import sys
-import typing
 
 from rbx.box.schema import CodeItem, ExpectedOutcome, TestcaseGroup
 
@@ -24,6 +25,7 @@ from rbx import annotations, config, console, utils
 from rbx.box import (
     builder,
     cd,
+    setter_config,
     creation,
     download,
     environment,
@@ -38,6 +40,8 @@ from rbx.box.contest import main as contest
 from rbx.box.environment import VerificationLevel, get_environment_path
 from rbx.box.packaging import main as packaging
 from rbx.box.solutions import (
+    estimate_time_limit,
+    get_exact_matching_solutions,
     get_matching_solutions,
     print_run_report,
     run_and_print_interactive_solutions,
@@ -46,6 +50,12 @@ from rbx.box.solutions import (
 from rbx.box.statements import build_statements
 
 app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
+app.add_typer(
+    setter_config.app,
+    name='config, cfg',
+    cls=annotations.AliasGroup,
+    help='Manage setter configuration.',
+)
 app.add_typer(
     build_statements.app,
     name='statements, st',
@@ -122,6 +132,18 @@ def run(
         '-d',
         help='Whether to print a detailed view of the tests using tables.',
     ),
+    timeit: bool = typer.Option(
+        False,
+        '--time',
+        '-t',
+        help='Whether to use estimate a time limit based on accepted solutions.',
+    ),
+    sanitized: bool = typer.Option(
+        False,
+        '--sanitized',
+        '-s',
+        help='Whether to compile the solutions with sanitizers enabled.',
+    ),
 ):
     main_solution = package.get_main_solution()
     if check and main_solution is None:
@@ -139,7 +161,27 @@ def run(
         )
         return
 
+    override_tl = None
+    if timeit:
+        if sanitized:
+            console.console.print(
+                '[error]Sanitizers are known to be time-hungry, so they cannot be used for time estimation.\n'
+                'Remove either the [item]-s[/item] flag or the [item]-t[/item] flag to run solutions without sanitizers.[/error]'
+            )
+            raise typer.Exit(1)
+
+        # Never use sanitizers for time estimation.
+        override_tl = _time_impl(check=check, detailed=False)
+        if override_tl is None:
+            raise typer.Exit(1)
+
     with utils.StatusProgress('Running solutions...') as s:
+        if sanitized:
+            console.console.print(
+                '[warning]Sanitizers are running, so the time limit for the problem will be dropped, '
+                'and the environment default time limit will be used instead.[/warning]'
+            )
+
         tracked_solutions = None
         if outcome is not None:
             tracked_solutions = {
@@ -148,23 +190,113 @@ def run(
             }
         if solution:
             tracked_solutions = {solution}
+
+        if sanitized and tracked_solutions is None:
+            console.console.print(
+                '[warning]Sanitizers are running, and no solutions were specified to run. Will only run [item]ACCEPTED[/item] solutions.'
+            )
+            tracked_solutions = {
+                str(solution.path)
+                for solution in get_exact_matching_solutions(ExpectedOutcome.ACCEPTED)
+            }
+
         solution_result = run_solutions(
             progress=s,
             tracked_solutions=tracked_solutions,
             check=check,
-            group_first=detailed,
             verification=VerificationLevel(verification),
+            timelimit_override=override_tl,
+            sanitized=sanitized,
         )
 
     console.console.print()
     console.console.rule('[status]Run report[/status]', style='status')
-    print_run_report(
-        solution_result,
-        console.console,
-        verification,
-        detailed=detailed,
+    asyncio.run(
+        print_run_report(
+            solution_result,
+            console.console,
+            verification,
+            detailed=detailed,
+        )
+    )
+
+
+def _time_impl(check: bool, detailed: bool) -> Optional[int]:
+    if package.get_main_solution() is None:
+        console.console.print(
+            '[warning]No main solution found, so cannot estimate a time limit.[/warning]'
+        )
+        return None
+
+    verification = VerificationLevel.ALL_SOLUTIONS.value
+
+    with utils.StatusProgress('Running ACCEPTED solutions...') as s:
+        tracked_solutions = {
+            str(solution.path)
+            for solution in get_exact_matching_solutions(ExpectedOutcome.ACCEPTED)
+        }
+        solution_result = run_solutions(
+            progress=s,
+            tracked_solutions=tracked_solutions,
+            check=check,
+            verification=VerificationLevel(verification),
+        )
+
+    console.console.print()
+    console.console.rule(
+        '[status]Run report (for time estimation)[/status]', style='status'
+    )
+    ok = asyncio.run(
+        print_run_report(
+            solution_result,
+            console.console,
+            verification,
+            detailed=detailed,
+        )
     )
 
+    if not ok:
+        console.console.print(
+            '[error]Failed to run ACCEPTED solutions, so cannot estimate a reliable time limit.[/error]'
+        )
+        return None
+
+    console.console.print()
+    return asyncio.run(estimate_time_limit(console.console, solution_result))
+
+
+@app.command(
+    'time, t',
+    help='Estimate a time limit for the problem based on a time limit formula and timings of accepted solutions.',
+)
+@package.within_problem
+def time(
+    check: bool = typer.Option(
+        True,
+        '--nocheck',
+        flag_value=False,
+        help='Whether to not build outputs for tests and run checker.',
+    ),
+    detailed: bool = typer.Option(
+        False,
+        '--detailed',
+        '-d',
+        help='Whether to print a detailed view of the tests using tables.',
+    ),
+):
+    main_solution = package.get_main_solution()
+    if check and main_solution is None:
+        console.console.print(
+            '[warning]No main solution found, running without checkers.[/warning]'
+        )
+        check = False
+
+    verification = VerificationLevel.ALL_SOLUTIONS.value
+    if not builder.build(verification=verification, output=check):
+        return None
+
+    _time_impl(check, detailed)
+
 
 @app.command(
     'irun, ir', help='Build and run solution(s) by passing testcases in the CLI.'
@@ -199,6 +331,12 @@ def irun(
     print: bool = typer.Option(
         False, '--print', '-p', help='Whether to print outputs to terminal.'
     ),
+    sanitized: bool = typer.Option(
+        False,
+        '--sanitized',
+        '-s',
+        help='Whether to compile the solutions with sanitizers enabled.',
+    ),
 ):
     if not print:
         console.console.print(
@@ -225,14 +363,26 @@ def irun(
         }
     if solution:
         tracked_solutions = {solution}
-    run_and_print_interactive_solutions(
-        tracked_solutions=tracked_solutions,
-        check=check,
-        verification=VerificationLevel(verification),
-        generator=generators.get_call_from_string(generator)
-        if generator is not None
-        else None,
-        print=print,
+    if sanitized and tracked_solutions is None:
+        console.console.print(
+            '[warning]Sanitizers are running, and no solutions were specified to run. Will only run [item]ACCEPTED[/item] solutions.'
+        )
+        tracked_solutions = {
+            str(solution.path)
+            for solution in get_exact_matching_solutions(ExpectedOutcome.ACCEPTED)
+        }
+
+    asyncio.run(
+        run_and_print_interactive_solutions(
+            tracked_solutions=tracked_solutions,
+            check=check,
+            verification=VerificationLevel(verification),
+            generator=generators.get_call_from_string(generator)
+            if generator is not None
+            else None,
+            print=print,
+            sanitized=sanitized,
+        )
     )
 
 
@@ -294,6 +444,12 @@ def stress(
         '--verbose',
         help='Whether to print verbose output for checkers and finders.',
     ),
+    sanitized: bool = typer.Option(
+        False,
+        '--sanitized',
+        '-s',
+        help='Whether to compile the solutions with sanitizers enabled.',
+    ),
 ):
     if finder and not generator_args or generator_args and not finder:
         console.console.print(
@@ -310,6 +466,7 @@ def stress(
             findingsLimit=findings,
             progress=s,
             verbose=verbose,
+            sanitized=sanitized,
         )
 
     stresses.print_stress_report(report)
@@ -351,10 +508,17 @@ def stress(
             groups_by_name[testgroup] = TestcaseGroup(
                 name=testgroup, generatorScript=CodeItem(path=new_script_path)
             )
-            console.console.print(
-                f'[warning]A testgroup for [item]{new_script_path}[/item] will not be automatically added to the problem.rbx.yml file for you.\n'
-                'Please add it manually. [/warning]'
+            ru, problem_yml = package.get_ruyaml()
+            problem_yml['testcases'].append(
+                {
+                    'name': testgroup,
+                    'generatorScript': new_script_path.name,
+                }
             )
+            dest = package.find_problem_yaml()
+            assert dest is not None
+            utils.save_ruyaml(dest, ru, problem_yml)
+            package.clear_package_cache()
 
         if testgroup not in groups_by_name:
             break
@@ -387,8 +551,20 @@ def stress(
 @package.within_problem
 def compile_command(
     path: Annotated[str, typer.Argument(help='Path to the asset to compile.')],
+    sanitized: bool = typer.Option(
+        False,
+        '--sanitized',
+        '-s',
+        help='Whether to compile the asset with sanitizers enabled.',
+    ),
+    warnings: bool = typer.Option(
+        False,
+        '--warnings',
+        '-w',
+        help='Whether to compile the asset with warnings enabled.',
+    ),
 ):
-    compile.any(path)
+    compile.any(path, sanitized, warnings)
 
 
 @app.command('validate', help='Run the validator in a one-off fashion, interactively.')

rbx/box/package.py

@@ -1,12 +1,14 @@
 import functools
 import pathlib
+import sys
 from typing import Dict, List, Optional, Tuple
 
+import ruyaml
 import typer
 from pydantic import ValidationError
 
 from rbx import config, console, utils
-from rbx.box import environment
+from rbx.box import cd, environment
 from rbx.box.environment import get_sandbox_type
 from rbx.box.presets import get_installed_preset_or_null, get_preset_lock
 from rbx.box.schema import (
@@ -102,7 +104,7 @@ def find_problem(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
 def within_problem(func):
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
-        with utils.new_cd(find_problem()):
+        with cd.new_package_cd(find_problem()):
             return func(*args, **kwargs)
 
     return wrapper
@@ -119,6 +121,17 @@ def save_package(
     problem_yaml_path.write_text(utils.model_to_yaml(package))
 
 
+def get_ruyaml() -> Tuple[ruyaml.YAML, ruyaml.Any]:
+    problem_yaml_path = find_problem_yaml()
+    if problem_yaml_path is None:
+        console.console.print(
+            f'Problem not found in {pathlib.Path().absolute()}', style='error'
+        )
+        raise typer.Exit(1)
+    res = ruyaml.YAML()
+    return res, res.load(problem_yaml_path.read_text())
+
+
 @functools.cache
 def get_problem_cache_dir(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
     cache_dir = find_problem(root) / '.box'
@@ -328,3 +341,12 @@ def get_compilation_files(code: CodeItem) -> List[Tuple[pathlib.Path, pathlib.Pa
             )
         )
     return res
+
+
+def clear_package_cache():
+    pkgs = [sys.modules[__name__]]
+
+    for pkg in pkgs:
+        for fn in pkg.__dict__.values():
+            if hasattr(fn, 'cache_clear'):
+                fn.cache_clear()

rbx/box/packaging/contest_main.py

@@ -4,9 +4,9 @@ from typing import Type
 
 import typer
 
-from rbx import annotations, console, utils
-from rbx.box import environment, package
-from rbx.box.contest import build_contest_statements, contest_package, contest_utils
+from rbx import annotations, console
+from rbx.box import cd, environment, package
+from rbx.box.contest import build_contest_statements, contest_package
 from rbx.box.packaging.main import run_packager
 from rbx.box.packaging.packager import (
     BaseContestPackager,
@@ -32,8 +32,8 @@ def run_contest_packager(
         console.console.print(
             f'Processing problem [item]{problem.short_name}[/item]...'
         )
-        with utils.new_cd(problem.get_path()):
-            contest_utils.clear_package_cache()
+        with cd.new_package_cd(problem.get_path()):
+            package.clear_package_cache()
             package_path = run_packager(packager_cls, verification=verification)
             built_packages.append(
                 BuiltProblemPackage(

rbx/box/sanitizers/warning_stack.py

@@ -0,0 +1,90 @@
+import functools
+import pathlib
+import shutil
+
+from rbx import console
+from rbx.box.schema import CodeItem
+from rbx.grading.judge.storage import Storage
+from rbx.grading.steps import GradingFileOutput
+
+
+class WarningStack:
+    def __init__(self, root: pathlib.Path):
+        self.root = root
+        self.warnings = set()
+        self.sanitizer_warnings = {}
+
+    def add_warning(self, code: CodeItem):
+        self.warnings.add(code.path)
+
+    def add_sanitizer_warning(
+        self, storage: Storage, code: CodeItem, reference: GradingFileOutput
+    ):
+        if code.path in self.sanitizer_warnings:
+            return
+        dest_path = _get_warning_runs_dir(self.root).joinpath(
+            code.path.with_suffix(code.path.suffix + '.log')
+        )
+        dest_path.parent.mkdir(parents=True, exist_ok=True)
+        f = reference.get_file(storage)
+        if f is None:
+            return
+        with dest_path.open('wb') as fout:
+            shutil.copyfileobj(f, fout)
+        f.close()
+        self.sanitizer_warnings[code.path] = dest_path
+
+    def clear(self):
+        self.warnings.clear()
+        self.sanitizer_warnings.clear()
+
+
+@functools.cache
+def _get_warning_stack(root: pathlib.Path) -> WarningStack:
+    return WarningStack(root)
+
+
+@functools.cache
+def _get_cache_dir(root: pathlib.Path) -> pathlib.Path:
+    dir = root / '.box'
+    dir.mkdir(parents=True, exist_ok=True)
+    return dir
+
+
+@functools.cache
+def _get_warning_runs_dir(root: pathlib.Path) -> pathlib.Path:
+    dir = _get_cache_dir(root) / 'warnings'
+    shutil.rmtree(dir, ignore_errors=True)
+    dir.mkdir(parents=True, exist_ok=True)
+    return dir
+
+
+def get_warning_stack() -> WarningStack:
+    current_root = pathlib.Path.cwd().resolve()
+    return _get_warning_stack(current_root)
+
+
+def print_warning_stack_report():
+    stack = get_warning_stack()
+    if not stack.warnings and not stack.sanitizer_warnings:
+        return
+    console.console.rule('[status]Warning stack[/status]')
+    console.console.print(
+        f'[warning]There were some warnings within the code that run at [item]{stack.root.absolute()}[/item][/warning]'
+    )
+    if stack.warnings:
+        console.console.print(f'{len(stack.warnings)} compilation warnings')
+        console.console.print(
+            'You can use [item]rbx compile[/item] to reproduce the issues with the files below.'
+        )
+        for path in sorted(stack.warnings):
+            console.console.print(f'- [item]{path}[/item]')
+        console.console.print()
+
+    if stack.sanitizer_warnings:
+        console.console.print(f'{len(stack.sanitizer_warnings)} sanitizer warnings')
+        for path in sorted(stack.sanitizer_warnings):
+            console.console.print(
+                f'- [item]{path}[/item], example log at [item]{stack.sanitizer_warnings[path]}[/item]'
+            )
+        console.console.print()

rbx/box/schema.py

@@ -54,6 +54,18 @@ class ExpectedOutcome(AutoEnum):
     ACCEPTED = alias('accepted', 'ac', 'correct')  # type: ignore
     """Expected outcome for correct solutions (AC)."""
 
+    ACCEPTED_OR_TLE = alias(
+        'accepted or time limit exceeded',
+        'accepted or tle',
+        'ac or tle',
+        'ac/tle',
+        'ac+tle',
+    )  # type: ignore
+    """Expected outcome for solutions that finish with either AC or TLE.
+    
+    Especially useful when you do not care about the running time of this solution, and
+    want it to not be considered when calculating the timelimit for the problem."""
+
     WRONG_ANSWER = alias('wrong answer', 'wa')  # type: ignore
     """Expected outcome for solutions that finish successfully,
     but the produced output are incorrect (WA)."""
@@ -75,7 +87,7 @@ class ExpectedOutcome(AutoEnum):
 
     TLE_OR_RTE = alias('tle or rte', 'tle/rte', 'tle+rte')  # type: ignore
     """Expected outcome for solutions that finish with either TLE or RTE.
-    
+
     Especially useful for environments where TLE and RTE are indistinguishable."""
 
     def style(self) -> str:
@@ -99,6 +111,8 @@ class ExpectedOutcome(AutoEnum):
     def match(self, outcome: Outcome) -> bool:
         if self == ExpectedOutcome.ACCEPTED:
             return outcome == Outcome.ACCEPTED
+        if self == ExpectedOutcome.ACCEPTED_OR_TLE:
+            return outcome in {Outcome.ACCEPTED, Outcome.TIME_LIMIT_EXCEEDED}
         if self == ExpectedOutcome.WRONG_ANSWER:
             return outcome == Outcome.WRONG_ANSWER
         if self == ExpectedOutcome.INCORRECT: