rbx.cp 0.5.16__tar.gz → 0.5.18__tar.gz

{rbx_cp-0.5.16 → rbx_cp-0.5.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rbx.cp
-Version: 0.5.16
+Version: 0.5.18
 Summary: 
 Author: Roberto Sales
 Requires-Python: >=3.9,<4.0
@@ -27,6 +27,7 @@ Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
 Requires-Dist: questionary (>=2.1.0,<3.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Requires-Dist: rich (>=13.9.4,<14.0.0)
+Requires-Dist: ruyaml (>=0.91.0,<0.92.0)
 Requires-Dist: textual (>=0.79.1,<0.80.0)
 Requires-Dist: typer (>=0.15.1,<0.16.0)
 Description-Content-Type: text/markdown

{rbx_cp-0.5.16 → rbx_cp-0.5.18}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rbx.cp"
-version = "0.5.16"
+version = "0.5.18"
 description = ""
 packages = [
   {include = "rbx"}
@@ -30,6 +30,7 @@ pyte = "^0.8.2"
 questionary = "^2.1.0"
 lark = "^1.2.2"
 chardet = "^5.2.0"
+ruyaml = "^0.91.0"
 
 [tool.poetry.scripts]
 rbc = "rbx.main:app"

{rbx_cp-0.5.16 → rbx_cp-0.5.18}/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_cp-0.5.16 → rbx_cp-0.5.18}/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_cp-0.5.16 → rbx_cp-0.5.18}/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_cp-0.5.16 → rbx_cp-0.5.18}/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,20 @@ 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)
+
+        # 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
 
     compiled_digest = DigestHolder()
 
@@ -104,6 +162,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 +212,29 @@ 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
+        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 +275,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_cp-0.5.18/rbx/box/compile.py

@@ -0,0 +1,82 @@
+import pathlib
+
+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)
+
+
+def _compile_out():
+    return package.get_build_path() / 'exe'
+
+
+def _compile(item: CodeItem, sanitized: SanitizationLevel, warnings: bool):
+    console.console.print(f'Compiling [item]{item.path}[/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, 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,
+            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,
+                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,
+            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,
+            sanitized=SanitizationLevel.FORCE
+            if sanitized
+            else SanitizationLevel.PREFER,
+            warnings=warnings,
+        )
+        return
+
+    _compile(
+        CodeItem(path=pathlib.Path(path)),
+        sanitized=SanitizationLevel.FORCE if sanitized else SanitizationLevel.NONE,
+        warnings=warnings,
+    )

{rbx_cp-0.5.16 → rbx_cp-0.5.18}/rbx/box/contest/build_contest_statements.py

@@ -6,8 +6,8 @@ from typing import List, Optional, Tuple
 
 import typer
 
-from rbx import console, testing_utils, utils
-from rbx.box.contest import contest_utils
+from rbx import console, testing_utils
+from rbx.box import cd, package
 from rbx.box.contest.contest_package import get_problems
 from rbx.box.contest.schema import Contest, ContestProblem, ContestStatement
 from rbx.box.schema import Package, Testcase
@@ -58,8 +58,8 @@ class ExtractedProblem:
 
 
 def _get_samples(problem: ContestProblem) -> List[Testcase]:
-    with utils.new_cd(problem.get_path()):
-        contest_utils.clear_package_cache()
+    with cd.new_package_cd(problem.get_path()):
+        package.clear_package_cache()
         return get_samples()
 
 
@@ -156,8 +156,8 @@ 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()):
-            contest_utils.clear_package_cache()
+        with cd.new_package_cd(extracted_problem.problem.get_path()):
+            package.clear_package_cache()
             # TODO: respect steps override
             content, _ = build_statements.build_statement_bytes(
                 extracted_problem.statement,
@@ -282,6 +282,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_cp-0.5.16 → rbx_cp-0.5.18}/rbx/box/contest/contest_package.py

@@ -1,11 +1,13 @@
 import functools
 import pathlib
-from typing import List, Optional
+from typing import List, Optional, Tuple
 
+import ruyaml
 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 +60,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
@@ -80,3 +82,14 @@ def get_problems(contest: Contest) -> List[Package]:
     for problem in contest.problems:
         problems.append(find_problem_package_or_die(problem.get_path()))
     return problems
