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

rbx/grading/steps.py

@@ -1,15 +1,12 @@
 import asyncio
-import contextlib
 import dataclasses
 import functools
-import os
 import pathlib
 import re
 import shlex
 import shutil
 import subprocess
 import sys
-import tempfile
 from enum import Enum
 from typing import IO, Any, Dict, Iterable, List, Optional, Tuple, Union
 
@@ -20,9 +17,9 @@ from rich.text import Text
 from rbx import utils
 from rbx.config import get_bits_stdcpp, get_jngen, get_testlib
 from rbx.console import console
-from rbx.grading import grading_context, processing_context
+from rbx.grading import grading_context
 from rbx.grading.judge.cacher import FileCacher
-from rbx.grading.judge.sandbox import SandboxBase, SandboxParams
+from rbx.grading.judge.sandbox import SandboxBase, SandboxLog, SandboxParams
 from rbx.grading.judge.storage import copyfileobj
 from rbx.grading.limits import Limits
 
@@ -81,6 +78,7 @@ class DigestHolder(BaseModel):
 
 class GradingLogsHolder(BaseModel):
     run: Optional['RunLog'] = None
+    interactor_run: Optional['RunLog'] = None
     preprocess: Optional[List['PreprocessLog']] = None
     cached: bool = False
 
@@ -238,6 +236,7 @@ class RunLog(BaseModel):
     sandbox: str = ''
     warnings: bool = False
     metadata: Optional[RunLogMetadata] = None
+    exitindex: int = 0
 
     def get_run_language(self) -> Optional[str]:
         if self.metadata is None:
@@ -394,16 +393,18 @@ def _expand_part(part: str, sandbox: SandboxBase) -> List[str]:
     return [part]
 
 
-def _get_java_memory_limits(sandbox: SandboxBase) -> Tuple[int, int]:
-    max_memory = sandbox.params.address_space
+def _get_java_memory_limits(params: SandboxParams) -> Tuple[int, int]:
+    max_memory = params.address_space
     if max_memory is None:
         max_memory = 2048
     return max_memory, min(512, int(max_memory * 0.9))
 
 
-def _split_and_expand(command: str, sandbox: SandboxBase) -> List[str]:
+def _split_and_expand(
+    command: str, sandbox: SandboxBase, params: SandboxParams
+) -> List[str]:
     res = []
-    max_mem, init_mem = _get_java_memory_limits(sandbox)
+    max_mem, init_mem = _get_java_memory_limits(params)
     parts = shlex.split(command.format(memory=max_mem, initialMemory=init_mem))
     for part in parts:
         res.extend(_expand_part(part, sandbox))
@@ -594,7 +595,7 @@ def _maybe_complain_about_sanitization(command: str) -> None:
         raise typer.Exit(1)
 
 
-def _check_for_sanitizer_warnings_in_line(line: str) -> bool:
+def check_for_sanitizer_warnings_in_line(line: str) -> bool:
     line = line.lower()
     return 'runtime error:' in line or '==error' in line
 
@@ -607,7 +608,7 @@ def _check_for_sanitizer_warnings(
     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)
+        return any(check_for_sanitizer_warnings_in_line(line.decode()) for line in f)
 
 
 _WARNING_RE = re.compile(r'([^:]+):\d+:\d+:[ ]+warning:.*')
@@ -640,6 +641,36 @@ def _check_for_compilation_warnings(
         )
 
 
