rbx.cp 0.5.45__tar.gz → 0.5.46__tar.gz

{rbx_cp-0.5.45 → rbx_cp-0.5.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rbx.cp
-Version: 0.5.45
+Version: 0.5.46
 Summary: 
 Author: Roberto Sales
 Requires-Python: >=3.9,<4.0

{rbx_cp-0.5.45 → rbx_cp-0.5.46}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rbx.cp"
-version = "0.5.45"
+version = "0.5.46"
 description = ""
 packages = [
   {include = "rbx"}

{rbx_cp-0.5.45 → rbx_cp-0.5.46}/rbx/box/generators.py

@@ -1,6 +1,5 @@
 import pathlib
 import shutil
-import tempfile
 from typing import Dict, List, Optional, Set
 
 import typer
@@ -63,6 +62,47 @@ def _copy_testcase_over(
         )
 
 
+def _copy_testcase_output_over(
+    src_output_path: pathlib.Path, dest_output_path: pathlib.Path, suffix: str
+) -> bool:
+    dest_output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    src_path = src_output_path.with_suffix(suffix)
+    if not src_path.is_file():
+        return False
+
+    shutil.copy(str(src_path), str(dest_output_path.with_suffix(suffix)))
+    return True
+
+
+def _copy_testcase_outputs_over(
+    testcase: Testcase, dest: Testcase, pipes: bool = False
+):
+    assert dest.outputPath is not None
+    dest.outputPath.parent.mkdir(parents=True, exist_ok=True)
+
+    has_copied = False
+
+    if testcase.outputPath is not None and testcase.outputPath.is_file():
+        shutil.copy(str(testcase.outputPath), str(dest.outputPath))
+        has_copied = True
+
+    if not pipes:
+        return has_copied
+
+    reference_path = testcase.outputPath or testcase.inputPath
+    if _copy_testcase_output_over(reference_path, dest.outputPath, '.pin'):
+        has_copied = True
+
+    if _copy_testcase_output_over(reference_path, dest.outputPath, '.pout'):
+        has_copied = True
+
+    if _copy_testcase_output_over(reference_path, dest.outputPath, '.pio'):
+        has_copied = True
+
+    return has_copied
+
+
 def get_all_built_testcases() -> Dict[str, List[Testcase]]:
     pkg = package.find_problem_package_or_die()
     res = {group.name: find_built_testcases(group) for group in pkg.testcases}
@@ -256,59 +296,46 @@ async def generate_testcases(
 async def generate_output_for_testcase(
     main_solution_digest: str,
     testcase: Testcase,
-    stderr_path: Optional[pathlib.Path] = None,
     interactor_digest: Optional[str] = None,
 ):
     assert testcase.outputPath is not None
     testcase.inputPath.parent.mkdir(parents=True, exist_ok=True)
     testcase.outputPath.parent.mkdir(parents=True, exist_ok=True)
 
-    if testcase.outputPath.is_file():
-        # Output file was already copied over from manual tests.
-        return
-
     main_solution = package.get_main_solution()
     if main_solution is None:
         return
 
-    with tempfile.TemporaryDirectory() as dir:
-        output_dir = pathlib.Path(dir)
+    eval: Evaluation = await run_solution_on_testcase(
+        main_solution,
+        main_solution_digest,
+        None,
+        testcase,
+        interactor_digest=interactor_digest,
+        use_retries=False,
+        use_timelimit=False,
+        capture_pipes=True,
+    )
 
-        eval: Evaluation = await run_solution_on_testcase(
-            main_solution,
-            main_solution_digest,
-            None,
-            testcase,
-            output_dir,
-            interactor_digest=interactor_digest,
-            use_retries=False,
-            use_timelimit=False,
+    if eval.result.outcome != Outcome.ACCEPTED:
+        console.console.print(
+            f'[error]Failed generating output for [item]{testcase.inputPath}[/item][/error]',
         )
-
-        if eval.log.stdout_absolute_path is not None:
-            shutil.copy(eval.log.stdout_absolute_path, testcase.outputPath)
-        if eval.log.stderr_absolute_path is not None and stderr_path is not None:
-            shutil.copy(eval.log.stderr_absolute_path, stderr_path)
-
-        if eval.result.outcome != Outcome.ACCEPTED:
-            console.console.print(
-                f'[error]Failed generating output for [item]{testcase.inputPath}[/item][/error]',
-            )
-            console.console.print(f'[error]Summary:[/error] {eval.log.get_summary()}')
-            console.console.print(
-                f'[warning]Verdict: [item]{eval.result.outcome.value}[/item][/warning]',
-            )
-            console.console.print(
-                f'[warning]Message: [info]{eval.result.message}[/info][/warning]',
-            )
-            console.console.print(f'Input written at [item]{testcase.inputPath}[/item]')
+        console.console.print(f'[error]Summary:[/error] {eval.log.get_summary()}')
+        console.console.print(
+            f'[warning]Verdict: [item]{eval.result.outcome.value}[/item][/warning]',
+        )
+        console.console.print(
+            f'[warning]Message: [info]{eval.result.message}[/info][/warning]',
+        )
+        console.console.print(f'Input written at [item]{testcase.inputPath}[/item]')
+        console.console.print(f'Output written at [item]{testcase.outputPath}[/item]')
+        if eval.log.stderr_absolute_path is not None:
             console.console.print(
-                f'Output written at [item]{testcase.outputPath}[/item]'
+                f'Stderr written at [item]{eval.log.stderr_absolute_path}[/item]'
             )
-            if stderr_path is not None:
-                console.console.print(f'Stderr written at [item]{stderr_path}[/item]')
 
-            raise typer.Exit(1)
+        raise typer.Exit(1)
 
 
 async def generate_outputs_for_testcases(
@@ -350,6 +377,14 @@ async def generate_outputs_for_testcases(
             return
         assert tc.outputPath is not None
 
+        if entry.metadata.copied_from is not None and _copy_testcase_outputs_over(
+            entry.metadata.copied_from, tc
+        ):
+            # Copy remaining pipe files.
+            _copy_testcase_outputs_over(entry.metadata.copied_from, tc, pipes=True)
+            step()
+            continue
+
         if (
             main_solution is None or solution_digest is None
         ) and not tc.outputPath.is_file():
@@ -362,7 +397,9 @@ async def generate_outputs_for_testcases(
         await generate_output_for_testcase(
             solution_digest,
             tc,
-            gen_runs_dir / 'main.stderr',
             interactor_digest=interactor_digest,
         )
+        if entry.metadata.copied_from is not None:
+            # Copy remaining pipe files.
+            _copy_testcase_outputs_over(entry.metadata.copied_from, tc, pipes=True)
         step()

{rbx_cp-0.5.45 → rbx_cp-0.5.46}/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,
             )

{rbx_cp-0.5.45 → rbx_cp-0.5.46}/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_cp-0.5.45 → rbx_cp-0.5.46}/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,7 +189,11 @@ async def _run_communication_solution_on_testcase(
             )
         # TODO: maybe combine wall time limits?
 
-        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)

{rbx_cp-0.5.45 → rbx_cp-0.5.46}/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_cp-0.5.45 → rbx_cp-0.5.46}/rbx/grading/judge/sandboxes/isolate.py

@@ -556,7 +556,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,
             )
@@ -680,4 +680,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_cp-0.5.45 → rbx_cp-0.5.46}/rbx/grading/judge/sandboxes/stupid_sandbox.py

@@ -321,4 +321,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)