rbx.cp 0.5.73__py3-none-any.whl → 0.6.1__py3-none-any.whl

rbx/grading/processing_context.py

@@ -1,87 +1,71 @@
-import asyncio
 import contextlib
 import os
 import signal
-import threading
-from typing import Optional, Set
+import subprocess
+from typing import List, Optional
 
-_processing_context_pids: Optional[Set[int]] = None
-_terminate_all_on_error = False
-_lock = threading.Lock()
-
-# Creating a processing context is not thread-safe, but adding to it is.
+from rbx.grading.judge.sandbox import SandboxBase
 
 
 @contextlib.contextmanager
-def new_processing_context(terminate_all_on_error: bool = False):
-    global _processing_context_pids, _terminate_all_on_error
-    with _lock:
-        old_processing_context_pids = _processing_context_pids
-        _old_terminate_all_on_error = _terminate_all_on_error
-        _processing_context_pids = set()
-        _terminate_all_on_error = terminate_all_on_error
+def new_process_group():
+    p = subprocess.Popen(['/bin/bash', '-c', 'exec sleep infinity'])
     try:
-        yield
+        yield p.pid
     finally:
-        with _lock:
-            _processing_context_pids = old_processing_context_pids
-            _terminate_all_on_error = _old_terminate_all_on_error
-
-
-def get_processing_context() -> Set[int]:
-    with _lock:
-        return _processing_context_pids or set()
-
-
-def add_to_processing_context(pid: int):
-    global _processing_context_pids
-    with _lock:
-        if _processing_context_pids is None:
-            return
-        _processing_context_pids.add(pid)
-
-
-def terminate_all_processes_in_context(clear: bool = True):
-    global _processing_context_pids
-    with _lock:
-        if _processing_context_pids is None:
-            return
-        for pid in _processing_context_pids:
-            try:
-                os.kill(pid, signal.SIGTERM)
-            except OSError:
-                pass
-        if clear:
-            _processing_context_pids.clear()
-
-
-async def wait_all_processes_in_context(wait_for: int):
-    global _processing_context_pids, _terminate_all_on_error
-    wait_pids = set()
-    while len(get_processing_context()) < wait_for:
-        await asyncio.sleep(0.01)
-
-    with _lock:
-        if _processing_context_pids is None:
-            return
-        wait_pids.update(_processing_context_pids)
-
-    wait_lock = threading.Lock()
-    finished_pids = []
-
-    def process(pid: int, returncode: int):
-        with wait_lock:
-            finished_pids.append(pid)
-        if returncode != 0 and _terminate_all_on_error:
-            terminate_all_processes_in_context()
-
-    def wait_all_processes():
-        while len(finished_pids) < len(wait_pids):
-            try:
-                pid, status = os.wait()
-            except ChildProcessError:
-                return
-            if pid in wait_pids:
-                process(pid, os.waitstatus_to_exitcode(status))
-
-    await asyncio.to_thread(wait_all_processes)
+        p.terminate()
+        p.wait()
+
+
+def should_use_group(sandboxes: List[SandboxBase]) -> bool:
+    if not sandboxes:
+        return False
+    uses_pgid = all(sandbox.use_pgid() for sandbox in sandboxes)
+    all_pgids = set(
+        sandbox.params.pgid for sandbox in sandboxes if sandbox.params.pgid is not None
+    )
+    return uses_pgid and len(all_pgids) == 1
+
+
+async def _fetch_pids(sandboxes: List[SandboxBase]) -> List[int]:
+    return [await sandbox.get_pid() for sandbox in sandboxes]
+
+
+def _find_sandbox_idx(pids: List[int], pid: int) -> Optional[int]:
+    try:
+        return pids.index(pid)
+    except ValueError:
+        return None
+
+
+async def _wait_for_group(sandboxes: List[SandboxBase]) -> List[int]:
+    pgid = [
+        sandbox.params.pgid for sandbox in sandboxes if sandbox.params.pgid is not None
+    ][0]
+    assert pgid is not None
+
+    sandbox_pids = await _fetch_pids(sandboxes)
+
+    finished = []
+    while len(finished) < len(sandboxes):
+        try:
+            pid, status = os.waitpid(-pgid, 0)
+        except ChildProcessError:
+            break
+
+        if os.waitstatus_to_exitcode(status) != 0:
+            os.kill(pgid, signal.SIGKILL)
+
+        sandbox_idx = _find_sandbox_idx(sandbox_pids, pid)
+        if sandbox_idx is not None:
+            finished.append(sandbox_idx)
+            continue
+
+    return finished
+
+
+async def wait_all(sandboxes: List[SandboxBase]):
+    if not should_use_group(sandboxes):
+        raise RuntimeError('Sandboxes are not using a process group')
+
+    await _wait_for_group(sandboxes)

