rbx.cp 0.5.0__py3-none-any.whl

rbx/box/checkers.py

@@ -0,0 +1,134 @@
+import pathlib
+from typing import Optional
+
+import typer
+
+from rbx import console
+from rbx.box import package
+from rbx.box.code import compile_item, run_item
+from rbx.box.schema import Testcase
+from rbx.grading.judge.sandbox import SandboxBase
+from rbx.grading.steps import (
+    CheckerResult,
+    DigestHolder,
+    DigestOrDest,
+    DigestOrSource,
+    GradingFileInput,
+    Outcome,
+    RunLog,
+)
+
+
+def compile_checker() -> str:
+    checker = package.get_checker()
+
+    try:
+        digest = compile_item(checker)
+    except Exception as e:
+        console.console.print('[error]Failed compiling checker.[/error]')
+        raise typer.Exit(1) from e
+    return digest
+
+
+def _check_pre_output(run_log: Optional[RunLog]) -> CheckerResult:
+    pkg = package.find_problem_package_or_die()
+
+    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:
+        return CheckerResult(outcome=Outcome.TIME_LIMIT_EXCEEDED)
+
+    if run_log.exitstatus in [SandboxBase.EXIT_SIGNAL, SandboxBase.EXIT_NONZERO_RETURN]:
+        return CheckerResult(outcome=Outcome.RUNTIME_ERROR)
+    if run_log.exitstatus in [SandboxBase.EXIT_TIMEOUT, SandboxBase.EXIT_TIMEOUT_WALL]:
+        return CheckerResult(outcome=Outcome.TIME_LIMIT_EXCEEDED)
+    if run_log.exitstatus == SandboxBase.EXIT_MEMORY_LIMIT_EXCEEDED:
+        return CheckerResult(outcome=Outcome.MEMORY_LIMIT_EXCEEDED)
+    if run_log.exitstatus == SandboxBase.EXIT_SANDBOX_ERROR:
+        return CheckerResult(outcome=Outcome.INTERNAL_ERROR)
+    if run_log.exitstatus == SandboxBase.EXIT_OUTPUT_LIMIT_EXCEEDED:
+        return CheckerResult(outcome=Outcome.OUTPUT_LIMIT_EXCEEDED)
+    return CheckerResult(outcome=Outcome.ACCEPTED)
+
+
+def _convert_tle(result: CheckerResult, run_log: Optional[RunLog]) -> CheckerResult:
+    if result.outcome == Outcome.TIME_LIMIT_EXCEEDED:
+        # This already is a TLE outcome.
+        return result
+    pkg = package.find_problem_package_or_die()
+    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())
+    ):
+        # Soft TLE.
+        result.no_tle_outcome = result.outcome
+        result.outcome = Outcome.TIME_LIMIT_EXCEEDED
+    return result
+
+
+def check_with_no_output(run_log: Optional[RunLog]) -> CheckerResult:
+    result = _check_pre_output(run_log)
+    return _convert_tle(result, run_log)
+
+
+def check(
+    checker_digest: str,
+    run_log: Optional[RunLog],
+    testcase: Testcase,
+    program_output: pathlib.Path,
+    skip_run_log: bool = False,
+) -> CheckerResult:
+    if not skip_run_log:
+        result = _check_pre_output(run_log)
+        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.',
+        )
+
+    error = DigestHolder()
+    inputs = [
+        GradingFileInput(
+            src=testcase.inputPath,
+            dest=pathlib.PosixPath('input.txt'),
+        ),
+        GradingFileInput(
+            src=testcase.outputPath,
+            dest=pathlib.PosixPath('expected.txt'),
+        ),
+        GradingFileInput(
+            src=program_output,
+            dest=pathlib.PosixPath('output.txt'),
+        ),
+    ]
+    checker_run_log = 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 ''
+
+    if checker_run_log is None or checker_run_log.exitcode not in [0, 1, 2, 3]:
+        return CheckerResult(outcome=Outcome.INTERNAL_ERROR)
+
+    result = CheckerResult(outcome=Outcome.ACCEPTED, message=message)
+
+    if checker_run_log.exitcode in [1, 2]:
+        result = CheckerResult(outcome=Outcome.WRONG_ANSWER, message=message)
+    if checker_run_log.exitcode == 3:
+        result = CheckerResult(outcome=Outcome.JUDGE_FAILED, message=message)
+
+    if skip_run_log:
+        return result
+    return _convert_tle(result, run_log)

