rbx.cp 0.5.45__py3-none-any.whl → 0.5.47__py3-none-any.whl

rbx/box/packaging/packager.py

@@ -7,7 +7,7 @@ from rbx.box import package
 from rbx.box.contest import contest_package
 from rbx.box.contest.schema import ContestProblem, ContestStatement
 from rbx.box.generators import get_all_built_testcases
-from rbx.box.schema import Package, Testcase, TestcaseGroup
+from rbx.box.schema import Package, TaskType, Testcase, TestcaseGroup
 from rbx.box.statements.schema import Statement, StatementType
 
 
@@ -33,10 +33,15 @@ class BuiltProblemPackage:
 
 
 class BasePackager(ABC):
+    @classmethod
     @abstractmethod
-    def name(self) -> str:
+    def name(cls) -> str:
         pass
 
+    @classmethod
+    def task_types(cls) -> List[TaskType]:
+        return [TaskType.BATCH]
+
     def languages(self):
         pkg = package.find_problem_package_or_die()
 

rbx/box/packaging/polygon/packager.py

@@ -188,15 +188,15 @@ class PolygonPackager(BasePackager):
         for i, testcase in enumerate(testcases):
             shutil.copyfile(
                 testcase.inputPath,
-                into_path / f'tests/{i+1:03d}',
+                into_path / f'tests/{i + 1:03d}',
             )
             if testcase.outputPath is not None:
                 shutil.copyfile(
                     testcase.outputPath,
-                    into_path / f'tests/{i+1:03d}.a',
+                    into_path / f'tests/{i + 1:03d}.a',
                 )
             else:
-                (into_path / f'tests/{i+1:03d}.a').touch()
+                (into_path / f'tests/{i + 1:03d}.a').touch()
 
         # Write problem.xml
         (into_path / 'problem.xml').write_text(descriptor)
@@ -208,7 +208,8 @@ class PolygonPackager(BasePackager):
 
 
 class PolygonContestPackager(BaseContestPackager):
-    def name(self) -> str:
+    @classmethod
+    def name(cls) -> str:
         return 'polygon'
 
     def _get_names(self) -> List[polygon_schema.Name]:

rbx/box/solutions.py

