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

rbx/box/builder.py

@@ -76,7 +76,7 @@ def build(
     return True
 
 
-def verify(verification: environment.VerificationParam) -> bool:
+async def verify(verification: environment.VerificationParam) -> bool:
     if not build(verification=verification):
         return False
 
@@ -100,7 +100,7 @@ def verify(verification: environment.VerificationParam) -> bool:
 
     console.console.print()
     console.console.rule('[status]Run report[/status]', style='status')
-    return print_run_report(
+    return await print_run_report(
         solution_result,
         console.console,
         verification,

rbx/box/cd.py

@@ -1,10 +1,13 @@
+import contextlib
 import functools
 import pathlib
 from typing import Optional
 
 import typer
 
-from rbx import console, utils
+from rbx import console
+from rbx.box.sanitizers import warning_stack
+from rbx.utils import new_cd
 
 
 def find_package(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Path]:
@@ -30,7 +33,14 @@ def within_closest_package(func):
             console.console.print('[error]No rbx package found.[/error]')
             raise typer.Exit(1)
         # Get deepest package.
-        with utils.new_cd(package):
+        with new_package_cd(package):
             return func(*args, **kwargs)
 
     return wrapper
+
+
+@contextlib.contextmanager
+def new_package_cd(x: pathlib.Path):
+    with new_cd(x):
+        yield
+        warning_stack.print_warning_stack_report()

rbx/box/checkers.py

@@ -5,7 +5,7 @@ import typer
 
 from rbx import console
 from rbx.box import package
-from rbx.box.code import compile_item, run_item
+from rbx.box.code import SanitizationLevel, compile_item, run_item
 from rbx.box.schema import Testcase
 from rbx.grading.judge.sandbox import SandboxBase
 from rbx.grading.steps import (
@@ -23,7 +23,7 @@ def compile_checker() -> str:
     checker = package.get_checker()
 
     try:
-        digest = compile_item(checker)
+        digest = compile_item(checker, sanitized=SanitizationLevel.PREFER)
     except Exception as e:
         console.console.print('[error]Failed compiling checker.[/error]')
         raise typer.Exit(1) from e
@@ -33,11 +33,21 @@ def compile_checker() -> str:
 def _check_pre_output(run_log: Optional[RunLog]) -> CheckerResult:
     pkg = package.find_problem_package_or_die()
 
+    is_sanitized = (
+        run_log is not None
+        and run_log.metadata is not None
+        and run_log.metadata.is_sanitized
+    )
+
     if run_log is None:
         return CheckerResult(outcome=Outcome.INTERNAL_ERROR)
 
     timelimit = pkg.timelimit_for_language(run_log.get_run_language())
-    if run_log.time is not None and run_log.time * 1000 > timelimit * 2:
+    if (
+        run_log.time is not None
+        and run_log.time * 1000 > timelimit * 2
+        and not is_sanitized
+    ):
         return CheckerResult(outcome=Outcome.TIME_LIMIT_EXCEEDED)
 
     if run_log.exitstatus in [SandboxBase.EXIT_SIGNAL, SandboxBase.EXIT_NONZERO_RETURN]:
@@ -58,11 +68,17 @@ def _convert_tle(result: CheckerResult, run_log: Optional[RunLog]) -> CheckerRes
         # This already is a TLE outcome.
         return result
     pkg = package.find_problem_package_or_die()
+    is_sanitized = (
+        run_log is not None
+        and run_log.metadata is not None
+        and run_log.metadata.is_sanitized
+    )
     if (
         run_log is not None
         and run_log.time is not None
         and run_log.time * 1000
         >= pkg.timelimit_for_language(run_log.get_run_language())
+        and not is_sanitized
     ):
         # Soft TLE.
         result.no_tle_outcome = result.outcome
@@ -75,7 +91,7 @@ def check_with_no_output(run_log: Optional[RunLog]) -> CheckerResult:
     return _convert_tle(result, run_log)
 
 
-def check(
+def _check(
     checker_digest: str,
     run_log: Optional[RunLog],
     testcase: Testcase,
@@ -157,3 +173,21 @@ def check(
     if skip_run_log:
         return result
     return _convert_tle(result, run_log)
+
+
+def _check_sanitizer_warnings(run_log: Optional[RunLog]) -> bool:
+    if run_log is None:
+        return False
+    return run_log.warnings
+
+
+def check(
+    checker_digest: str,
+    run_log: Optional[RunLog],
+    testcase: Testcase,
+    program_output: pathlib.Path,
+    skip_run_log: bool = False,
+) -> CheckerResult:
+    result = _check(checker_digest, run_log, testcase, program_output, skip_run_log)
+    result.sanitizer_warnings = _check_sanitizer_warnings(run_log)
+    return result

rbx/box/code.py

@@ -1,17 +1,19 @@
 import pathlib
 import shlex
-import sys
+from enum import Enum
 from pathlib import PosixPath
 from typing import List, Optional
 
+import rich
+import rich.text
 import typer
 
-from rbx.box import download, package
+from rbx import console
+from rbx.box import download, package, setter_config
 from rbx.box.environment import (
     ExecutionConfig,
     get_compilation_config,
     get_execution_config,
-    get_extension_or_default,
     get_file_mapping,
     get_language,
     get_mapped_command,
@@ -19,7 +21,7 @@ from rbx.box.environment import (
     get_sandbox_params_from_config,
     merge_execution_configs,
 )
-from rbx.box.extensions import MacExtension
+from rbx.box.sanitizers import warning_stack
 from rbx.box.schema import CodeItem
 from rbx.grading import steps_with_caching
 from rbx.grading.steps import (
@@ -31,17 +33,25 @@ from rbx.grading.steps import (
     GradingFileOutput,
     RunLog,
     RunLogMetadata,
+    is_cxx_command,
 )
 
 
-def normalize_for_macos(commands: List[str]) -> List[str]:
-    def normalize(command: str) -> str:
-        extension = get_extension_or_default('mac', MacExtension)
-        if extension.gpp_alternative is None:
-            return command
-        return command.replace('g++', extension.gpp_alternative)
+class SanitizationLevel(Enum):
+    NONE = 0
+    PREFER = 1
+    FORCE = 2
 
-    return [normalize(command) for command in commands]
+    def should_sanitize(self) -> bool:
+        cfg = setter_config.get_setter_config()
+        if cfg.sanitizers.enabled:
+            return self.value >= SanitizationLevel.PREFER.value
+        return self.value >= SanitizationLevel.FORCE.value
+
+
+def substitute_commands(commands: List[str], sanitized: bool = False) -> List[str]:
+    cfg = setter_config.get_setter_config()
+    return [cfg.substitute_command(command, sanitized) for command in commands]
 
 
 def get_extension(code: CodeItem) -> str:
@@ -55,8 +65,46 @@ def find_language_name(code: CodeItem) -> str:
     return get_language(get_extension(code)).name
 
 
+def is_executable_sanitized(executable: DigestOrSource) -> bool:
+    if executable.digest is None:
+        return False
+    storage = package.get_cache_storage()
+    return storage.exists(f'{executable.digest.value}.san')
+
+
+def add_sanitizer_flags_to_command(command: str) -> str:
+    if is_cxx_command(command):
+        return command + ' -fsanitize=address,undefined -fno-omit-frame-pointer'
+    return command
+
+
+def add_sanitizer_flags(commands: List[str]) -> List[str]:
+    return [add_sanitizer_flags_to_command(command) for command in commands]
+
+
+def add_warning_flags_to_command(command: str) -> str:
+    if is_cxx_command(command):
+        return (
+            command
+            + ' -Wall -Wshadow -Wno-unused-result -Wno-sign-compare -Wno-char-subscripts'
+        )
+    return command
+
+
+def add_warning_flags(commands: List[str], force_warnings: bool) -> List[str]:
+    cfg = setter_config.get_setter_config()
+    if cfg.warnings.enabled or force_warnings:
+        return [add_warning_flags_to_command(command) for command in commands]
+    return commands
+
+
 # Compile code item and return its digest in the storage.
-def compile_item(code: CodeItem) -> str:
+def compile_item(
+    code: CodeItem,
+    sanitized: SanitizationLevel = SanitizationLevel.PREFER,
+    force_warnings: bool = False,
+    verbose: bool = False,
+) -> str:
     generator_path = PosixPath(code.path)
     language = find_language_name(code)
     compilation_options = get_compilation_config(language)
@@ -69,10 +117,12 @@ def compile_item(code: CodeItem) -> str:
         # Language is not compiled.
         return sandbox.file_cacher.put_file_from_path(generator_path)
 
-    # Compile the generator
     commands = get_mapped_commands(compilation_options.commands, file_mapping)
-    if sys.platform == 'darwin':
-        commands = normalize_for_macos(commands)
+    commands = add_warning_flags(commands, force_warnings)
+    commands = substitute_commands(commands, sanitized=sanitized.should_sanitize())
+
+    if sanitized.should_sanitize():
+        commands = add_sanitizer_flags(commands)
 
     compiled_digest = DigestHolder()
 
@@ -104,6 +154,33 @@ def compile_item(code: CodeItem) -> str:
         raise typer.Exit(1)
 
     assert compiled_digest.value is not None
+
+    if verbose and artifacts.logs is not None and artifacts.logs.preprocess is not None:
+        for log in artifacts.logs.preprocess:
+            console.console.print(f'[status]Command:[/status] {log.get_command()}')
+            console.console.print(f'[status]Summary:[/status] {log.get_summary()}')
+            console.console.print(rich.text.Text.from_ansi(log.log), style='default')
+
+    # Write compiler warnings.
+    cfg = setter_config.get_setter_config()
+    if (
+        (cfg.warnings.enabled or force_warnings)
+        and artifacts.logs is not None
+        and artifacts.logs.preprocess is not None
+    ):
+        any_warning = any(log.warnings for log in artifacts.logs.preprocess)
+        if any_warning:
+            warning_stack.get_warning_stack().add_warning(code)
+
+    # Create sentinel to indicate this executable is sanitized.
+    storage = package.get_cache_storage()
+    if sanitized.should_sanitize():
+        pf = storage.create_file(f'{compiled_digest.value}.san')
+        if pf is not None:
+            storage.commit_file(pf)
+    elif storage.exists(f'{compiled_digest.value}.san'):
+        storage.delete(f'{compiled_digest.value}.san')
+
     return compiled_digest.value
 
 
@@ -127,14 +204,35 @@ def run_item(
     sandbox = package.get_singleton_sandbox()
     sandbox_params = get_sandbox_params_from_config(execution_options.sandbox)
 
+    # Sanitization parameters.
+    sanitized = False
+    if is_executable_sanitized(executable):
+        # Remove any memory constraints for a sanitized executable.
+        # Sanitizers are known to be memory-hungry.
+        sandbox_params.address_space = None
+
+        # Reset timeout configs since sanitizers are known to be time-hungry.
+        sandbox_params.timeout = None
+        sandbox_params.wallclock_timeout = None
+        orig_execution_config = get_execution_config(language)
+        if orig_execution_config.sandbox is not None:
+            sandbox_params.timeout = orig_execution_config.sandbox.timeLimit
+            sandbox_params.wallclock_timeout = (
+                orig_execution_config.sandbox.wallTimeLimit
+            )
+        sanitized = True
+
     sandbox_params.set_stdall(
         stdin=PosixPath(file_mapping.input) if stdin is not None else None,
         stdout=PosixPath(file_mapping.output) if stdout is not None else None,
-        stderr=PosixPath(file_mapping.error) if stderr is not None else None,
+        stderr=PosixPath(file_mapping.error)
+        if stderr is not None or sanitized
+        else None,
     )
 
     assert execution_options.command
     command = get_mapped_command(execution_options.command, file_mapping)
+    command = substitute_commands([command], sanitized=sanitized)[0]
 
     if extra_args is not None:
         splitted_command = shlex.split(command)
@@ -175,11 +273,21 @@ def run_item(
     if outputs:
         artifacts.outputs.extend(outputs)
 
-    return steps_with_caching.run(
+    run_log = steps_with_caching.run(
         command,
         params=sandbox_params,
         sandbox=sandbox,
         artifacts=artifacts,
         dependency_cache=dependency_cache,
-        metadata=RunLogMetadata(language=code.language),
+        metadata=RunLogMetadata(language=code.language, is_sanitized=sanitized),
     )
+
+    # Find sanitizer logs.
+    if run_log is not None and run_log.warnings:
+        assert sandbox_params.stderr_file is not None
+        stderr_output = artifacts.get_output_file_for_src(sandbox_params.stderr_file)
+        if stderr_output is not None:
+            warning_stack.get_warning_stack().add_sanitizer_warning(
+                package.get_cache_storage(), code, stderr_output
+            )
+    return run_log

rbx/box/compile.py

@@ -4,6 +4,8 @@ import typer
 
 from rbx import annotations, console
 from rbx.box import code, package
+from rbx.box.code import SanitizationLevel
+from rbx.box.sanitizers import warning_stack
 from rbx.box.schema import CodeItem
 
 app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
@@ -13,38 +15,68 @@ def _compile_out():
     return package.get_build_path() / 'exe'
 
 
-def _compile(item: CodeItem):
+def _compile(item: CodeItem, sanitized: SanitizationLevel, warnings: bool):
     console.console.print(f'Compiling [item]{item.path}[/item]...')
-    digest = code.compile_item(item)
+    digest = code.compile_item(item, sanitized, force_warnings=warnings, verbose=True)
     cacher = package.get_file_cacher()
     out_path = _compile_out()
     cacher.get_file_to_path(digest, out_path)
     out_path.chmod(0o755)
 
+    # Clear the warning stack as we don't really worry about it when running
+    # `rbx compile`.
+    warning_stack.get_warning_stack().clear()
+
     console.console.print(
         f'[success]Compiled file written at [item]{out_path}[/item][/success]'
     )
 
 
-def any(path: str):
+def any(path: str, sanitized: bool = False, warnings: bool = False):
     pkg = package.find_problem_package_or_die()
 
     solution = package.get_solution_or_nil(path)
     if solution is not None:
-        _compile(solution)
+        _compile(
+            solution,
+            sanitized=SanitizationLevel.FORCE if sanitized else SanitizationLevel.NONE,
+            warnings=warnings,
+        )
         return
 
     for generator in pkg.generators:
         if generator.path == pathlib.Path(path) or generator.name == path:
-            _compile(generator)
+            _compile(
+                generator,
+                sanitized=SanitizationLevel.FORCE
+                if sanitized
+                else SanitizationLevel.PREFER,
+                warnings=warnings,
+            )
             return
 
     if pkg.checker is not None and pkg.checker.path == pathlib.Path(path):
-        _compile(pkg.checker)
+        _compile(
+            pkg.checker,
+            sanitized=SanitizationLevel.FORCE
+            if sanitized
+            else SanitizationLevel.PREFER,
+            warnings=warnings,
+        )
         return
 
     if pkg.validator is not None and pkg.validator.path == pathlib.Path(path):
-        _compile(pkg.validator)
+        _compile(
+            pkg.validator,
+            sanitized=SanitizationLevel.FORCE
+            if sanitized
+            else SanitizationLevel.PREFER,
+            warnings=warnings,
+        )
         return
 
-    _compile(CodeItem(path=pathlib.Path(path)))
+    _compile(
+        CodeItem(path=pathlib.Path(path)),
+        sanitized=SanitizationLevel.FORCE if sanitized else SanitizationLevel.NONE,
+        warnings=warnings,
+    )

rbx/box/contest/build_contest_statements.py

@@ -6,7 +6,8 @@ from typing import List, Optional, Tuple
 
 import typer
 
-from rbx import console, testing_utils, utils
+from rbx import console, testing_utils
+from rbx.box import cd
 from rbx.box.contest import contest_utils
 from rbx.box.contest.contest_package import get_problems
 from rbx.box.contest.schema import Contest, ContestProblem, ContestStatement
@@ -58,7 +59,7 @@ class ExtractedProblem:
 
 
 def _get_samples(problem: ContestProblem) -> List[Testcase]:
-    with utils.new_cd(problem.get_path()):
+    with cd.new_package_cd(problem.get_path()):
         contest_utils.clear_package_cache()
         return get_samples()
 
@@ -156,7 +157,7 @@ def _build_problem_statements(
         console.console.print(
             f'Building statement for problem {extracted_problem.problem.short_name}...'
         )
-        with utils.new_cd(extracted_problem.problem.get_path()):
+        with cd.new_package_cd(extracted_problem.problem.get_path()):
             contest_utils.clear_package_cache()
             # TODO: respect steps override
             content, _ = build_statements.build_statement_bytes(
@@ -282,6 +283,7 @@ def build_statement_rooted(
 
     if joiner is None:
         return last_content, last_output
+    assert statement.joiner is not None
 
     # Join statements.
     console.console.print('Joining statements...')

rbx/box/contest/contest_package.py

@@ -6,6 +6,7 @@ import typer
 from pydantic import ValidationError
 
 from rbx import console, utils
+from rbx.box import cd
 from rbx.box.contest.schema import Contest
 from rbx.box.package import find_problem_package_or_die, warn_preset_deactivated
 from rbx.box.schema import Package
@@ -58,7 +59,7 @@ def find_contest(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
 def within_contest(func):
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
-        with utils.new_cd(find_contest()):
+        with cd.new_package_cd(find_contest()):
             return func(*args, **kwargs)
 
     return wrapper

rbx/box/contest/main.py

@@ -7,7 +7,7 @@ import rich.prompt
 import typer
 
 from rbx import annotations, console, utils
-from rbx.box import creation, presets
+from rbx.box import cd, creation, presets
 from rbx.box.contest import contest_utils, statements
 from rbx.box.contest.contest_package import (
     find_contest,
@@ -111,7 +111,7 @@ def create(
     if local:
         shutil.copytree(str(preset_path), str(dest_path / '.local.rbx'))
 
-    with utils.new_cd(dest_path):
+    with cd.new_package_cd(dest_path):
         contest_utils.clear_all_caches()
         presets.generate_lock(preset if not local else presets.LOCAL)
 

rbx/box/contest/statements.py

@@ -2,8 +2,8 @@ from typing import Annotated, List, Optional
 
 import typer
 
-from rbx import annotations, console, utils
-from rbx.box import builder, environment
+from rbx import annotations, console
+from rbx.box import builder, cd, environment
 from rbx.box.contest import contest_utils
 from rbx.box.contest.build_contest_statements import build_statement
 from rbx.box.contest.contest_package import (
@@ -49,7 +49,7 @@ def build(
             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()
 
                 if not builder.build(

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(