rbx/box/code.py

@@ -0,0 +1,185 @@
+import pathlib
+import shlex
+import sys
+from pathlib import PosixPath
+from typing import List, Optional
+
+import typer
+
+from rbx.box import download, package
+from rbx.box.environment import (
+    ExecutionConfig,
+    get_compilation_config,
+    get_execution_config,
+    get_extension_or_default,
+    get_file_mapping,
+    get_language,
+    get_mapped_command,
+    get_mapped_commands,
+    get_sandbox_params_from_config,
+    merge_execution_configs,
+)
+from rbx.box.extensions import MacExtension
+from rbx.box.schema import CodeItem
+from rbx.grading import steps_with_caching
+from rbx.grading.steps import (
+    DigestHolder,
+    DigestOrDest,
+    DigestOrSource,
+    GradingArtifacts,
+    GradingFileInput,
+    GradingFileOutput,
+    RunLog,
+    RunLogMetadata,
+)
+
+
+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)
+
+    return [normalize(command) for command in commands]
+
+
+def get_extension(code: CodeItem) -> str:
+    path: pathlib.Path = PosixPath(code.path)
+    return path.suffix[1:]
+
+
+def find_language_name(code: CodeItem) -> str:
+    if code.language is not None:
+        return get_language(code.language).name
+    return get_language(get_extension(code)).name
+
+
+# Compile code item and return its digest in the storage.
+def compile_item(code: CodeItem) -> str:
+    generator_path = PosixPath(code.path)
+    language = find_language_name(code)
+    compilation_options = get_compilation_config(language)
+    file_mapping = get_file_mapping(language)
+    dependency_cache = package.get_dependency_cache()
+    sandbox = package.get_singleton_sandbox()
+    sandbox_params = get_sandbox_params_from_config(compilation_options.sandbox)
+
+    if not compilation_options.commands:
+        # 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)
+
+    compiled_digest = DigestHolder()
+
+    artifacts = GradingArtifacts()
+    artifacts.inputs.extend(
+        GradingFileInput(src=src, dest=dest)
+        for src, dest in package.get_compilation_files(code)
+    )
+    download.maybe_add_testlib(code, artifacts)
+    download.maybe_add_jngen(code, artifacts)
+    artifacts.inputs.append(
+        GradingFileInput(src=generator_path, dest=PosixPath(file_mapping.compilable))
+    )
+    artifacts.outputs.append(
+        GradingFileOutput(
+            src=PosixPath(file_mapping.executable),
+            digest=compiled_digest,
+            executable=True,
+        )
+    )
+
+    if not steps_with_caching.compile(
+        commands,
+        params=sandbox_params,
+        artifacts=artifacts,
+        sandbox=sandbox,
+        dependency_cache=dependency_cache,
+    ):
+        raise typer.Exit(1)
+
+    assert compiled_digest.value is not None
+    return compiled_digest.value
+
+
+def run_item(
+    code: CodeItem,
+    executable: DigestOrSource,
+    stdin: Optional[DigestOrSource] = None,
+    stdout: Optional[DigestOrDest] = None,
+    stderr: Optional[DigestOrDest] = None,
+    inputs: Optional[List[GradingFileInput]] = None,
+    outputs: Optional[List[GradingFileOutput]] = None,
+    extra_args: Optional[str] = None,
+    extra_config: Optional[ExecutionConfig] = None,
+) -> Optional[RunLog]:
+    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)
+    dependency_cache = package.get_dependency_cache()
+    sandbox = package.get_singleton_sandbox()
+    sandbox_params = get_sandbox_params_from_config(execution_options.sandbox)
+
+    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,
+    )
+
+    assert execution_options.command
+    command = get_mapped_command(execution_options.command, file_mapping)
+
+    if extra_args is not None:
+        splitted_command = shlex.split(command)
+        splitted_command.extend(shlex.split(extra_args))
+        command = shlex.join(splitted_command)
+
+    artifacts = GradingArtifacts()
+    artifacts.inputs.append(
+        GradingFileInput(
+            **executable.expand(),
+            dest=PosixPath(file_mapping.executable),
+            executable=True,
+        )
+    )
+    if stdin is not None:
+        artifacts.inputs.append(
+            GradingFileInput(
+                **stdin.expand(),
+                dest=PosixPath(file_mapping.input),
+            )
+        )
+    if stdout is not None:
+        artifacts.outputs.append(
+            GradingFileOutput(
+                src=PosixPath(file_mapping.output),
+                **stdout.expand(),
+            )
+        )
+    if stderr is not None:
+        artifacts.outputs.append(
+            GradingFileOutput(
+                src=PosixPath(file_mapping.error),
+                **stderr.expand(),
+            )
+        )
+    if inputs:
+        artifacts.inputs.extend(inputs)
+    if outputs:
+        artifacts.outputs.extend(outputs)
+
+    return steps_with_caching.run(
+        command,
+        params=sandbox_params,
+        sandbox=sandbox,
+        artifacts=artifacts,
+        dependency_cache=dependency_cache,
+        metadata=RunLogMetadata(language=code.language),
+    )