rbx/grading/steps.py

@@ -10,7 +10,6 @@ import shutil
 import subprocess
 import sys
 import tempfile
-import typing
 from enum import Enum
 from typing import IO, Any, Dict, Iterable, List, Optional, Tuple, Union
 
@@ -53,6 +52,27 @@ class Outcome(Enum):
             Outcome.IDLENESS_LIMIT_EXCEEDED,
         ]
 
+    def short_name(self) -> str:
+        if self == Outcome.ACCEPTED:
+            return 'AC'
+        if self == Outcome.WRONG_ANSWER:
+            return 'WA'
+        if self == Outcome.TIME_LIMIT_EXCEEDED:
+            return 'TLE'
+        if self == Outcome.IDLENESS_LIMIT_EXCEEDED:
+            return 'ILE'
+        if self == Outcome.MEMORY_LIMIT_EXCEEDED:
+            return 'MLE'
+        if self == Outcome.RUNTIME_ERROR:
+            return 'RTE'
+        if self == Outcome.OUTPUT_LIMIT_EXCEEDED:
+            return 'OLE'
+        if self == Outcome.JUDGE_FAILED:
+            return 'FL'
+        if self == Outcome.INTERNAL_ERROR:
+            return 'IE'
+        return 'XX'
+
 
 class DigestHolder(BaseModel):
     value: Optional[str] = None
@@ -372,12 +392,12 @@ def _is_c_command(exe_command: str) -> bool:
     return 'gcc' in exe_command or 'clang' in exe_command
 
 
-def _is_cpp_command(exe_command: str) -> bool:
+def is_cpp_command(exe_command: str) -> bool:
     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)
+    return is_cpp_command(exe_command) or _is_c_command(exe_command)
 
 
 def is_cxx_sanitizer_command(command: str) -> bool:
@@ -413,7 +433,8 @@ def _complain_about_clang() -> None:
     )
 
 
-def _get_cxx_version_output(command: str) -> Optional[str]:
+@functools.cache
+def _get_cxx_version_output(command: str, extra_flags: str = '') -> Optional[str]:
     cmds = shlex.split(command)
     if not cmds:
         return None
@@ -421,8 +442,8 @@ def _get_cxx_version_output(command: str) -> Optional[str]:
     if not is_cxx_command(exe):
         return None
 
-    exe = cmds[0]
-    output = subprocess.run([exe, '-v'], capture_output=True)
+    extra = shlex.split(extra_flags)
+    output = subprocess.run([exe, '-v', *extra], capture_output=True, input='')
     if output.returncode != 0:
         console.print('[error]Failed to get C/C++ compiler version.[/error]')
         return None
@@ -430,6 +451,8 @@ def _get_cxx_version_output(command: str) -> Optional[str]:
 
 
 def _maybe_get_bits_stdcpp_for_clang(command: str) -> Optional[GradingFileInput]:
+    if not is_cpp_command(get_exe_from_command(command)):
+        return None
     version_output = _get_cxx_version_output(command)
     if version_output is None:
         return None
@@ -446,11 +469,44 @@ def _maybe_get_bits_stdcpp_for_clang(command: str) -> Optional[GradingFileInput]
     return GradingFileInput(src=bits, dest=pathlib.Path('bits/stdc++.h'))
 
 