@@ -185,7 +185,7 @@ def _run_solution(
                 compiled_digest,
                 checker_digest,
                 testcase,
-                output_path,
+                output_dir=output_path,
                 interactor_digest=interactor_digest,
                 testcase_index=i,
                 verification=verification,
@@ -367,6 +367,7 @@ async def _generate_testcase_interactively(
     )
 
     is_manual = False
+    is_output_manual = False
     generation_metadata = None
     if generator is not None:
         generation_metadata = GenerationMetadata(
@@ -398,6 +399,7 @@ async def _generate_testcase_interactively(
                 output = console.multiline_prompt('Testcase output')
                 testcase.outputPath.write_text(output)
                 console.console.print()
+            is_output_manual = True
 
         generation_metadata = GenerationMetadata(
             copied_to=testcase,
@@ -453,7 +455,7 @@ async def _generate_testcase_interactively(
             )
             raise
 
-    if main_solution_digest is not None:
+    if main_solution_digest is not None and not is_output_manual:
         pkg = package.find_problem_package_or_die()
         if pkg.type == TaskType.COMMUNICATION:
             interactor_digest = checkers.compile_interactor(progress)
@@ -523,7 +525,7 @@ def _run_interactive_solutions(
                 compiled_solutions[solution.path],
                 checker_digest,
                 testcase,
-                output_dir,
+                output_dir=output_dir,
                 interactor_digest=interactor_digest,
                 verification=verification,
             )
@@ -614,7 +616,7 @@ def _get_solution_repr(sol: Solution) -> List[Tuple[str, str]]:
     ]
 
 
-def pick_solutions(tracked_solutions: Optional[Set[str]]) -> List[str]:
+async def pick_solutions(tracked_solutions: Optional[Set[str]]) -> List[str]:
     pkg = package.find_problem_package_or_die()
     if tracked_solutions is None:
         tracked_solutions = set(str(sol.path) for sol in pkg.solutions)
@@ -628,7 +630,7 @@ def pick_solutions(tracked_solutions: Optional[Set[str]]) -> List[str]:
         if str(sol.path) in tracked_solutions
     ]
 
-    picked = questionary.checkbox('Select solutions', choices=choices).ask()
+    picked = await questionary.checkbox('Select solutions', choices=choices).ask_async()
     if picked is None:
         raise typer.Abort()
     return picked

rbx/box/statements/builders.py

@@ -25,6 +25,7 @@ from rbx.box.statements.schema import (
     TexToPDF,
     rbxToTeX,
 )
+from rbx.box.testcase_utils import TestcaseInteraction, parse_interaction
 
 
 @dataclasses.dataclass
@@ -63,13 +64,31 @@ class StatementSample(BaseModel):
     inputPath: pathlib.Path
     outputPath: pathlib.Path
     hasOutput: bool = True
+    interaction: Optional[TestcaseInteraction] = None
 
     @staticmethod
     def from_testcase(testcase: Testcase) -> 'StatementSample':
+        input_path = testcase.inputPath
+        output_path = testcase.outputPath
+
+        pin_path = input_path.with_suffix('.pin')
+        pout_path = input_path.with_suffix('.pout')
+        pio_path = input_path.with_suffix('.pio')
+
+        if pin_path.is_file():
+            input_path = pin_path
+        if pout_path.is_file():
+            output_path = pout_path
+
+        interaction = None
+        if pio_path.is_file():
+            interaction = parse_interaction(pio_path)
+
         return StatementSample(
-            inputPath=testcase.inputPath,
-            outputPath=testcase.outputPath or utils.get_empty_sentinel_path(),
-            hasOutput=testcase.outputPath is not None,
+            inputPath=input_path,
+            outputPath=output_path or utils.get_empty_sentinel_path(),
+            hasOutput=output_path is not None,
+            interaction=interaction,
         )
 
     @staticmethod

rbx/box/stresses.py

@@ -50,7 +50,6 @@ def _compile_finder(finder: CodeItem) -> str:
     return digest
 
 
-@syncer.sync
 async def run_stress(
     name: str,
     timeoutInSeconds: int,

rbx/box/tasks.py

@@ -42,7 +42,7 @@ async def run_solution_on_testcase(
     compiled_digest: str,
     checker_digest: Optional[str],
     testcase: Testcase,
-    output_dir: pathlib.Path,
+    output_dir: Optional[pathlib.Path] = None,
     interactor_digest: Optional[str] = None,
     testcase_index: int = 0,
     verification: VerificationLevel = VerificationLevel.NONE,
@@ -78,7 +78,11 @@ async def run_solution_on_testcase(
         )
         extra_config = _get_execution_config(limits, actual_sandbox)
 
-        output_path = output_dir / testcase.inputPath.with_suffix('.out').name
+        if output_dir is None:
+            assert testcase.outputPath is not None
+            output_path = testcase.outputPath
+        else:
+            output_path = output_dir / testcase.inputPath.with_suffix('.out').name
         error_path = output_path.with_suffix('.err')
         log_path = output_path.with_suffix('.log')
         output_path.parent.mkdir(parents=True, exist_ok=True)
@@ -151,7 +155,7 @@ async def _run_communication_solution_on_testcase(
     interactor_digest: str,
     checker_digest: Optional[str],
     testcase: Testcase,
-    output_dir: pathlib.Path,
+    output_dir: Optional[pathlib.Path] = None,
     testcase_index: int = 0,
     verification: VerificationLevel = VerificationLevel.NONE,
     timelimit_override: Optional[int] = None,
@@ -185,8 +189,13 @@ async def _run_communication_solution_on_testcase(
             )
         # TODO: maybe combine wall time limits?
 
-        output_path = output_dir / testcase.inputPath.with_suffix('.out').name
-        error_path = output_path.with_suffix('.err')
+        if output_dir is None:
+            assert testcase.outputPath is not None
+            output_path = testcase.outputPath
+        else:
+            output_path = output_dir / testcase.inputPath.with_suffix('.out').name
+        solution_error_path = output_path.with_suffix('.sol.err')
+        interactor_error_path = output_path.with_suffix('.int.err')
         log_path = output_path.with_suffix('.log')
         output_path.parent.mkdir(parents=True, exist_ok=True)
 
@@ -196,7 +205,7 @@ async def _run_communication_solution_on_testcase(
         interactor_item = CommunicationItem(
             code=package.get_interactor(),
             executable=DigestOrSource.create(interactor_digest),
-            stderr=DigestOrDest.create(error_path),
+            stderr=DigestOrDest.create(interactor_error_path),
             extra_config=interactor_extra_config,
             extra_args='interactor.in interactor.out',
             inputs=[
@@ -222,6 +231,7 @@ async def _run_communication_solution_on_testcase(
         solution_item = CommunicationItem(
             code=solution,
             executable=DigestOrSource.create(compiled_digest),
+            stderr=DigestOrDest.create(solution_error_path),
             extra_config=extra_config,
             capture=DigestOrDest.create(solution_capture_path)
             if solution_capture_path
@@ -240,7 +250,7 @@ async def _run_communication_solution_on_testcase(
             checker_digest,
             run_log,
             interactor_run_log,
-            error_path,
+            interactor_error_path,
             testcase,
             output_path,
         )
@@ -255,7 +265,7 @@ async def _run_communication_solution_on_testcase(
             log=TestcaseLog(
                 **(run_log.model_dump() if run_log is not None else {}),
                 stdout_absolute_path=output_path.absolute(),
-                stderr_absolute_path=error_path.absolute(),
+                stderr_absolute_path=solution_error_path.absolute(),
                 log_absolute_path=log_path.absolute(),
             ),
         )

rbx/box/testcase_utils.py

@@ -97,6 +97,16 @@ class TestcaseData(BaseModel):
     output: str
 
 
+class TestcaseInteractionEntry(BaseModel):
+    data: str
+    pipe: int
+
+
+class TestcaseInteraction(BaseModel):
+    entries: List[TestcaseInteractionEntry]
+    prefixes: Tuple[str, str]
+
+
 def find_built_testcases(group: TestcaseGroup) -> List[Testcase]:
     inputs = find_built_testcase_inputs(group)
 
@@ -143,3 +153,59 @@ def fill_output_for_defined_testcase(testcase: Testcase) -> Testcase:
     if output_path.is_file():
         res.outputPath = output_path
     return res
+
+
+def parse_interaction(file: pathlib.Path) -> TestcaseInteraction:
+    entries = []
+    with file.open('r') as f:
+        try:
+            interactor_prefix = f.readline().strip()
+            solution_prefix = f.readline().strip()
+        except Exception:
+            console.console.print(
+                f'[error]Failed to read interaction file [item]{file}[/item]. Expected the first two lines to be the interactor and solution prefixes.[/error]'
+            )
+            raise typer.Exit(1) from None
+
+        rest = f.read()
+        start = 0
+
+        def _find_next_prefix(start: int) -> Optional[Tuple[int, int]]:
+            interactor_idx = rest.find(interactor_prefix, start)
+            solution_idx = rest.find(solution_prefix, start)
+            if interactor_idx == -1 and solution_idx == -1:
+                return None
+            if interactor_idx == -1:
+                return (solution_idx, solution_idx + len(solution_prefix))
+            if solution_idx == -1:
+                return (interactor_idx, interactor_idx + len(interactor_prefix))
+            if interactor_idx < solution_idx:
+                return (interactor_idx, interactor_idx + len(interactor_prefix))
+            return (solution_idx, solution_idx + len(solution_prefix))
+
+        def _find_next_block() -> Optional[Tuple[int, Tuple[int, int]]]:
+            prefix = _find_next_prefix(start)
+            if prefix is None:
+                return None
+            prefix_start, prefix_end = prefix
+            prefix = rest[prefix_start:prefix_end]
+            pipe = 1 if prefix == solution_prefix else 0
+
+            nxt = _find_next_prefix(prefix_end)
+            if nxt is None:
+                return (pipe, (prefix_end, len(rest)))
+            nxt_start, _ = nxt
+            return (pipe, (prefix_end, nxt_start))
+
+        while True:
+            block = _find_next_block()
+            if block is None:
+                break
+            pipe, (st, nd) = block
+            entries.append(TestcaseInteractionEntry(data=rest[st:nd], pipe=pipe))
+            start = nd
+
+    return TestcaseInteraction(
+        prefixes=(interactor_prefix, solution_prefix),
+        entries=entries,
+    )

rbx/grading/judge/sandbox.py

@@ -6,6 +6,7 @@ import logging
 import os
 import pathlib
 import select
+import signal
 import stat
 import subprocess
 import sys
@@ -14,6 +15,7 @@ from typing import IO, Any, Dict, List, Optional
 
 import pydantic
 
+from rbx.grading import processing_context
 from rbx.grading.judge import cacher, storage
 
 logger = logging.getLogger(__name__)
@@ -187,6 +189,7 @@ class SandboxBase(abc.ABC):
 
     EXIT_SANDBOX_ERROR = 'sandbox error'
     EXIT_OK = 'ok'
+    EXIT_TERMINATED = 'terminated'
     EXIT_SIGNAL = 'signal'
     EXIT_TIMEOUT = 'timeout'
     EXIT_TIMEOUT_WALL = 'wall timeout'
@@ -225,6 +228,7 @@ class SandboxBase(abc.ABC):
         self.cmd_file = pathlib.PosixPath('commands.log')
 
         self.params = params or SandboxParams()
+        self.pid = None
 
         # Set common environment variables.
         # Specifically needed by Python, that searches the home for
@@ -324,6 +328,28 @@ class SandboxBase(abc.ABC):
         """
         pass
 
+    def set_pid(self, pid: int):
+        processing_context.add_to_processing_context(pid)
+        self.pid = pid
+
+    def get_pid(self) -> Optional[int]:
+        """Return the PID of the sandboxed process.
+
+        return (int|None): the PID of the sandboxed process, or None if
+            the sandboxed process is not running.
+
+        """
+        return self.pid
+
+    @abc.abstractmethod
+    def get_detailed_logs(self) -> str:
+        """Return the detailed logs of the sandbox.
+
+        return (string): the detailed logs of the sandbox.
+
+        """
+        pass
+
     @abc.abstractmethod
     def get_human_exit_description(self) -> str:
         """Get the status of the sandbox and return a human-readable
@@ -667,7 +693,9 @@ class SandboxBase(abc.ABC):
             did).
 
         """
-        return exitcode == 0
+        # SIGTERM can be safely ignored, just in case it leaks away from
+        # the sandbox.
+        return exitcode == 0 or exitcode == -signal.SIGTERM
 
     @abc.abstractmethod
     def initialize(self):

rbx/grading/judge/sandboxes/isolate.py

@@ -420,6 +420,7 @@ class IsolateSandbox(SandboxBase):
         return (string): the main reason why the sandbox terminated.
 
         """
+        # TODO: figure out EXIT_TERMINATED
         assert self.log is not None
         status_list = self.get_status_list()
         if 'XX' in status_list:
@@ -462,6 +463,14 @@ class IsolateSandbox(SandboxBase):
             return 'Execution failed because the return code was nonzero'
         return ''
 
+    def get_detailed_logs(self) -> str:
+        """Return the detailed logs of the sandbox.
+
+        return (string): the detailed logs of the sandbox.
+
+        """
+        return str(self.log)
+
     def inner_absolute_path(self, path: pathlib.Path) -> pathlib.Path:
         """Translate from a relative path inside the sandbox to an
         absolute path inside the sandbox.
@@ -556,7 +565,7 @@ class IsolateSandbox(SandboxBase):
             )
         except OSError:
             logger.critical(
-                'Failed to execute program in sandbox ' 'with command: %s',
+                'Failed to execute program in sandbox with command: %s',
                 str(args),
                 exc_info=True,
             )
@@ -602,6 +611,7 @@ class IsolateSandbox(SandboxBase):
         # std*** to interfere with command. Otherwise we let the
         # caller handle these issues.
         with popen as p:
+            self.set_pid(p.pid)
             exitcode = self.translate_box_exitcode(
                 wait_without_std([p], actually_pipe_to_stdout=self.debug)[0]
             )
@@ -680,4 +690,4 @@ class IsolateSandbox(SandboxBase):
         if delete:
             logger.debug('Deleting sandbox in %s.', self._outer_dir)
             # Delete the working directory.
-            shutil.rmtree(str(self._outer_dir))
+            shutil.rmtree(str(self._outer_dir), ignore_errors=True)

rbx/grading/judge/sandboxes/stupid_sandbox.py

@@ -57,7 +57,6 @@ class StupidSandbox(SandboxBase):
         self.initialize()
 
         self.exec_num = -1
-        self.popen = None
         self.log = None
         self.returncode = None
 
@@ -192,9 +191,13 @@ class StupidSandbox(SandboxBase):
         return (string): the main reason why the sandbox terminated.
 
         """
-        if self.returncode != 0:
+        if self.returncode is not None and not self.translate_box_exitcode(
+            self.returncode
+        ):
             return self.EXIT_SANDBOX_ERROR
         status_list = self.get_status_list()
+        if 'TE' in status_list:
+            return self.EXIT_TERMINATED
         if 'WT' in status_list:
             return self.EXIT_TIMEOUT_WALL
         if 'TO' in status_list:
@@ -218,6 +221,9 @@ class StupidSandbox(SandboxBase):
         assert self.log is not None
         return int(self.log['exit-code'])
 
+    def get_detailed_logs(self) -> str:
+        return str(self.log)
+
     def get_human_exit_description(self) -> str:
         """Get the status of the sandbox and return a human-readable
         string describing it.
@@ -299,13 +305,19 @@ class StupidSandbox(SandboxBase):
             + self.get_timeit_args()
             + command
         )
-        self.returncode = subprocess.call(
+        with subprocess.Popen(
             real_command,
             stdin=subprocess.PIPE,
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
             env={**os.environ, **self.params.set_env},
-        )
+        ) as p:
+            self.set_pid(p.pid)
+            try:
+                self.returncode = p.wait()
+            except Exception:
+                p.kill()
+                raise
         self.hydrate_logs()
         return self.translate_box_exitcode(self.returncode)
 
@@ -321,4 +333,4 @@ class StupidSandbox(SandboxBase):
         # This sandbox doesn't have any cleanup, but we might want to delete.
         if delete:
             logger.debug('Deleting sandbox in %s.', self._path)
-            shutil.rmtree(str(self._path))
+            shutil.rmtree(str(self._path), ignore_errors=True)

rbx/grading/judge/sandboxes/timeit.py

@@ -223,6 +223,7 @@ def wait_and_finish(
     pid: int,
     options: Options,
     start_time: float,
+    status_holder: Set[str],
     alarm_msg: Optional[List[Optional[str]]] = None,
 ):
     _, exitstatus, ru = os.wait4(pid, 0)
@@ -237,7 +238,7 @@ def wait_and_finish(
     if exitcode < 0:
         entries.append(f'exit-sig: {-exitcode}')
 
-    status = set()
+    status = status_holder
     if exitcode > 0:
         status.add('RE')
     if exitcode < 0:
@@ -284,9 +285,11 @@ def main():
             os.chdir(options.chdir)
         set_rlimits(options)
         redirect_fds(options)
+        signal.signal(signal.SIGPIPE, signal.SIG_DFL)
         os.execvp(options.argv[0], options.argv)
 
     alarm_msg: List[Optional[str]] = [None]
+    status_holder: Set[str] = set()
 
     def handle_alarm(*args, **kwargs):
         nonlocal alarm_msg
@@ -311,15 +314,21 @@ def main():
 
         signal.setitimer(signal.ITIMER_REAL, 0.3)
 
+    def handle_sub_term(*args, **kwargs):
+        nonlocal status_holder
+        status_holder.add('TE')
+        os.kill(sub_pid, 9)
+
     signal.setitimer(signal.ITIMER_REAL, 0.3)
     signal.signal(signal.SIGALRM, handle_alarm)
-    wait_and_finish(sub_pid, options, start_time, alarm_msg=alarm_msg)
+    signal.signal(signal.SIGTERM, handle_sub_term)
 
+    wait_and_finish(sub_pid, options, start_time, status_holder, alarm_msg=alarm_msg)
     # Cancel alarm before exiting to avoid surprises.
     signal.setitimer(signal.ITIMER_REAL, 0)
 
     # Exit gracefully.
-    sys.exit()
+    sys.exit(0)
 
 
 if __name__ == '__main__':

rbx/grading/processing_context.py

@@ -0,0 +1,48 @@
+import contextlib
+import os
+import signal
+import threading
+from typing import Optional, Set
+
+_processing_context_pids: Optional[Set[int]] = None
+_lock = threading.Lock()
+
+# Creating a processing context is not thread-safe, but adding to it is.
+
+
+@contextlib.contextmanager
+def new_processing_context():
+    global _processing_context_pids
+    with _lock:
+        old_processing_context_pids = _processing_context_pids
+        _processing_context_pids = set()
+    try:
+        yield
+    finally:
+        with _lock:
+            _processing_context_pids = old_processing_context_pids
+
+
+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():
+    with _lock:
+        if _processing_context_pids is None:
+            return
+        for pid in _processing_context_pids:
+            try:
+                os.kill(pid, signal.SIGTERM)
+            except OSError:
+                pass
+        _processing_context_pids.clear()