+def _build_run_log(
+    sandbox_log: SandboxLog,
+    sandbox: SandboxBase,
+    params: SandboxParams,
+    metadata: Optional[RunLogMetadata] = None,
+) -> RunLog:
+    execution_time = sandbox_log.execution_time
+    if execution_time is not None and (
+        sandbox_log.exitstatus == SandboxBase.EXIT_TIMEOUT
+        or sandbox_log.exitstatus == SandboxBase.EXIT_TIMEOUT_WALL
+    ):
+        execution_time = max(execution_time, (params.timeout or 0.0) / 1000)
+
+    run_log = RunLog(
+        exitcode=sandbox_log.exitcode,
+        exitstatus=sandbox_log.exitstatus,
+        time=execution_time,
+        memory=sandbox_log.memory_used,
+        metadata=metadata,
+        sandbox=sandbox_log.dump_other_logs(),
+        exitindex=sandbox_log.exit_index,
+    )
+    if metadata is not None and metadata.is_sanitized:
+        run_log.warnings = _check_for_sanitizer_warnings(
+            sandbox,
+            params.stderr_file,
+        )
+    return run_log
+
+
 def compile(
     commands: List[str],
     params: SandboxParams,
@@ -656,29 +687,20 @@ def compile(
         return True
 
     logs: List[PreprocessLog] = []
-    sandbox.set_params(
-        params.model_copy(deep=True)
-    )  # Copy to allow further modification.
+    params = params.model_copy(deep=True)  # Copy to allow further modification.
 
     for i, command in enumerate(commands):
         _maybe_complain_about_sanitization(command)
-        cmd = _split_and_expand(command, sandbox)
+        cmd = _split_and_expand(command, sandbox, params)
         stdout_file = pathlib.PosixPath(f'compile-{i}.stdout')
         stderr_file = pathlib.PosixPath(f'compile-{i}.stderr')
-        sandbox.params.set_stdall(stdout=stdout_file, stderr=stderr_file)
+        params.set_stdall(stdout=stdout_file, stderr=stderr_file)
 
         # Remove memory constraints for Java.
         if is_java_like_command(get_exe_from_command(command)):
-            sandbox.params.address_space = None
+            params.address_space = None
 
-        if not sandbox.execute_without_std(cmd):
-            console.print(
-                '[error]Sandbox crashed while processing command:[/error]',
-                utils.highlight_json_obj(cmd),
-                '[error]and logs[/error]',
-                sandbox.debug_message(),
-            )
-            return False
+        sandbox_log = sandbox.run(cmd, params)
 
         std_outputs = [
             sandbox.get_file_to_string(stderr_file, maxlen=None)
@@ -691,13 +713,13 @@ def compile(
 
         log = PreprocessLog(
             cmd=cmd,
-            exitcode=sandbox.get_exit_code(),
-            exitstatus=sandbox.get_exit_status(),
-            time=sandbox.get_execution_time(),
-            memory=sandbox.get_memory_used(),
+            exitcode=sandbox_log.exitcode,
+            exitstatus=sandbox_log.exitstatus,
+            time=sandbox_log.execution_time,
+            memory=sandbox_log.memory_used,
             warnings=_check_for_compilation_warnings(sandbox, stderr_file),
             log='\n'.join(std_outputs),
-            sandbox=sandbox.get_detailed_logs(),
+            sandbox=sandbox_log.dump_other_logs(),
         )
         logs.append(log)
 
@@ -730,48 +752,19 @@ async def run(
 
     _process_input_artifacts(artifacts, sandbox)
     _process_fifos(artifacts, sandbox)
-    cmd = _split_and_expand(command, sandbox)
-    sandbox.set_params(
-        params.model_copy(deep=True)
-    )  # Copy to allow further modification.
+    cmd = _split_and_expand(command, sandbox, params)
+    params = params.model_copy(deep=True)  # Copy to allow further modification.
 
     # Remove memory constraints for Java.
     if is_java_like_command(get_exe_from_command(command)):
-        sandbox.params.address_space = None
+        params.address_space = None
 
-    sandbox.pid_event.set_loop(asyncio.get_event_loop())
-    if not await asyncio.to_thread(sandbox.execute_without_std, cmd):
-        console.print(
-            '[error]Sandbox crashed while processing command:[/error]',
-            utils.highlight_json_obj(cmd),
-            '[error]and logs[/error]',
-            sandbox.debug_message(),
-        )
-        return None
+    sandbox_log = await asyncio.to_thread(sandbox.run, cmd, params)
 
     if not _process_output_artifacts(artifacts, sandbox):
         return None
 
-    execution_time = sandbox.get_execution_time()
-    if execution_time is not None and (
-        sandbox.get_exit_status() == SandboxBase.EXIT_TIMEOUT
-        or sandbox.get_exit_status() == SandboxBase.EXIT_TIMEOUT_WALL
-    ):
-        execution_time = max(execution_time, (params.timeout or 0.0) / 1000)
-
-    run_log = RunLog(
-        exitcode=sandbox.get_exit_code(),
-        exitstatus=sandbox.get_exit_status(),
-        time=sandbox.get_execution_time(),
-        memory=sandbox.get_memory_used(),
-        metadata=metadata,
-        sandbox=sandbox.get_detailed_logs(),
-    )
-    if metadata is not None and metadata.is_sanitized:
-        run_log.warnings = _check_for_sanitizer_warnings(
-            sandbox,
-            params.stderr_file,
-        )
+    run_log = _build_run_log(sandbox_log, sandbox, params, metadata)
     if artifacts.logs is not None:
         artifacts.logs.run = run_log.model_copy()
     return run_log
@@ -781,45 +774,53 @@ async def run(
 class CoordinatedRunParams:
     command: str
     params: SandboxParams
-    sandbox: SandboxBase
-    artifacts: GradingArtifacts
     metadata: Optional[RunLogMetadata] = None
 
 
 async def run_coordinated(
     interactor: CoordinatedRunParams,
     solution: CoordinatedRunParams,
+    artifacts: GradingArtifacts,
+    sandbox: SandboxBase,
+    merged_capture: Optional[pathlib.Path] = None,
 ) -> Tuple[Optional[RunLog], Optional[RunLog]]:
-    def run_one(params: CoordinatedRunParams) -> asyncio.Task[Optional[RunLog]]:
-        return asyncio.create_task(
-            run(
-                params.command,
-                params.params,
-                params.sandbox,
-                params.artifacts,
-                params.metadata,
-            )
-        )
+    sandbox.reset()
 
-    # Use interactor PID as the process group id.
-    interactor_task = run_one(interactor)
-    solution.sandbox.params.pgid = await interactor.sandbox.get_pid()
-    solution_task = run_one(solution)
+    _process_input_artifacts(artifacts, sandbox)
+    _process_fifos(artifacts, sandbox)
 
-    await processing_context.wait_all([interactor.sandbox, solution.sandbox])
+    interactor_cmd = _split_and_expand(interactor.command, sandbox, interactor.params)
+    solution_cmd = _split_and_expand(solution.command, sandbox, solution.params)
 
-    return await asyncio.gather(interactor_task, solution_task)
+    interactor_params = interactor.params.model_copy(deep=True)
+    solution_params = solution.params.model_copy(deep=True)
 
+    if is_java_like_command(get_exe_from_command(solution.command)):
+        solution_params.address_space = None
+
+    solution_sandbox_log, interactor_sandbox_log = sandbox.run_communication(
+        solution_cmd,
+        solution_params,
+        interactor_cmd,
+        interactor_params,
+        merged_capture,
+    )
 
-def _normalize_checked_words(s: str) -> Tuple[str, ...]:
-    return tuple(s.split())
+    if not _process_output_artifacts(artifacts, sandbox):
+        return None, None
 
+    solution_log = _build_run_log(
+        solution_sandbox_log, sandbox, solution.params, solution.metadata
+    )
+    interactor_log = _build_run_log(
+        interactor_sandbox_log, sandbox, interactor.params, interactor.metadata
+    )
 
-def _wcmp_check(expected: str, output: str) -> Outcome:
-    if _normalize_checked_words(expected) == _normalize_checked_words(output):
-        return Outcome.ACCEPTED
+    if artifacts.logs is not None:
+        artifacts.logs.run = solution_log
+        artifacts.logs.interactor_run = interactor_log
 
-    return Outcome.WRONG_ANSWER
+    return solution_log, interactor_log
 
 
 def get_checker_sandbox_params() -> SandboxParams:
@@ -830,116 +831,3 @@ def get_checker_sandbox_params() -> SandboxParams:
     params.add_mapped_directory(pathlib.Path('/usr'))
     params.add_mapped_directory(pathlib.Path('/etc'))
     return params
-
-
-def _check(
-    sandbox: SandboxBase,
-    testcase: TestcaseIO,
-    output_path: pathlib.Path,
-    should_use_python_checker: bool = False,
-) -> CheckerResult:
-    if testcase.output is None:
-        # No output to compare.
-        return CheckerResult(outcome=Outcome.ACCEPTED)
-
-    if should_use_python_checker:
-        # Use default wcmp checker.
-        expected = testcase.output.read_text()
-        output = output_path.read_text()
-
-        return CheckerResult(outcome=_wcmp_check(expected, output))
-
-    sandbox.params.set_stdall(
-        stdin=None,
-        stdout=pathlib.PosixPath('stdout.txt'),
-        stderr=pathlib.PosixPath('stderr.txt'),
-    )
-
-    sandbox.create_file_from_string(
-        pathlib.PosixPath('expected.txt'), testcase.output.read_text(), override=True
-    )
-    sandbox.create_file_from_string(
-        pathlib.PosixPath('output.txt'), output_path.read_text(), override=True
-    )
-    sandbox.create_file_from_string(
-        pathlib.PosixPath('input.txt'),
-        testcase.input.read_text() if testcase.input is not None else '',
-        override=True,
-    )
-
-    if not sandbox.execute_without_std(
-        ['./checker', 'input.txt', 'output.txt', 'expected.txt'],
-    ):
-        console.print(
-            '[error]Sandbox crashed while running checker.[/error]',
-            '[error]and logs[/error]',
-            sandbox.debug_message(),
-        )
-        return CheckerResult(outcome=Outcome.INTERNAL_ERROR)
-
-    checker_stderr = sandbox.get_file_to_string(
-        pathlib.PosixPath('stderr.txt'), maxlen=None
-    )
-    if sandbox.get_exit_code() in [1, 2]:
-        return CheckerResult(outcome=Outcome.WRONG_ANSWER, message=checker_stderr)
-    if sandbox.get_exit_code() == 3:
-        return CheckerResult(outcome=Outcome.JUDGE_FAILED, message=checker_stderr)
-    return CheckerResult(outcome=Outcome.ACCEPTED, message=checker_stderr)
-
-
-# Always assume a `checker` executable in the sandbox if should use checker.
-def evaluate(
-    sandbox: SandboxBase,
-    testcase: TestcaseIO,
-    log: Optional[TestcaseLog],
-    artifacts: GradingArtifacts,
-    should_use_python_checker: bool = False,
-) -> Evaluation:
-    if log is None:
-        return Evaluation(
-            testcase=testcase,
-            log=TestcaseLog(),
-            result=CheckerResult(outcome=Outcome.INTERNAL_ERROR),
-        )
-    if log.exitstatus != SandboxBase.EXIT_OK:
-        return Evaluation(
-            testcase=testcase,
-            log=log,
-            result=CheckerResult(outcome=Outcome.RUNTIME_ERROR),
-        )
-
-    if not testcase.output:
-        # No output to compare.
-        return Evaluation(
-            testcase=testcase, log=log, result=CheckerResult(outcome=Outcome.ACCEPTED)
-        )
-
-    _process_input_artifacts(artifacts, sandbox)
-    if log.stdout_absolute_path is None:
-        return Evaluation(
-            testcase=testcase,
-            log=log,
-            result=CheckerResult(outcome=Outcome.INTERNAL_ERROR, message='No output'),
-        )
-
-    checker_result = _check(
-        sandbox,
-        testcase,
-        log.stdout_absolute_path,
-        should_use_python_checker=should_use_python_checker,
-    )
-    return Evaluation(
-        testcase=testcase,
-        log=log,
-        result=checker_result,
-    )
-
-
-@contextlib.contextmanager
-def make_fifos():
-    with tempfile.TemporaryDirectory() as temp_dir:
-        fifo_in = pathlib.PosixPath(temp_dir) / 'fifo.in'
-        fifo_out = pathlib.PosixPath(temp_dir) / 'fifo.out'
-        os.mkfifo(fifo_in)
-        os.mkfifo(fifo_out)
-        yield fifo_in, fifo_out

rbx/grading/steps_with_caching.py

@@ -1,3 +1,4 @@
+import pathlib
 from typing import Any, Dict, List, Optional, Tuple
 
 from rbx.grading import grading_context, profiling, steps
@@ -88,10 +89,12 @@ async def run(
 async def run_coordinated(
     interactor: steps.CoordinatedRunParams,
     solution: steps.CoordinatedRunParams,
+    artifacts: GradingArtifacts,
+    sandbox: SandboxBase,
     dependency_cache: DependencyCache,
+    merged_capture: Optional[pathlib.Path] = None,
 ) -> Tuple[Optional[RunLog], Optional[RunLog]]:
-    interactor.artifacts.logs = GradingLogsHolder()
-    solution.artifacts.logs = GradingLogsHolder()
+    artifacts.logs = GradingLogsHolder()
 
     cacheable_params = {
         **_get_prefixed_cacheable_params(
@@ -114,18 +117,24 @@ async def run_coordinated(
         cached_profile = profiling.Profiler('steps.run_coordinated[cached]', start=True)
         with dependency_cache(
             [interactor.command, solution.command],
-            [interactor.artifacts, solution.artifacts],
+            [artifacts],
             cacheable_params,
         ) as is_cached:
             if not is_cached:
                 with profiling.Profiler('steps.run_coordinated'):
                     profiling.add_to_counter('steps.run_coordinated')
-                    await steps.run_coordinated(interactor, solution)
+                    await steps.run_coordinated(
+                        interactor,
+                        solution,
+                        artifacts,
+                        sandbox,
+                        merged_capture=merged_capture,
+                    )
             else:
                 cached_profile.stop()
                 profiling.add_to_counter('steps.run_coordinated[cached]')
 
     return (
-        interactor.artifacts.logs.run,
-        solution.artifacts.logs.run,
+        artifacts.logs.interactor_run,
+        artifacts.logs.run,
     )

rbx/resources/presets/default/problem/problem.rbx.yml

@@ -19,8 +19,6 @@ solutions:
     outcome: "ACCEPTED"
   - path: "sols/wa.cpp"
     outcome: "WRONG_ANSWER"
-  - path: "sols/slow.cpp"
-    outcome: "TLE_OR_RTE" # Can be TLE too
 statements:
   - name: "statement-en"
     title: "New Problem"

rbx/resources/templates/rbx.h

@@ -1,5 +1,7 @@
 #ifndef _RBX_H
 #define _RBX_H
+#include <cstdint>
+#include <limits>
 #include <optional>
 #include <stdexcept>
 #include <string>
@@ -9,7 +11,7 @@ std::optional<std::string> getStringVar(std::string name) {
   return std::nullopt;
 }
 
-std::optional<int> getIntVar(std::string name) {
+std::optional<int64_t> getIntVar(std::string name) {
   //<rbx::int_var>
   return std::nullopt;
 }
@@ -26,7 +28,46 @@ std::optional<bool> getBoolVar(std::string name) {
 
 template <typename T> T getVar(std::string name);
 
-template <> int getVar<int>(std::string name) {
+template <> int32_t getVar<int32_t>(std::string name) {
+  auto opt = getIntVar(name);
+  if (!opt.has_value()) {
+    throw std::runtime_error("Variable " + name +
+                             " is not an integer or could not be found");
+  }
+  if (opt.value() < std::numeric_limits<int32_t>::min() ||
+      opt.value() > std::numeric_limits<int32_t>::max()) {
+    throw std::runtime_error("Variable " + name + " of value " +
+                             std::to_string(opt.value()) +
+                             " does not fit in int32_t");
+  }
+  return opt.value();
+}
+
+template <> uint32_t getVar<uint32_t>(std::string name) {
+  auto opt = getIntVar(name);
+  if (!opt.has_value()) {
+    throw std::runtime_error("Variable " + name +
+                             " is not an integer or could not be found");
+  }
+  if (opt.value() < std::numeric_limits<uint32_t>::min() ||
+      opt.value() > std::numeric_limits<uint32_t>::max()) {
+    throw std::runtime_error("Variable " + name + " of value " +
+                             std::to_string(opt.value()) +
+                             " does not fit in uint32_t");
+  }
+  return opt.value();
+}
+
+template <> int64_t getVar<int64_t>(std::string name) {
+  auto opt = getIntVar(name);
+  if (!opt.has_value()) {
+    throw std::runtime_error("Variable " + name +
+                             " is not an integer or could not be found");
+  }
+  return opt.value();
+}
+
+template <> uint64_t getVar<uint64_t>(std::string name) {
   auto opt = getIntVar(name);
   if (!opt.has_value()) {
     throw std::runtime_error("Variable " + name +

rbx/testing_utils.py

@@ -16,6 +16,13 @@ def get_testdata_path() -> pathlib.Path:
         return file.parent
 
 
+def get_resources_path() -> pathlib.Path:
+    with importlib.resources.as_file(
+        importlib.resources.files('rbx') / 'resources' / 'default_setter_config.yml'
+    ) as file:
+        return file.parent
+
+
 def clear_all_functools_cache():
     from rbx.box import environment, header, package