-def _maybe_get_bits_stdcpp_for_commands(
+def _find_system_paths_in_version_output(version_output: str) -> List[pathlib.Path]:
+    res = []
+    start = False
+    for line in version_output.splitlines():
+        if line.startswith('#include <...> search starts here:'):
+            start = True
+            continue
+        if not start:
+            continue
+        if not line.startswith(' '):
+            break
+        res.append(pathlib.Path(line.strip()))
+    return res
+
+
+def _get_system_bits_stdcpp(command: str) -> Optional[GradingFileInput]:
+    if not is_cpp_command(get_exe_from_command(command)):
+        return None
+    version_output = _get_cxx_version_output(command, '-xc++ -E -')
+    if version_output is None:
+        return None
+    for path in _find_system_paths_in_version_output(version_output):
+        bits_candidate = path / 'bits' / 'stdc++.h'
+        if not bits_candidate.is_file():
+            continue
+        return GradingFileInput(
+            src=bits_candidate.resolve().absolute(), dest=pathlib.Path('bits/stdc++.h')
+        )
+    return None
+
+
+def maybe_get_bits_stdcpp_for_commands(
     commands: List[str],
 ) -> Optional[GradingFileInput]:
     for command in commands:
-        res = _maybe_get_bits_stdcpp_for_clang(command)
+        res = _get_system_bits_stdcpp(command) or _maybe_get_bits_stdcpp_for_clang(
+            command
+        )
         if res is not None:
             return res
     return None
@@ -560,10 +616,9 @@ def compile(
     sandbox: SandboxBase,
     artifacts: GradingArtifacts,
 ) -> bool:
+    sandbox.reset()
+
     commands = _try_following_alias_for_commands(commands)
-    bits_artifact = _maybe_get_bits_stdcpp_for_commands(commands)
-    if bits_artifact is not None:
-        _process_input_artifacts(GradingArtifacts(inputs=[bits_artifact]), sandbox)
     _process_input_artifacts(artifacts, sandbox)
 
     if not commands:
@@ -571,7 +626,9 @@ def compile(
         return True
 
     logs: List[PreprocessLog] = []
-    sandbox.set_params(params)
+    sandbox.set_params(
+        params.model_copy(deep=True)
+    )  # Copy to allow further modification.
 
     for i, command in enumerate(commands):
         _maybe_complain_about_sanitization(command)
@@ -584,10 +641,6 @@ def compile(
         if is_java_like_command(get_exe_from_command(command)):
             sandbox.params.address_space = None
 
-        if bits_artifact is not None and _is_cpp_command(cmd[0]):
-            # Include from sandbox directory to import bits/stdc++.h.
-            cmd.append('-I.')
-
         if not sandbox.execute_without_std(cmd):
             console.print(
                 '[error]Sandbox crashed while processing command:[/error]',
@@ -642,17 +695,21 @@ async def run(
     sandbox: SandboxBase,
     artifacts: GradingArtifacts,
     metadata: Optional[RunLogMetadata] = None,
-    kill_on_processing_context_exit: bool = False,
 ) -> Optional[RunLog]:
+    sandbox.reset()
+
     _process_input_artifacts(artifacts, sandbox)
     _process_fifos(artifacts, sandbox)
     cmd = _split_and_expand(command, sandbox)
-    sandbox.set_params(params)
+    sandbox.set_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
 
+    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]',
@@ -662,9 +719,6 @@ async def run(
         )
         return None
 
-    if sandbox.get_exit_code() != 0 and kill_on_processing_context_exit:
-        processing_context.terminate_all_processes_in_context(clear=False)
-
     if not _process_output_artifacts(artifacts, sandbox):
         return None
 
@@ -706,27 +760,25 @@ async def run_coordinated(
     interactor: CoordinatedRunParams,
     solution: CoordinatedRunParams,
 ) -> Tuple[Optional[RunLog], Optional[RunLog]]:
-    with processing_context.new_processing_context(terminate_all_on_error=True):
-        # Schedule both runs to execute immediately.
-        runs = tuple(
-            asyncio.create_task(
-                run(
-                    params.command,
-                    params.params,
-                    params.sandbox,
-                    params.artifacts,
-                    params.metadata,
-                    kill_on_processing_context_exit=True,
-                )
+    def run_one(params: CoordinatedRunParams) -> asyncio.Task[Optional[RunLog]]:
+        return asyncio.create_task(
+            run(
+                params.command,
+                params.params,
+                params.sandbox,
+                params.artifacts,
+                params.metadata,
             )
-            for params in [interactor, solution]
-        )
-        await processing_context.wait_all_processes_in_context(wait_for=2)
-        logs = typing.cast(
-            Tuple[Optional[RunLog], Optional[RunLog]],
-            tuple(await asyncio.gather(*runs)),
         )
-        return logs
+
+    # 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)
+
+    await processing_context.wait_all([interactor.sandbox, solution.sandbox])
+
+    return await asyncio.gather(interactor_task, solution_task)
 
 
 def _normalize_checked_words(s: str) -> Tuple[str, ...]:

rbx/resources/packagers/boca/checker.sh

@@ -1,4 +1,7 @@
 ### START OF CHECKER COMPILATION
+CACHE_DIR="/tmp/boca-cache"
+mkdir -p $CACHE_DIR
+
 CDIR=$(pwd)
 CHECKER_PATH="checker.cpp"
 CHECKER_OUT="checker.exe"
@@ -27,7 +30,7 @@ printf "%s" "${RbxHeaderContent}" >rbx.h
 printf "%s" "${CheckerContent}" >$CHECKER_PATH
 
 checker_hash=($(cat $CHECKER_PATH rbx.h testlib.h | md5sum))
-checker_cache="/tmp/boca-chk-${checker_hash}"
+checker_cache="$CACHE_DIR/checker-${checker_hash}"
 
 echo "Polygon checker hash: $checker_hash"
 echo "Copying polygon checker to $CDIR/$CHECKER_OUT"

rbx/resources/packagers/boca/compile/c

@@ -92,12 +92,8 @@ if [ "$4" != "" ]; then
 fi
 
 # setting up the timelimit according to the problem
-if [ "$3" == "" ]; then
-  time=5
-else
-  time=$3
-fi
-let "ttime = $time + 30"
+time=15
+let "ttime = $time * 2"
 
 if [ "$2" == "" ]; then
   exe=run.exe

rbx/resources/packagers/boca/compile/cc

@@ -93,12 +93,8 @@ if [ "$4" != "" ]; then
 fi
 
 # setting up the timelimit according to the problem
-if [ "$3" == "" ]; then
-  time=5
-else
-  time=$3
-fi
-let "ttime = $time + 30"
+time=15
+let "ttime = $time * 2"
 
 if [ "$2" == "" ]; then
   exe=run.exe

rbx/resources/packagers/boca/compile/cpp

@@ -92,12 +92,8 @@ if [ "$4" != "" ]; then
 fi
 
 # setting up the timelimit according to the problem
-if [ "$3" == "" ]; then
-  time=5
-else
-  time=$3
-fi
-let "ttime = $time + 30"
+time=15
+let "ttime = $time * 2"
 
 if [ "$2" == "" ]; then
   exe=run.exe

rbx/resources/packagers/boca/compile/java

@@ -88,13 +88,8 @@ if [ ! -x $sf ]; then
 fi
 
 # setting up the timelimit according to the problem
-if [ "$3" == "" ]; then
-  time=5
-else
-  time=$3
-fi
-let "ttime = $time + 30"
 time=30
+ttime=30
 
 maxm=512
 if [ "$4" != "" -a "$4" -gt "512" ]; then

rbx/resources/packagers/boca/compile/kt

@@ -41,22 +41,22 @@
 
 umask 0022
 if [ "$1" == "" ]; then
-    echo "parameter problem"
-    exit 43
+	echo "parameter problem"
+	exit 43
 fi
 name="$1"
 if [ ! -r "$1" ]; then
-    echo "$1 not found or it's not readable"
-    exit 44
+	echo "$1 not found or it's not readable"
+	exit 44
 fi
 id -u bocajail >/dev/null 2>/dev/null
 if [ $? == 0 ]; then
-	bocau=`id -u bocajail`
-	bocag=`id -g bocajail`
+	bocau=$(id -u bocajail)
+	bocag=$(id -g bocajail)
 	chown bocajail.nogroup .
 else
-	bocau=`id -u nobody`
-	bocag=`id -g nobody`
+	bocau=$(id -u nobody)
+	bocag=$(id -g nobody)
 	chown nobody.nogroup .
 fi
 if [ "$bocau" == "" -o "$bocag" == "" ]; then
@@ -67,10 +67,10 @@ fi
 mkdir -p src
 if [ "${name##*.}" == "zip" -a "${name##*.}" == "ZIP" ]; then
 	unzip "$name" -d src
-    if [ "${name##*.}" == "zip" ]; then
-		name=`basename $name .zip`
+	if [ "${name##*.}" == "zip" ]; then
+		name=$(basename $name .zip)
 	else
-		name=`basename $name .ZIP`
+		name=$(basename $name .ZIP)
 	fi
 else
 	cp "$name" src
@@ -80,42 +80,38 @@ chmod -R 700 src
 
 # this script makes use of safeexec to execute the code with less privilegies
 # make sure that directories below are correct.
-sf=`which safeexec`
+sf=$(which safeexec)
 [ -x "$sf" ] || sf=/usr/bin/safeexec
 if [ ! -x $sf ]; then
-    echo "$sf not found or it's not executable"
-    exit 46
+	echo "$sf not found or it's not executable"
+	exit 46
 fi
 
 # setting up the timelimit according to the problem
-if [ "$3" == "" ]; then
-  time=5
-else
-  time=$3
-fi
-let "ttime = $time + 30"
+time=30
+ttime=30
 
 maxm=1024
 if [ "$4" != "" -a "$4" -gt "1024" ]; then
-maxm=$4
+	maxm=$4
 fi
 
 maxms=100
 
 if [ "$2" == "" ]; then
-  jarfile=run.jar
+	jarfile=run.jar
 else
-  jarfile=$2
+	jarfile=$2
 fi
 
-cdir=`pwd`
+cdir=$(pwd)
 echo "Current directory is $cdir" >&2
-mainname=`echo $name | cut -d'.' -f1`
+mainname=$(echo $name | cut -d'.' -f1)
 if [ "$mainname" == "" ]; then
-  mainname=Main
+	mainname=Main
 fi
 
-cat <<EOF > compileit.sh
+cat <<EOF >compileit.sh
 #!/bin/bash
 kotlinc=/snap/kotlin/24/bin/kotlinc
 [ -x "\$kotlinc" ] || kotlinc=/snap/bin/kotlinc
@@ -147,7 +143,7 @@ if [ "$ret" != "0" ]; then
 	echo "Compilation Error: $ret"
 	exit $ret
 fi
-ret=`cat compileit.retcode`
+ret=$(cat compileit.retcode)
 if [ "$ret" != "0" ]; then
 	echo "Compilation Error: $ret"
 	ret=1

rbx/resources/packagers/boca/compile/py2

@@ -92,12 +92,8 @@ if [ "$4" != "" ]; then
 fi
 
 # setting up the timelimit according to the problem
-if [ "$3" == "" ]; then
-  time=5
-else
-  time=$3
-fi
-let "ttime = $time + 30"
+time=15
+let "ttime = $time * 2"
 
 if [ "$2" == "" ]; then
   exe=run.exe

rbx/resources/packagers/boca/compile/py3

@@ -92,12 +92,8 @@ if [ "$4" != "" ]; then
 fi
 
 # setting up the timelimit according to the problem
-if [ "$3" == "" ]; then
-  time=5
-else
-  time=$3
-fi
-let "ttime = $time + 30"
+time=15
+let "ttime = $time * 2"
 
 if [ "$2" == "" ]; then
   exe=run.exe