rbx.cp 0.5.15__py3-none-any.whl → 0.5.17__py3-none-any.whl

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)
@@ -387,8 +544,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

@@ -6,7 +6,7 @@ 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 +102,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

rbx/box/packaging/contest_main.py

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

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:

rbx/box/setter_config.py

@@ -0,0 +1,132 @@
+import functools
+import importlib
+import importlib.resources
+import pathlib
+import shlex
+import sys
+from typing import Dict
+
+import typer
+from pydantic import BaseModel, Field
+
+from rbx import config, console, utils
+
+app = typer.Typer(no_args_is_help=True)
+
+_CONFIG_FILE_NAME = 'default_setter_config.yml'
+_CONFIG_FILE_NAME_MAC = 'default_setter_config.mac.yml'
+
+
+class SanitizersConfig(BaseModel):
+    enabled: bool = Field(
+        False,
+        description='Whether to use sanitizers when running solutions.',
+    )
+
+    command_substitutions: Dict[str, str] = Field(
+        {},
+        description='Substitutions to apply to commands before running them with sanitizers.',
+    )
+
+
+class WarningsConfig(BaseModel):
+    enabled: bool = Field(
+        False,
+        description='Whether to use warning flags when running solutions.',
+    )
+
+
+class SetterConfig(BaseModel):
+    sanitizers: SanitizersConfig = Field(
+        default_factory=SanitizersConfig,  # type: ignore
+        description='Configuration for sanitizers.',
+    )
+    warnings: WarningsConfig = Field(
+        default_factory=WarningsConfig,  # type: ignore
+        description='Configuration for warnings.',
+    )
+
+    command_substitutions: Dict[str, str] = Field(
+        {},
+        description='Substitutions to apply to commands before running them.',
+    )
+
+    def substitute_command(self, command: str, sanitized: bool = False) -> str:
+        exe = shlex.split(command)[0]
+        if sanitized and exe in self.sanitizers.command_substitutions:
+            exe = self.sanitizers.command_substitutions[exe]
+            return ' '.join([exe, *shlex.split(command)[1:]])
+        if exe in self.command_substitutions:
+            exe = self.command_substitutions[exe]
+            return ' '.join([exe, *shlex.split(command)[1:]])
+        return command
+
+
+def get_default_setter_config_path() -> pathlib.Path:
+    cfg_name = _CONFIG_FILE_NAME
+    if sys.platform == 'darwin':
+        cfg_name = _CONFIG_FILE_NAME_MAC
+
+    with importlib.resources.as_file(
+        importlib.resources.files('rbx') / 'resources' / cfg_name
+    ) as file:
+        return file
+
+
+def get_default_setter_config() -> SetterConfig:
+    return utils.model_from_yaml(
+        SetterConfig, get_default_setter_config_path().read_text()
+    )
+
+
+def get_setter_config_path() -> pathlib.Path:
+    return config.get_app_path() / 'setter_config.yml'
+
+
+@functools.cache
+def get_setter_config() -> SetterConfig:
+    config_path = get_setter_config_path()
+    if not config_path.is_file():
+        utils.create_and_write(
+            config_path, get_default_setter_config_path().read_text()
+        )
+    return utils.model_from_yaml(SetterConfig, config_path.read_text())
+
+
+def save_setter_config(config: SetterConfig):
+    config_path = get_setter_config_path()
+    config_path.write_text(utils.model_to_yaml(config))
+    get_setter_config.cache_clear()
+
+
+@app.command(help='Show the path to the setter config.')
+def path():
+    print(get_setter_config_path())
+
+
+@app.command('list, ls')
+def list():
+    """
+    Pretty print the config file.
+    """
+    console.console.print_json(utils.model_json(get_setter_config()))
+
+
+@app.command(help='Open the setter config in an editor.')
+def edit():
+    # Ensure config is created before calling the editor.
+    get_setter_config()
+
+    config.open_editor(get_setter_config_path())
+
+
+@app.command()
+def reset():
+    """
+    Reset the config file to the default one.
+    """
+    if not typer.confirm('Do you really want to reset your config to the default one?'):
+        return
+    cfg_path = get_setter_config_path()
+    cfg_path.unlink(missing_ok=True)
+    get_setter_config()  # Reset the config.