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

rbx/box/solutions_test.py

@@ -1,3 +1,4 @@
+import asyncio
 import pathlib
 
 import pytest
@@ -20,7 +21,7 @@ def test_solutions(pkg_from_testdata: pathlib.Path):
     generate_outputs_for_testcases()
 
     result = run_solutions(verification=VerificationLevel.FULL)
-    res = convert_list_of_solution_evaluations_to_dict(result.items)
+    res = asyncio.run(convert_list_of_solution_evaluations_to_dict(result.items))
 
     # First solution should pass all tests.
     assert all(chk.result.outcome == Outcome.ACCEPTED for chk in res[0]['gen1'])

rbx/box/stresses.py

@@ -8,7 +8,7 @@ from pydantic import BaseModel
 
 from rbx import console
 from rbx.box import checkers, package, validators
-from rbx.box.code import compile_item, run_item
+from rbx.box.code import SanitizationLevel, compile_item, run_item
 from rbx.box.generators import generate_standalone
 from rbx.box.schema import CodeItem, GeneratorCall, Stress, Testcase
 from rbx.box.solutions import compile_solutions, get_outcome_style_verdict
@@ -49,6 +49,7 @@ def run_stress(
     findingsLimit: int = 1,
     verbose: bool = False,
     progress: Optional[StatusProgress] = None,
+    sanitized: bool = False,
 ) -> StressReport:
     if finder:
         stress = Stress(
@@ -63,7 +64,7 @@ def run_stress(
     generator = package.get_generator(call.name)
 
     try:
-        generator_digest = compile_item(generator)
+        generator_digest = compile_item(generator, sanitized=SanitizationLevel.PREFER)
     except:
         console.console.print(
             f'[error]Failed compiling generator [item]{generator.name}[/item].[/error]'
@@ -79,7 +80,8 @@ def run_stress(
 
     solution_indices = {str(solution.path): i for i, solution in enumerate(solutions)}
     solutions_digest = compile_solutions(
-        tracked_solutions=set(str(solution.path) for solution in solutions)
+        tracked_solutions=set(str(solution.path) for solution in solutions),
+        sanitized=sanitized,
     )
     if progress:
         progress.update('Compiling finders...')

rbx/box/validators.py

@@ -1,13 +1,13 @@
 import pathlib
 import shlex
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Dict, Iterable, List, Optional, Set, Tuple
 
 import typer
 from pydantic import BaseModel
 
 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 CodeItem, Primitive
 from rbx.box.testcases import find_built_testcase_inputs
 from rbx.grading.judge.sandbox import SandboxBase
@@ -32,7 +32,7 @@ class TestcaseValidationInfo(BaseModel):
 
 def _compile_validator(validator: CodeItem) -> str:
     try:
-        digest = compile_item(validator)
+        digest = compile_item(validator, sanitized=SanitizationLevel.PREFER)
     except:
         console.console.print(
             f'[error]Failed compiling validator [item]{validator.path}[/item][/error]'
@@ -65,7 +65,7 @@ def _process_bounds(log: str) -> HitBounds:
     return bounds
 
 
-def _merge_hit_bounds(hit_bounds: List[HitBounds]) -> HitBounds:
+def _merge_hit_bounds(hit_bounds: Iterable[HitBounds]) -> HitBounds:
     res: HitBounds = {}
     for hb in hit_bounds:
         for k, hit in hb.items():
@@ -241,7 +241,7 @@ def has_validation_errors(infos: List[TestcaseValidationInfo]) -> bool:
 
 def print_validation_report(infos: List[TestcaseValidationInfo]):
     console.console.rule('Validation report', style='status')
-    hit_bounds_per_group: Dict[str, HitBounds] = {}
+    hit_bounds_per_group: Dict[Optional[str], HitBounds] = {}
     for info in infos:
         if not info.ok:
             console.console.print(

rbx/config.py

@@ -268,4 +268,7 @@ def edit():
     """
     Open the config in an editor.
     """
+    # Ensure config is created before calling the editor.
+    get_config()
+
     open_editor(get_config_path())

rbx/grading/caching.py

@@ -334,6 +334,10 @@ class DependencyCache:
         for logs, reference_logs in zip(fingerprint.logs, reference_fingerprint.logs):
             if logs.run is not None:
                 reference_logs.run = logs.run.model_copy(deep=True)
+            if logs.preprocess is not None:
+                reference_logs.preprocess = [
+                    log.model_copy(deep=True) for log in logs.preprocess
+                ]
             reference_logs.cached = True
 
         return True

rbx/grading/judge/sandboxes/stupid_sandbox.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import importlib
 import importlib.resources
 import logging
+import os
 import pathlib
 import shutil
 import signal
@@ -291,6 +292,7 @@ class StupidSandbox(SandboxBase):
             stdin=subprocess.PIPE,
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
+            env={**os.environ, **self.params.set_env},
         )
         self.hydrate_logs()
         return self.translate_box_exitcode(self.returncode)

rbx/grading/judge/sandboxes/timeit.py

@@ -200,14 +200,14 @@ def main():
                 os.kill(sub_pid, 9)
                 return
 
-        signal.alarm(1)
+        signal.setitimer(signal.ITIMER_REAL, 0.3)
 
-    signal.alarm(1)
+    signal.setitimer(signal.ITIMER_REAL, 0.3)
     signal.signal(signal.SIGALRM, handle_alarm)
     wait_and_finish(sub_pid, options, start_time, alarm_msg=alarm_msg)
 
     # Cancel alarm before exiting to avoid surprises.
-    signal.alarm(0)
+    signal.setitimer(signal.ITIMER_REAL, 0)
 
     # Exit gracefully.
     sys.exit()

rbx/grading/steps.py

@@ -1,12 +1,14 @@
 import functools
-import os
 import pathlib
+import re
 import shlex
 import shutil
 import subprocess
+import sys
 from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import IO, Any, Dict, List, Optional, Tuple, Union
 
+import typer
 from pydantic import BaseModel
 from rich.text import Text
 
@@ -14,7 +16,7 @@ from rbx import utils
 from rbx.config import get_bits_stdcpp, get_jngen, get_testlib
 from rbx.console import console
 from rbx.grading.judge.sandbox import SandboxBase, SandboxParams
-from rbx.grading.judge.storage import copyfileobj
+from rbx.grading.judge.storage import Storage, copyfileobj
 
 MAX_STDOUT_LEN = 1024 * 1024 * 128  # 128 MB
 
@@ -36,6 +38,7 @@ class DigestHolder(BaseModel):
 
 class GradingLogsHolder(BaseModel):
     run: Optional['RunLog'] = None
+    preprocess: Optional[List['PreprocessLog']] = None
     cached: bool = False
 
 
@@ -114,6 +117,17 @@ class GradingFileOutput(BaseModel):
     # Whether to track file through its hash (disable for optimization).
     hash: bool = True
 
+    def get_file(self, storage: Storage) -> Optional[IO[bytes]]:
+        if self.dest is not None:
+            if self.optional and not self.dest.exists():
+                return None
+            return self.dest.open('rb')
+        if self.digest is not None and self.digest.value is not None:
+            if self.optional and not storage.exists(self.digest.value):
+                return None
+            return storage.get_file(self.digest.value)
+        raise ValueError('No file to get')
+
 
 class GradingArtifacts(BaseModel):
     # Root directory for the produced artifacts.
@@ -125,6 +139,18 @@ class GradingArtifacts(BaseModel):
     # Capture certain logs of the execution.
     logs: Optional[GradingLogsHolder] = None
 
+    def get_input_file_for_dest(self, dest: pathlib.Path) -> Optional[GradingFileInput]:
+        for input in self.inputs:
+            if input.dest == dest:
+                return input
+        return None
+
+    def get_output_file_for_src(self, src: pathlib.Path) -> Optional[GradingFileOutput]:
+        for output in self.outputs:
+            if output.src == src:
+                return output
+        return None
+
 
 class TestcaseIO(BaseModel):
     index: int
@@ -134,6 +160,7 @@ class TestcaseIO(BaseModel):
 
 class RunLogMetadata(BaseModel):
     language: Optional[str] = None
+    is_sanitized: bool = False
 
 
 class RunLog(BaseModel):
@@ -141,6 +168,7 @@ class RunLog(BaseModel):
     exitstatus: str = SandboxBase.EXIT_SANDBOX_ERROR
     time: Optional[float] = 0.0
     memory: Optional[int] = 0
+    warnings: bool = False
     metadata: Optional[RunLogMetadata] = None
 
     def get_run_language(self) -> Optional[str]:
@@ -160,6 +188,9 @@ class PreprocessLog(RunLog):
     cmd: List[str]
     log: str
 
+    def get_command(self) -> str:
+        return ' '.join(self.cmd)
+
 
 class TestcaseLog(RunLog):
     stdout_absolute_path: Optional[pathlib.Path] = None
@@ -171,6 +202,7 @@ class CheckerResult(BaseModel):
     outcome: Outcome
     message: str = ''
     no_tle_outcome: Optional[Outcome] = None
+    sanitizer_warnings: bool = False
 
 
 class Evaluation(BaseModel):
@@ -260,11 +292,25 @@ def _split_and_expand(command: str, sandbox: SandboxBase) -> List[str]:
 
 
 def _is_c_command(exe_command: str) -> bool:
-    return exe_command.endswith('gcc') or exe_command.endswith('clang')
+    return 'gcc' in exe_command or 'clang' in exe_command
 
 
 def _is_cpp_command(exe_command: str) -> bool:
-    return exe_command.endswith('g++') or exe_command.endswith('clang++')
+    return 'g++' in exe_command or 'clang++' in exe_command
+
+
+def is_cxx_command(exe_command: str) -> bool:
+    return _is_cpp_command(exe_command) or _is_c_command(exe_command)
+
+
+def is_cxx_sanitizer_command(command: str) -> bool:
+    cmds = shlex.split(command)
+    if not cmds:
+        return False
+    exe = cmds[0]
+    if not is_cxx_command(exe):
+        return False
+    return 'fsanitize' in command
 
 
 @functools.cache
@@ -279,27 +325,35 @@ def _complain_about_clang() -> None:
     )
 
 
-def _maybe_get_bits_stdcpp_for_clang(command: str) -> Optional[GradingFileInput]:
+def _get_cxx_version_output(command: str) -> Optional[str]:
     cmds = shlex.split(command)
     if not cmds:
         return None
     exe = cmds[0]
-
-    if not _is_cpp_command(exe):
+    if not is_cxx_command(exe):
         return None
 
+    exe = cmds[0]
     output = subprocess.run([exe, '-v'], capture_output=True)
     if output.returncode != 0:
-        console.print('[error]Failed to get g++/clang compiler version.[/error]')
+        console.print('[error]Failed to get C/C++ compiler version.[/error]')
         return None
-    lines = output.stderr.decode().splitlines()
+    return output.stderr.decode()
+
+
+def _maybe_get_bits_stdcpp_for_clang(command: str) -> Optional[GradingFileInput]:
+    version_output = _get_cxx_version_output(command)
+    if version_output is None:
+        return None
+    lines = version_output.splitlines()
     if not lines:
         return None
     # Check the first line for `clang`.
     if 'clang' not in lines[0]:
         return None
 
-    _complain_about_clang()
+    if not is_cxx_sanitizer_command(command):
+        _complain_about_clang()
     bits = get_bits_stdcpp()
     return GradingFileInput(src=bits, dest=pathlib.Path('bits/stdc++.h'))
 
@@ -316,10 +370,6 @@ def _maybe_get_bits_stdcpp_for_commands(
 
 @functools.cache
 def _try_following_alias_for_exe(exe: str) -> Optional[str]:
-    if _is_c_command(exe) and os.environ.get('RBX_C_PATH'):
-        return os.environ['RBX_C_PATH']
-    if _is_cpp_command(exe) and os.environ.get('RBX_CXX_PATH'):
-        return os.environ['RBX_CXX_PATH']
     output = subprocess.run(
         f'which {exe}', shell=True, executable=shutil.which('bash'), capture_output=True
     )
@@ -346,6 +396,74 @@ def _try_following_alias_for_commands(commands: List[str]) -> List[str]:
     return res
 
 
+@functools.cache
+def _maybe_complain_about_sanitization(command: str) -> None:
+    if not is_cxx_sanitizer_command(command):
+        return
+    if sys.platform != 'darwin':
+        return
+
+    version_output = _get_cxx_version_output(command)
+    if version_output is None:
+        return
+    lines = version_output.splitlines()
+    if not lines:
+        return
+    if 'gcc' in lines[-1]:
+        console.print(
+            '[error]Notice you are using sanitizers in [item]MacOS[/item], but your C/C++ compiler is [item]gcc[/item].[/error]'
+        )
+        console.print('[error]GCC does not support sanitization in MacOS.[/error]')
+        console.print(
+            '[warning]See [item]https://rsalesc.github.io/rbx/cpp-on-macos[/item] for instructions on how to use C/C++ sanitizers on MacOS.[/warning]'
+        )
+        raise typer.Exit(1)
+
+
+def _check_for_sanitizer_warnings_in_line(line: str) -> bool:
+    line = line.lower()
+    return 'runtime error:' in line or '==error' in line
+
+
+def _check_for_sanitizer_warnings(
+    sandbox: SandboxBase, stderr_file: Optional[pathlib.Path]
+) -> bool:
+    if stderr_file is None:
+        return False
+    if not sandbox.file_exists(stderr_file):
+        return False
+    with sandbox.get_file(stderr_file) as f:
+        return any(_check_for_sanitizer_warnings_in_line(line.decode()) for line in f)
+
+
+_WARNING_RE = re.compile(r'[^:]+:\d+:\d+:[ ]+warning:.*')
+
+
+def _check_for_compilation_warnings_in_line(line: str) -> bool:
+    if line.startswith('./'):
+        return False
+    matched = _WARNING_RE.match(line) is not None
+    # if matched:
+    #     console.print(
+    #         '[warning]Compilation warning:[/warning]',
+    #         utils.highlight_json_obj(line),
+    #     )
+    return matched
+
+
+def _check_for_compilation_warnings(
+    sandbox: SandboxBase, stderr_file: Optional[pathlib.Path]
+) -> bool:
+    if stderr_file is None:
+        return False
+    if not sandbox.file_exists(stderr_file):
+        return False
+    with sandbox.get_file(stderr_file) as f:
+        return any(
+            _check_for_compilation_warnings_in_line(line.strip().decode()) for line in f
+        )
+
+
 def compile(
     commands: List[str],
     params: SandboxParams,
@@ -366,6 +484,7 @@ def compile(
     sandbox.set_params(params)
 
     for i, command in enumerate(commands):
+        _maybe_complain_about_sanitization(command)
         cmd = _split_and_expand(command, sandbox)
         stdout_file = pathlib.PosixPath(f'compile-{i}.stdout')
         stderr_file = pathlib.PosixPath(f'compile-{i}.stderr')
@@ -399,6 +518,7 @@ def compile(
             exitstatus=sandbox.get_exit_status(),
             time=sandbox.get_execution_time(),
             memory=sandbox.get_memory_used(),
+            warnings=_check_for_compilation_warnings(sandbox, stderr_file),
             log='\n'.join(std_outputs),
         )
         logs.append(log)
@@ -406,6 +526,9 @@ def compile(
         if log.exitcode != 0:
             break
 
+    if artifacts.logs is not None:
+        artifacts.logs.preprocess = logs
+
     if logs and logs[-1].exitcode != 0:
         console.print(
             '[error]FAILED[/error] Preprocessing failed with command',
@@ -455,6 +578,11 @@ def run(
         memory=sandbox.get_memory_used(),
         metadata=metadata,
     )
+    if metadata is not None and metadata.is_sanitized:
+        run_log.warnings = _check_for_sanitizer_warnings(
+            sandbox,
+            params.stderr_file,
+        )
     if artifacts.logs is not None:
         artifacts.logs.run = run_log.model_copy()
     return run_log

rbx/grading/steps_with_caching.py

@@ -18,6 +18,8 @@ def compile(
     artifacts: GradingArtifacts,
     dependency_cache: DependencyCache,
 ):
+    artifacts.logs = GradingLogsHolder()
+
     ok = True
     with dependency_cache(
         commands, [artifacts], params.get_cacheable_params()

rbx/resources/default_setter_config.mac.yml

@@ -0,0 +1,31 @@
+# Whether to enable warnings when running solutions.
+warnings:
+  enabled: true
+
+# A list of command substitutions to apply to rbx.
+# Useful when replacing compilers in OS such as Mac.
+command_substitutions:
+  g++: g++
+  gcc: gcc
+  java: java
+  javac: javac
+  jar: jar
+  python: python
+  python2: python2
+  python3: python3
+
+# Whether sanitizers will be enabled by default
+# when running testlib components.
+# This flag has no effect on running solutions with
+# sanitizers. For this, you have to use the `-s` flag in `rbx run`.
+sanitizers:
+  enabled: false
+
+  # A list of command substitutions to apply to rbx when
+  # sanitizers are enabled.
+  #
+  # This is useful when replacing compilers in OS such as Mac,
+  # since GCC on Mac does not support sanitizers.
+  command_substitutions:
+    g++: clang++
+    gcc: clang

rbx/resources/default_setter_config.yml

@@ -0,0 +1,29 @@
+# Whether to enable warnings when running solutions.
+warnings:
+  enabled: true
+
+# A list of command substitutions to apply to rbx.
+# Useful when replacing compilers in OS such as Mac.
+command_substitutions:
+  g++: g++
+  gcc: gcc
+  java: java
+  javac: javac
+  jar: jar
+  python: python
+  python2: python2
+  python3: python3
+
+# Whether sanitizers will be enabled by default
+# when running testlib components.
+# This flag has no effect on running solutions with
+# sanitizers. For this, you have to use the `-s` flag in `rbx run`.
+sanitizers:
+  enabled: false
+
+  # A list of command substitutions to apply to rbx when
+  # sanitizers are enabled.
+  #
+  # This is useful when replacing compilers in OS such as Mac,
+  # since GCC on Mac does not support sanitizers.
+  command_substitutions: {}

rbx/utils.py

@@ -9,6 +9,7 @@ from typing import Any, Optional, Type, TypeVar
 import rich
 import rich.prompt
 import rich.status
+import ruyaml
 import typer
 import yaml
 from fastapi.encoders import jsonable_encoder
@@ -91,6 +92,12 @@ def validate_field(model: Type[T], field: str, value: Any):
     )
 
 
+def save_ruyaml(path: pathlib.Path, yml: ruyaml.YAML, data: ruyaml.Any):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open('w') as f:
+        yml.dump(data, f)
+
+
 def confirm_on_status(status: Optional[rich.status.Status], *args, **kwargs) -> bool:
     if status:
         status.stop()
@@ -113,7 +120,7 @@ def get_open_fds():
 
 
 @contextlib.contextmanager
-def new_cd(x):
+def new_cd(x: pathlib.Path):
     d = os.getcwd()
 
     # This could raise an exception, but it's probably

{rbx_cp-0.5.16.dist-info → rbx_cp-0.5.18.dist-info}/METADATA

@@ -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