rbx.cp 0.13.3__py3-none-any.whl → 0.13.5__py3-none-any.whl

rbx/annotations.py

@@ -7,7 +7,7 @@ import typer
 import typer.core
 from typing_extensions import Annotated
 
-from rbx import config, metadata
+from rbx import config
 from rbx.config import get_config
 
 
@@ -21,10 +21,10 @@ def _get_language_default():
 
 def _get_problem_options():
     options = set()
-    all_problems = metadata.find_problems()
-    for problem in all_problems:
-        options.add(problem.code)
-        options.update(problem.aliases)
+    # all_problems = metadata.find_problems()
+    # for problem in all_problems:
+    #     options.add(problem.code)
+    #     options.update(problem.aliases)
     return sorted(options)
 
 

rbx/box/checkers.py

@@ -1,12 +1,10 @@
 import pathlib
-import signal
 from typing import List, Optional
 
 import typer
 
 from rbx import console
-from rbx.box import package
-from rbx.box.code import SanitizationLevel, compile_item, run_item
+from rbx.box import code, package
 from rbx.box.schema import Testcase
 from rbx.grading.judge.sandbox import SandboxBase
 from rbx.grading.steps import (
@@ -28,7 +26,7 @@ def compile_checker(progress: Optional[StatusProgress] = None) -> str:
         progress.update('Compiling checker...')
 
     try:
-        digest = compile_item(checker, sanitized=SanitizationLevel.PREFER)
+        digest = code.compile_item(checker, sanitized=code.SanitizationLevel.PREFER)
     except Exception as e:
         console.console.print('[error]Failed compiling checker[/error]')
         raise typer.Exit(1) from e
@@ -46,7 +44,7 @@ def compile_interactor(progress: Optional[StatusProgress] = None) -> str:
         progress.update('Compiling interactor...')
 
     try:
-        digest = compile_item(interactor, sanitized=SanitizationLevel.PREFER)
+        digest = code.compile_item(interactor, sanitized=code.SanitizationLevel.PREFER)
     except Exception as e:
         console.console.print('[error]Failed compiling interactor.[/error]')
         raise typer.Exit(1) from e
@@ -164,6 +162,14 @@ def process_checker_run_log(
 
     if checker_run_log is None:
         return CheckerResult(outcome=Outcome.INTERNAL_ERROR)
+    if checker_run_log.exitstatus not in [
+        SandboxBase.EXIT_OK,
+        SandboxBase.EXIT_NONZERO_RETURN,
+    ]:
+        return CheckerResult(
+            outcome=Outcome.JUDGE_FAILED,
+            message=f'checker failed with exit status {checker_run_log.exitstatus}: {message}',
+        )
     if not _is_checker_exitcode(checker_run_log.exitcode):
         return CheckerResult(
             outcome=Outcome.JUDGE_FAILED,
@@ -196,13 +202,17 @@ async def _check(
         if result.outcome != Outcome.ACCEPTED:
             return _convert_tle(result, run_log)
 
-    pkg = package.find_problem_package_or_die()
-    output_size = program_output.stat().st_size
-    if output_size > pkg.outputLimit * 1024:
-        return CheckerResult(
-            outcome=Outcome.OUTPUT_LIMIT_EXCEEDED,
-            message=f'Output size {pkg.outputLimit}kb, limit is {output_size // 1024}kb.',
-        )
+    if (
+        run_log is not None
+        and run_log.metadata is not None
+        and run_log.metadata.limits.output is not None
+    ):
+        output_size = program_output.stat().st_size
+        if output_size > run_log.metadata.limits.output * 1024:
+            return CheckerResult(
+                outcome=Outcome.OUTPUT_LIMIT_EXCEEDED,
+                message=f'Output size {run_log.metadata.limits.output}kb, limit is {output_size // 1024}kb.',
+            )
 
     error = DigestHolder()
     inputs = [
@@ -219,14 +229,14 @@ async def _check(
             dest=pathlib.PosixPath('output.txt'),
         ),
     ]
-    checker_run_log = await run_item(
+    checker_run_log = await code.run_item(
         package.get_checker(),
         DigestOrSource.create(checker_digest),
         stderr=DigestOrDest.create(error),
         inputs=inputs,
         extra_args='input.txt output.txt expected.txt',
     )
-    message = package.get_digest_as_string(error.value or '') or ''
+    message = package.get_digest_as_string(error.value) or ''
 
     processed_checker_result = process_checker_run_log(checker_run_log, message)
     if processed_checker_result.outcome == Outcome.INTERNAL_ERROR:
@@ -237,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]'
         )
@@ -334,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

@@ -128,7 +128,6 @@ def main(
     capture: bool = typer.Option(
         True,
         '--nocapture',
-        flag_value=False,
         help='Whether to save extra logs and outputs from interactive solutions.',
     ),
     profile: bool = typer.Option(
@@ -259,7 +258,6 @@ async def run(
     check: bool = typer.Option(
         True,
         '--nocheck',
-        flag_value=False,
         help='Whether to not build outputs for tests and run checker.',
     ),
     detailed: bool = typer.Option(
@@ -432,7 +430,6 @@ async 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(
@@ -488,7 +485,6 @@ async def irun(
     check: bool = typer.Option(
         True,
         '--nocheck',
-        flag_value=False,
         help='Whether to not build outputs for tests and run checker.',
     ),
     generator: Optional[str] = typer.Option(

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/contest/build_contest_statements.py

@@ -10,6 +10,7 @@ from rbx import console, testing_utils, 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.fields import Primitive
 from rbx.box.formatting import href
 from rbx.box.schema import Package, Testcase
 from rbx.box.statements import build_statements, latex
@@ -72,14 +73,21 @@ def get_statement_builder_problems(
 
 
 def get_statement_builder_contest(
+    contest: Contest,
     statement: ContestStatement,
     extracted_problems: List[ExtractedProblem],
+    custom_vars: Optional[Dict[str, Primitive]] = None,
 ) -> StatementBuilderContest:
     return StatementBuilderContest(
         title=statement.title,
         location=statement.location,
         date=statement.date,
         problems=get_statement_builder_problems(extracted_problems),
+        vars={
+            **contest.expanded_vars,
+            **statement.expanded_vars,
+            **(custom_vars or {}),
+        },
     )
 
 
@@ -241,10 +249,13 @@ def build_contest_only(
                     languages=get_environment_languages_for_statement(),
                     params=params,
                     root=pathlib.Path(td),
+                ),
+                item=get_statement_builder_contest(
+                    contest,
+                    statement,
+                    extracted_problems,
                     custom_vars=custom_vars,
-                    vars={**contest.expanded_vars, **statement.expanded_vars},
                 ),
-                item=get_statement_builder_contest(statement, extracted_problems),
                 verbose=False,
             )
 
@@ -326,7 +337,9 @@ def build_statement_rooted(
     last_content = joiner.build(
         last_content,
         context=joiner_context,
-        contest=get_statement_builder_contest(statement, extracted_problems),
+        contest=get_statement_builder_contest(
+            contest, statement, extracted_problems, custom_vars=custom_vars
+        ),
     )
     last_output = joiner.output_type()
 

rbx/box/contest/schema.py

@@ -3,8 +3,7 @@ from typing import Annotated, Dict, List, Optional
 
 from pydantic import AfterValidator, BaseModel, ConfigDict, Field, model_validator
 
-from rbx.box.fields import FNameField, NameField
-from rbx.box.schema import Primitive, expand_var
+from rbx.box.fields import FNameField, NameField, Primitive, expand_var
 from rbx.box.statements.expander import expand_statements
 from rbx.box.statements.schema import (
     ConversionStep,

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/fields.py

@@ -1,4 +1,4 @@
-from typing import TypeVar
+from typing import Dict, TypeVar, Union
 
 from deepmerge import always_merger
 from pydantic import BaseModel, Field
@@ -33,3 +33,27 @@ def merge_pydantic_models(base: T, nxt: T) -> T:
     nxt_dict = nxt.model_dump(exclude_unset=True)
     merged_dict = always_merger.merge(base_dict, nxt_dict)
     return base.model_validate(merged_dict)
+
+
+Primitive = Union[str, int, float, bool]
+
+
+def expand_var(value: Primitive) -> Primitive:
+    if not isinstance(value, str):
+        return value
+    if value.startswith('\\'):
+        return value[1:]
+    if not value.startswith('py`') or not value.endswith('`'):
+        return value
+    res = eval(value[3:-1])
+    for supported_type in [str, int, float, bool]:
+        if isinstance(res, supported_type):
+            return res
+
+    raise TypeError(
+        f'Variable with backticks should evaluate to a primitive Python type: {value}'
+    )
+
+
+def expand_vars(vars: Dict[str, Primitive]) -> Dict[str, Primitive]:
+    return {key: expand_var(value) for key, value in vars.items()}

rbx/box/generators.py

@@ -63,13 +63,16 @@ def _warn_about_crlf(path: pathlib.Path):
 
 
 def _check_crlf(path: pathlib.Path):
+    should_fix = False
     with open(path, 'rb') as f:
         for line in f:
-            if line.endswith(b'\r\n') or line.endswith(b'\n\r'):
+            if line.endswith(b'\r\n'):
                 _warn_about_crlf(path)
+                should_fix = True
                 break
 
-    path.write_text(path.read_text().replace('\r', ''))
+    if should_fix:
+        path.write_text('\n'.join(path.read_text().splitlines()) + '\n')
 
 
 def _copy_testcase_over(
@@ -117,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))
@@ -368,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)
@@ -385,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:
@@ -471,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:
@@ -29,9 +29,13 @@ def is_cache_valid(cache_dir: pathlib.Path) -> bool:
     return True
 
 
+def get_global_cache_dir_path() -> pathlib.Path:
+    return get_app_path() / '.box'
+
+
 @functools.cache
 def get_global_cache_dir() -> pathlib.Path:
-    cache_dir = get_app_path() / '.box'
+    cache_dir = get_global_cache_dir_path()
     cache_dir.mkdir(parents=True, exist_ok=True)
     fingerprint_file = cache_dir / 'fingerprint'
     if not fingerprint_file.is_file():