rbx.cp 0.13.4__py3-none-any.whl → 0.13.6__py3-none-any.whl

rbx/box/checkers.py

@@ -1,5 +1,4 @@
 import pathlib
-import signal
 from typing import List, Optional
 
 import typer
@@ -248,6 +247,7 @@ async def _check(
             console.console.print(
                 f'[error]Summary:[/error] {checker_run_log.get_summary()}'
             )
+        console.console.print(f'[error]Message:[/error] {message}')
         console.console.print(
             f'[error]Testcase input:[/error] [item]{testcase.inputPath}[/item]'
         )
@@ -345,14 +345,7 @@ async def check_communication(
     if (
         interactor_run_log is not None
         and run_log is not None
-        and (
-            run_log.exitcode == -signal.SIGPIPE
-            or run_log.exitstatus == SandboxBase.EXIT_TERMINATED
-            or (
-                run_log.exitstatus == SandboxBase.EXIT_NONZERO_RETURN
-                and not _is_testlib_eof(interactor_stderr.read_text())
-            )
-        )
+        and (interactor_run_log.exitindex < run_log.exitindex)
     ):
         result = _check_interactor()
         if result is not None and result.outcome != Outcome.ACCEPTED:

rbx/box/cli.py

@@ -286,7 +286,6 @@ async def run(
         help='Whether to pick solutions interactively.',
     ),
 ):
-    console.console.log(check)
     main_solution = package.get_main_solution()
     if check and main_solution is None:
         console.console.print(

rbx/box/code.py

@@ -12,7 +12,7 @@ import rich.text
 import typer
 from pydantic import BaseModel
 
-from rbx import console, utils
+from rbx import console
 from rbx.box import download, global_package, package, setter_config, state
 from rbx.box.environment import (
     CompilationConfig,
@@ -48,6 +48,8 @@ from rbx.grading.steps import (
     maybe_get_bits_stdcpp_for_commands,
 )
 
+MERGED_CAPTURE_FILENAME = 'merged_capture.pio'
+
 
 class SanitizationLevel(Enum):
     NONE = 0
@@ -207,6 +209,9 @@ def _format_stack_limit(limit: int) -> str:
 
 
 def _check_stack_limit():
+    cfg = setter_config.get_setter_config()
+    if not cfg.judging.check_stack:
+        return
     if not state.STATE.run_through_cli:
         return
     soft, hard = resource.RLIM_INFINITY, resource.RLIM_INFINITY
@@ -261,52 +266,6 @@ class PreparedRun:
     metadata: RunLogMetadata
 
 
-@dataclasses.dataclass
-class CaptureSpec:
-    prefix: str
-    output: Optional[DigestOrDest] = None
-    merged_capture: Optional[pathlib.Path] = None
-
-
-def _prepare_for_communication(
-    run: PreparedRun,
-    stdin: pathlib.Path,
-    stdout: pathlib.Path,
-    reverse_io: bool = False,
-    capture: Optional[CaptureSpec] = None,
-):
-    run.sandbox_params.set_stdio(
-        stdin=stdin,
-        stdout=stdout,
-    )
-    run.sandbox_params.reverse_io = reverse_io
-    if capture is not None:
-        run.sandbox_params.timeit_prefix = capture.prefix
-
-        if capture.output is not None:
-            output_path = PosixPath('capture')
-            run.sandbox_params.timeit_dups['do'].append(output_path)
-
-            run.artifacts.outputs.append(
-                GradingFileOutput(
-                    src=output_path,
-                    **capture.output.expand(),
-                    touch=True,
-                )
-            )
-
-        if capture.merged_capture is not None:
-            merged_output_path = utils.abspath(package.get_merged_capture_path())
-            run.sandbox_params.timeit_dups['Do'].append(merged_output_path)
-
-            run.artifacts.outputs.append(
-                GradingFileOutput(
-                    src=merged_output_path,
-                    dest=capture.merged_capture,
-                )
-            )
-
-
 def _prepare_run(
     code: CodeItem,
     executable: DigestOrSource,
@@ -318,12 +277,13 @@ def _prepare_run(
     extra_args: Optional[str] = None,
     extra_config: Optional[ExecutionConfig] = None,
     retry_index: Optional[int] = None,
+    file_prefix: Optional[str] = None,
 ):
     language = find_language_name(code)
     execution_options = get_execution_config(language)
     if extra_config is not None:
         execution_options = merge_execution_configs([execution_options, extra_config])
-    file_mapping = get_file_mapping(language)
+    file_mapping = get_file_mapping(language, file_prefix)
     sandbox_params = get_sandbox_params_from_config(execution_options.sandbox)
 
     # Sanitization parameters.
@@ -739,6 +699,7 @@ async def run_item(
 class CommunicationItem:
     code: CodeItem
     executable: DigestOrSource
+    file_prefix: str
     stderr: Optional[DigestOrDest] = None
     inputs: Optional[List[GradingFileInput]] = None
     outputs: Optional[List[GradingFileOutput]] = None
@@ -750,21 +711,22 @@ class CommunicationItem:
         return _prepare_run(
             self.code,
             self.executable,
+            stdout=self.capture,
             stderr=self.stderr,
             inputs=self.inputs,
             outputs=self.outputs,
             extra_args=self.extra_args,
             extra_config=self.extra_config,
+            file_prefix=self.file_prefix,
         )
 
 
 async def run_communication(
     interactor: CommunicationItem,
     solution: CommunicationItem,
-    merged_capture: Optional[pathlib.Path] = None,
+    merged_capture: Optional[DigestOrDest] = None,
     retry_index: Optional[int] = None,
 ):
-    fifo_in, fifo_out = package.get_fifos()
     interactor_prepared = interactor.prepare()
     solution_prepared = solution.prepare()
 
@@ -772,48 +734,30 @@ async def run_communication(
     interactor_prepared.metadata.retryIndex = retry_index
     solution_prepared.metadata.retryIndex = retry_index
 
-    interactor_prefix = '<'
-    solution_prefix = '>'
+    grading_artifacts = GradingArtifacts()
+    grading_artifacts.inputs.extend(interactor_prepared.artifacts.inputs)
+    grading_artifacts.outputs.extend(interactor_prepared.artifacts.outputs)
+    grading_artifacts.inputs.extend(solution_prepared.artifacts.inputs)
+    grading_artifacts.outputs.extend(solution_prepared.artifacts.outputs)
 
+    merged_capture_path: Optional[pathlib.Path] = None
     if merged_capture is not None:
-        package.get_merged_capture_path().write_text(
-            f'{interactor_prefix}\n{solution_prefix}\n'
+        merged_capture_path = pathlib.Path(MERGED_CAPTURE_FILENAME)
+        grading_artifacts.outputs.append(
+            GradingFileOutput(
+                src=merged_capture_path,
+                **merged_capture.expand(),
+            )
         )
 
-    _prepare_for_communication(
-        interactor_prepared,
-        fifo_out,
-        fifo_in,
-        capture=CaptureSpec(
-            prefix=interactor_prefix,
-            output=interactor.capture,
-            merged_capture=merged_capture,
-        ),
-    )
-    _prepare_for_communication(
-        solution_prepared,
-        fifo_in,
-        fifo_out,
-        reverse_io=True,
-        capture=CaptureSpec(
-            prefix=solution_prefix,
-            output=solution.capture,
-            merged_capture=merged_capture,
-        ),
-    )
-
     interactor_run_params = steps.CoordinatedRunParams(
         command=interactor_prepared.command,
         params=interactor_prepared.sandbox_params,
-        sandbox=package.get_singleton_interactor_sandbox(),
-        artifacts=interactor_prepared.artifacts,
         metadata=interactor_prepared.metadata,
     )
     solution_run_params = steps.CoordinatedRunParams(
         command=solution_prepared.command,
         params=solution_prepared.sandbox_params,
-        sandbox=package.get_singleton_sandbox(),
-        artifacts=solution_prepared.artifacts,
         metadata=solution_prepared.metadata,
     )
 
@@ -825,5 +769,8 @@ async def run_communication(
         return await steps_with_caching.run_coordinated(
             interactor_run_params,
             solution_run_params,
+            sandbox=package.get_singleton_sandbox(),
+            artifacts=grading_artifacts,
             dependency_cache=package.get_dependency_cache(),
+            merged_capture=merged_capture_path,
         )

rbx/box/environment.py

@@ -10,7 +10,6 @@ from rbx import config, console, utils
 from rbx.box import presets
 from rbx.box.extensions import Extensions, LanguageExtensions
 from rbx.grading.judge.sandbox import SandboxBase, SandboxParams
-from rbx.grading.judge.sandboxes.isolate import IsolateSandbox
 from rbx.grading.judge.sandboxes.stupid_sandbox import StupidSandbox
 from rbx.grading.limits import Limits
 
@@ -58,6 +57,12 @@ relative to the sandbox root.""",
 relative to the sandbox root.""",
     )
 
+    capture: str = Field(
+        default='capture',
+        description="""Path where to output the capture file after running the program,
+relative to the sandbox root.""",
+    )
+
     compilable: str = Field(
         default='compilable',
         description="""Path where to copy the compilable file to before compiling the program,
@@ -232,7 +237,7 @@ execution config can be individually overridden in the language configuration.""
 
     sandbox: str = Field(
         default='stupid',
-        description="""Identifier of the sandbox used by this environment (e.g. "stupid", "isolate")""",
+        description="""Identifier of the sandbox used by this environment (e.g. "stupid")""",
     )
 
     timing: TimingConfig = Field(
@@ -381,13 +386,20 @@ def get_execution_config(language: str) -> ExecutionConfig:
 
 
 @functools.cache
-def get_file_mapping(language: str) -> FileMapping:
+def get_file_mapping(language: str, file_prefix: Optional[str] = None) -> FileMapping:
     environment = get_environment()
-    return _merge_shallow_models(
+    mapping = _merge_shallow_models(
         FileMapping,
         environment.defaultFileMapping or FileMapping(),
         get_language(language).fileMapping or FileMapping(),
     )
+    if file_prefix is not None:
+        mapping.input = f'{file_prefix}_{mapping.input}'
+        mapping.output = f'{file_prefix}_{mapping.output}'
+        mapping.error = f'{file_prefix}_{mapping.error}'
+        mapping.compilable = f'{file_prefix}_{mapping.compilable}'
+        mapping.executable = f'{file_prefix}_{mapping.executable}'
+    return mapping
 
 
 @functools.cache
@@ -395,8 +407,6 @@ def get_sandbox_type() -> Type[SandboxBase]:
     used_sandbox = get_environment().sandbox
     if used_sandbox == 'stupid':
         return StupidSandbox
-    if used_sandbox == 'isolate':
-        return IsolateSandbox
     return StupidSandbox
 
 

rbx/box/generators.py

@@ -120,15 +120,25 @@ def _copy_testcase_output_over(
 
 
 def _copy_testcase_outputs_over(
-    testcase: Testcase, dest: Testcase, pipes: bool = False, dry_run: bool = False
+    testcase: Testcase,
+    dest: Testcase,
+    pipes: bool = False,
+    only_pipes: bool = False,
+    dry_run: bool = False,
 ):
+    if only_pipes:
+        pipes = True
     assert dest.outputPath is not None
     if not dry_run:
         dest.outputPath.parent.mkdir(parents=True, exist_ok=True)
 
     has_copied = False
 
-    if testcase.outputPath is not None and testcase.outputPath.is_file():
+    if (
+        not only_pipes
+        and testcase.outputPath is not None
+        and testcase.outputPath.is_file()
+    ):
         if not dry_run:
             _check_crlf(testcase.outputPath)
             shutil.copy(str(testcase.outputPath), str(dest.outputPath))
@@ -371,6 +381,7 @@ async def generate_output_for_testcase(
     main_solution_digest: str,
     testcase: Testcase,
     interactor_digest: Optional[str] = None,
+    capture_pipes: Optional[bool] = None,
 ):
     assert testcase.outputPath is not None
     testcase.inputPath.parent.mkdir(parents=True, exist_ok=True)
@@ -388,7 +399,7 @@ async def generate_output_for_testcase(
         interactor_digest=interactor_digest,
         use_retries=False,
         use_timelimit=False,
-        capture_pipes=True,
+        capture_pipes=capture_pipes,
     )
 
     if eval.result.outcome.is_slow() and eval.result.no_tle_outcome == Outcome.ACCEPTED:
@@ -474,10 +485,22 @@ async def generate_outputs_for_testcases(
             raise typer.Exit(1)
 
         assert solution_digest is not None
+        capture_pipes = None
+        if (
+            pkg.type == TaskType.COMMUNICATION
+            and entry.metadata.copied_from is not None
+        ):
+            # If some pipe file is already specified, we don't need to capture the pipes
+            # when running the program.
+            capture_pipes = not _copy_testcase_outputs_over(
+                entry.metadata.copied_from, tc, only_pipes=True, dry_run=True
+            )
+
         await generate_output_for_testcase(
             solution_digest,
             tc,
             interactor_digest=interactor_digest,
+            capture_pipes=capture_pipes,
         )
         if entry.metadata.copied_from is not None:
             # Copy remaining pipe files.

rbx/box/global_package.py

@@ -9,7 +9,7 @@ from rbx.grading.judge.sandbox import SandboxBase
 from rbx.grading.judge.sandboxes.stupid_sandbox import StupidSandbox
 from rbx.grading.judge.storage import FilesystemStorage, Storage
 
-CACHE_STEP_VERSION = 3
+CACHE_STEP_VERSION = 4
 
 
 def get_cache_fingerprint() -> str:

rbx/box/header.py

@@ -49,13 +49,33 @@ def _get_string_var_block() -> str:
     return _get_var_block(_get_vars_of_type(str, _string_repr))
 
 
+def check_int_bounds(x: int) -> None:
+    if x >= 2**64:
+        raise ValueError(
+            f'Some variable you defined (value: {x}) is too large to fit in a C++ 64-bit integer (signed or unsigned)'
+        )
+    if x < -(2**63):
+        raise ValueError(
+            f'Some variable you defined (value: {x}) is too small to fit in a C++ 64-bit signed integer (int64_t)'
+        )
+
+
 def _get_int_var_block() -> str:
     def _transform(x: Primitive) -> str:
         if isinstance(x, bool):
-            return str(int(x))
-        return str(x)
+            return f'static_cast<int64_t>({int(x)})'
+        check_int_bounds(int(x))
+        return f'static_cast<int64_t>({x})'
 
-    return _get_var_block(_get_vars_of_type(int, _transform))
+    # Get both int and bool variables for the int block
+    pkg = package.find_problem_package_or_die()
+    vars = pkg.expanded_vars
+    int_vars = {
+        name: _transform(value)
+        for name, value in vars.items()
+        if isinstance(value, (int, bool))
+    }
+    return _get_var_block(int_vars)
 
 
 def _get_float_var_block() -> str:
@@ -69,11 +89,9 @@ def _get_bool_var_block() -> str:
 def _get_vars_of_type(t: Type, transform: Callable[[Primitive], str]) -> Dict[str, str]:
     pkg = package.find_problem_package_or_die()
     vars = pkg.expanded_vars
-
-    def is_valid(value: Primitive) -> bool:
-        return isinstance(value, t)
-
-    return {name: transform(value) for name, value in vars.items() if is_valid(value)}
+    return {
+        name: transform(value) for name, value in vars.items() if isinstance(value, t)
+    }
 
 
 def _get_var_block(mappings: Dict[str, str]) -> str:

rbx/box/package.py

@@ -1,8 +1,6 @@
 import atexit
 import functools
-import os
 import pathlib
-import shutil
 import sys
 from typing import Dict, List, Optional, Tuple
 
@@ -455,18 +453,6 @@ def get_empty_sentinel_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path
     return path
 
 
-@functools.cache
-def get_fifos(root: pathlib.Path = pathlib.Path()) -> Tuple[pathlib.Path, pathlib.Path]:
-    path = get_shared_dir(root) / '.fifos'
-    shutil.rmtree(path, ignore_errors=True)
-    path.mkdir(parents=True, exist_ok=True)
-    fifo_in = path / 'fifo.in'
-    fifo_out = path / 'fifo.out'
-    os.mkfifo(fifo_in)
-    os.mkfifo(fifo_out)
-    return fifo_in, fifo_out
-
-
 @functools.cache
 def get_merged_capture_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
     path = get_shared_dir(root) / '.merged_capture'

rbx/box/setter_config.py

@@ -66,6 +66,13 @@ class CachingConfig(BaseModel):
     )
 
 
+class JudgingConfig(BaseModel):
+    check_stack: bool = Field(
+        default=True,
+        description='Whether to check the stack size before running code.',
+    )
+
+
 class SetterConfig(BaseModel):
     sanitizers: SanitizersConfig = Field(
         default_factory=SanitizersConfig,  # type: ignore
@@ -93,6 +100,10 @@ class SetterConfig(BaseModel):
         default_factory=CachingConfig,  # type: ignore
         description='Configuration for caching.',
     )
+    judging: JudgingConfig = Field(
+        default_factory=JudgingConfig,  # type: ignore
+        description='Configuration for judging.',
+    )
 
     def substitute_command(self, command: str, sanitized: bool = False) -> str:
         exe = shlex.split(command)[0]

rbx/box/solutions.py

@@ -922,6 +922,12 @@ def get_worst_outcome(evals: List[Evaluation]) -> Outcome:
     return Outcome.worst_outcome(eval.result.outcome for eval in evals)
 
 
+def get_truncated_message(message: str, max_length: int = 100) -> str:
+    if len(message) > max_length:
+        return message[:max_length] + '... (truncated)'
+    return message
+
+
 class SolutionOutcomeReport(BaseModel):
     solution: Solution
     evals: List[Evaluation]
@@ -971,9 +977,8 @@ class SolutionOutcomeReport(BaseModel):
         if print_message and self.message is not None:
             tc, msg = self.message
             if msg:
-                if len(msg) > 100:
-                    msg = msg[:100] + '... (truncated)'
-                res += f'\nMessage for {tc}: {msg}'
+                msg = get_truncated_message(msg)
+                res += f'\nMessage for {utils.escape_markup(str(tc))}: {utils.escape_markup(msg)}'
         return res
 
 
@@ -1471,7 +1476,10 @@ async def print_run_report(
                     console.print(f' ({time}, {memory})', end='')
                     checker_msg = eval.result.message
                     if checker_msg:
-                        console.print(f': [i]{checker_msg}[/i]', end='')
+                        checker_msg = get_truncated_message(checker_msg, 150)
+                        console.print(
+                            f': [i]{utils.escape_markup(checker_msg)}[/i]', end=''
+                        )
                 else:
                     console.print(f'{i}/', end='')
                     console.print(get_testcase_markup_verdict(eval), end='')

rbx/box/tasks.py

@@ -51,7 +51,7 @@ async def run_solution_on_testcase(
     timelimit_override: Optional[int] = None,
     use_retries: bool = True,
     use_timelimit: bool = True,
-    capture_pipes: bool = False,
+    capture_pipes: Optional[bool] = None,
     nruns: int = 0,
     filestem: Optional[str] = None,
     is_stress: bool = False,
@@ -175,12 +175,13 @@ async def _run_communication_solution_on_testcase(
     timelimit_override: Optional[int] = None,
     use_retries: bool = True,
     use_timelimit: bool = True,
-    capture_pipes: bool = False,
+    capture_pipes: Optional[bool] = None,
     nruns: int = 0,
     filestem: Optional[str] = None,
     is_stress: bool = False,
 ) -> Evaluation:
-    capture_pipes = capture_pipes or state.STATE.debug_logs
+    if capture_pipes is None:
+        capture_pipes = state.STATE.debug_logs
 
     async def run_fn(retry_index: int) -> Evaluation:
         actual_sandbox = package.get_singleton_sandbox()
@@ -243,6 +244,7 @@ async def _run_communication_solution_on_testcase(
             capture=DigestOrDest.create(interactor_capture_path)
             if interactor_capture_path
             else None,
+            file_prefix='interactor',
         )
         solution_capture_path = (
             output_path.with_suffix('.pout') if capture_pipes else None
@@ -255,6 +257,7 @@ async def _run_communication_solution_on_testcase(
             capture=DigestOrDest.create(solution_capture_path)
             if solution_capture_path
             else None,
+            file_prefix='solution',
         )
 
         merged_capture_path = output_path.with_suffix('.pio') if capture_pipes else None
@@ -262,7 +265,9 @@ async def _run_communication_solution_on_testcase(
             interactor=interactor_item,
             solution=solution_item,
             retry_index=retry_index,
-            merged_capture=merged_capture_path,
+            merged_capture=DigestOrDest.create(merged_capture_path)
+            if merged_capture_path
+            else None,
         )
 
         checker_result = await checkers.check_communication(

rbx/box/testing/testing_package.py

@@ -3,8 +3,10 @@ from dataclasses import dataclass
 from typing import Dict, List, Optional
 
 from rbx import console, utils
+from rbx.box import package, presets
 from rbx.box.fields import Primitive
 from rbx.box.schema import (
+    CheckerTest,
     CodeItem,
     ExpectedOutcome,
     Generator,
@@ -13,6 +15,8 @@ from rbx.box.schema import (
     Solution,
     TaskType,
     TestcaseGroup,
+    ValidatorOutcome,
+    ValidatorTest,
 )
 from rbx.box.testing.testing_preset import TestingPreset
 from rbx.box.testing.testing_shared import PathOrStr, TestingShared
@@ -52,8 +56,12 @@ class TestingPackage(TestingShared):
             )
 
     def initialize_preset(self) -> TestingPreset:
-        preset_path = self.root / '.local.rbx'
-        preset_path.mkdir(parents=True, exist_ok=True)
+        preset = presets.get_active_preset_or_null(self.root)
+        if preset is None:
+            preset_path = self.root / '.local.rbx'
+            preset_path.mkdir(parents=True, exist_ok=True)
+        else:
+            preset_path = presets.get_active_preset_path(self.root)
         return TestingPreset(preset_path)
 
     def print_tree(self):
@@ -74,6 +82,9 @@ class TestingPackage(TestingShared):
 
     def save(self):
         self.yml_path.write_text(utils.model_to_yaml(self.yml))
+        # Clear internal cache and package cache to ensure the updated package is loaded fresh
+        self._yml = None
+        package.clear_package_cache()
 
     def set_type(self, type: TaskType):
         self.yml.type = type
@@ -239,3 +250,59 @@ class TestingPackage(TestingShared):
         if interactor_pipes_path.exists():
             contents.interactor_pipes = interactor_pipes_path.read_text()
         return contents
+
+    def add_validator_unit_test(
+        self,
+        glob: str,
+        outcome: ValidatorOutcome = ValidatorOutcome.VALID,
+        validator: Optional[PathOrStr] = None,
+        files: Optional[Dict[str, str]] = None,
+    ):
+        """Add a unit test for the validator.
+
+        Args:
+            glob: Glob pattern for input files
+            outcome: Expected validation outcome
+            validator: Optional validator to use (if not main validator)
+            files: Optional dict of {filename: content} to create test files
+        """
+        if files:
+            for filename, content in files.items():
+                self.add_file(filename).write_text(content)
+
+        validator_test = ValidatorTest(
+            glob=glob,
+            outcome=outcome,
+            validator=CodeItem(path=pathlib.Path(validator)) if validator else None,
+        )
+
+        # Explicitly set the unitTests field to mark it as dirty
+        unit_tests = self.yml.unitTests
+        unit_tests.validator = unit_tests.validator + [validator_test]
+        self.yml.unitTests = unit_tests
+        self.save()
+
+    def add_checker_unit_test(
+        self,
+        glob: str,
+        outcome: ExpectedOutcome = ExpectedOutcome.ACCEPTED,
+        files: Optional[Dict[str, str]] = None,
+    ):
+        """Add a unit test for the checker.
+
+        Args:
+            glob: Glob pattern for test files
+            outcome: Expected checker outcome
+            files: Optional dict of {filename: content} to create test files
+        """
+        if files:
+            for filename, content in files.items():
+                self.add_file(filename).write_text(content)
+
+        checker_test = CheckerTest(glob=glob, outcome=outcome)
+
+        # Explicitly set the unitTests field to mark it as dirty
+        unit_tests = self.yml.unitTests
+        unit_tests.checker = unit_tests.checker + [checker_test]
+        self.yml.unitTests = unit_tests
+        self.save()