+
+
+def get_ruyaml() -> Tuple[ruyaml.YAML, ruyaml.Any]:
+    contest_yaml_path = find_contest_yaml()
+    if contest_yaml_path is None:
+        console.console.print(
+            f'Contest not found in {pathlib.Path().absolute()}', style='error'
+        )
+        raise typer.Exit(1)
+    res = ruyaml.YAML()
+    return res, res.load(contest_yaml_path.read_text())

{rbx_cp-0.5.16 → rbx_cp-0.5.18}/rbx/box/contest/contest_utils.py

@@ -2,15 +2,6 @@ from rbx.box import environment, package
 from rbx.box.contest import contest_package
 
 
-def clear_package_cache():
-    pkgs = [package]
-
-    for pkg in pkgs:
-        for fn in pkg.__dict__.values():
-            if hasattr(fn, 'cache_clear'):
-                fn.cache_clear()
-
-
 def clear_all_caches():
     pkgs = [package, environment, contest_package]
 

{rbx_cp-0.5.16 → rbx_cp-0.5.18}/rbx/box/contest/main.py

@@ -7,13 +7,12 @@ import rich.prompt
 import typer
 
 from rbx import annotations, console, utils
-from rbx.box import creation, presets
-from rbx.box.contest import contest_utils, statements
+from rbx.box import cd, creation, presets
+from rbx.box.contest import contest_package, contest_utils, statements
 from rbx.box.contest.contest_package import (
     find_contest,
     find_contest_package_or_die,
     find_contest_yaml,
-    save_contest,
     within_contest,
 )
 from rbx.box.contest.schema import ContestProblem
@@ -111,7 +110,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)
 
@@ -145,16 +144,19 @@ def add(path: str, short_name: str, preset: Optional[str] = None):
     creation.create(name, preset=preset, path=pathlib.Path(path))
 
     contest = find_contest_package_or_die()
-    # Reassign mutable object before saving.
-    contest.problems = sorted(
-        [
-            *contest.problems,
-            ContestProblem(short_name=short_name, path=pathlib.Path(path)),
-        ],
-        key=lambda p: p.short_name,
+
+    ru, contest = contest_package.get_ruyaml()
+
+    contest['problems'].append(
+        {
+            'short_name': short_name,
+            'path': path,
+        }
     )
+    dest = find_contest_yaml()
+    assert dest is not None
+    utils.save_ruyaml(dest, ru, contest)
 
-    save_contest(contest)
     console.console.print(
         f'Problem [item]{name} ({short_name})[/item] added to contest at [item]{path}[/item].'
     )
@@ -165,25 +167,34 @@ def add(path: str, short_name: str, preset: Optional[str] = None):
 def remove(path_or_short_name: str):
     contest = find_contest_package_or_die()
 
-    kept_problems = []
-    removed_problems = []
-    for problem in contest.problems:
+    removed_problem_idx = None
+    removed_problem = None
+    for i, problem in enumerate(contest.problems):
         if (
             problem.path == pathlib.Path(path_or_short_name)
             or problem.short_name == path_or_short_name
         ):
-            removed_problems.append(problem)
-        else:
-            kept_problems.append(problem)
+            removed_problem_idx = i
+            removed_problem = problem
+            break
 
-    contest.problems = kept_problems
-    save_contest(contest)
-
-    for problem in removed_problems:
-        shutil.rmtree(str(problem.path), ignore_errors=True)
+    if removed_problem_idx is None or removed_problem is None:
         console.console.print(
-            f'Problem [item]{problem.short_name}[/item] removed from contest at [item]{problem.path}[/item].'
+            f'[error]Problem [item]{path_or_short_name}[/item] not found in contest.[/error]'
         )
+        raise typer.Exit(1)
+
+    ru, contest = contest_package.get_ruyaml()
+
+    del contest['problems'][removed_problem_idx]
+    dest = find_contest_yaml()
+    assert dest is not None
+    utils.save_ruyaml(dest, ru, contest)
+
+    shutil.rmtree(str(removed_problem.path), ignore_errors=True)
+    console.console.print(
+        f'Problem [item]{removed_problem.short_name}[/item] removed from contest at [item]{removed_problem.path}[/item].'
+    )
 
 
 @app.command(