rbx/box/compile.py

@@ -0,0 +1,56 @@
+import pathlib
+
+import typer
+
+from rbx import annotations, console
+from rbx.box import code, package
+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):
+    console.console.print(f'Compiling [item]{item.path}[/item]...')
+    digest = code.compile_item(item)
+    cacher = package.get_file_cacher()
+    out_path = _compile_out()
+    cacher.get_file_to_path(digest, out_path)
+    out_path.chmod(0o755)
+
+    console.console.print(
+        f'[success]Compiled file written at [item]{out_path}[/item].[/success]'
+    )
+
+
+@app.command('any, a', help='Compile an asset given its path.')
+@package.within_problem
+def any(path: str):
+    _compile(CodeItem(path=pathlib.Path(path)))
+
+
+@app.command('solution, s', help='Compile a solution given its path.')
+@package.within_problem
+def solution(path: str):
+    _compile(package.get_solution(path))
+
+
+@app.command('generator, gen, g', help='Compile a generator given its name.')
+@package.within_problem
+def generator(name: str):
+    _compile(package.get_generator(name))
+
+
+@app.command('checker, c', help='Compile the checker.')
+@package.within_problem
+def checker():
+    _compile(package.get_checker())
+
+
+@app.command('validator, v', help='Compile the main validator.')
+@package.within_problem
+def validator():
+    _compile(package.get_validator())

rbx/box/conftest.py

@@ -0,0 +1,42 @@
+import os
+import pathlib
+import shutil
+from collections.abc import Iterator
+
+import pytest
+
+from rbx import testing_utils
+from rbx.box import package
+
+
+@pytest.fixture
+def pkg_cleandir(cleandir: pathlib.Path) -> Iterator[pathlib.Path]:
+    old_temp_dir = package.TEMP_DIR
+    package.TEMP_DIR = cleandir
+
+    pkgdir = cleandir / 'pkg'
+    pkgdir.mkdir(exist_ok=True, parents=True)
+    lwd = pathlib.Path.cwd()
+    os.chdir(str(pkgdir))
+    try:
+        yield pkgdir.absolute()
+    finally:
+        os.chdir(str(lwd))
+        package.TEMP_DIR = old_temp_dir
+
+
+@pytest.fixture
+def pkg_from_testdata(
+    request, testdata_path: pathlib.Path, pkg_cleandir: pathlib.Path
+) -> Iterator[pathlib.Path]:
+    marker = request.node.get_closest_marker('test_pkg')
+    if marker is None:
+        raise ValueError('test_pkg marker not found')
+    testdata = testdata_path / marker.args[0]
+    shutil.copytree(str(testdata), str(pkg_cleandir), dirs_exist_ok=True)
+    yield pkg_cleandir
+
+
+@pytest.fixture(autouse=True)
+def clear_cache():
+    testing_utils.clear_all_functools_cache()