rbx.cp 0.5.39__py3-none-any.whl → 0.5.42__py3-none-any.whl

rbx/box/package.py

@@ -1,5 +1,8 @@
+import atexit
 import functools
+import os
 import pathlib
+import shutil
 import sys
 from typing import Dict, List, Optional, Tuple
 
@@ -201,7 +204,9 @@ def get_digest_as_string(
 
 
 def get_new_sandbox(root: pathlib.Path = pathlib.Path()) -> SandboxBase:
-    return get_sandbox_type()(file_cacher=get_file_cacher(root), temp_dir=TEMP_DIR)
+    sandbox = get_sandbox_type()(file_cacher=get_file_cacher(root), temp_dir=TEMP_DIR)
+    atexit.register(lambda: sandbox.cleanup(delete=True))
+    return sandbox
 
 
 @functools.cache
@@ -209,6 +214,13 @@ def get_singleton_sandbox(root: pathlib.Path = pathlib.Path()) -> SandboxBase:
     return get_new_sandbox(root)
 
 
+@functools.cache
+def get_singleton_interactor_sandbox(
+    root: pathlib.Path = pathlib.Path(),
+) -> SandboxBase:
+    return get_new_sandbox(root)
+
+
 @functools.cache
 def get_build_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
     return find_problem(root) / 'build'
@@ -266,6 +278,23 @@ def get_checker(root: pathlib.Path = pathlib.Path()) -> CodeItem:
     )
 
 
+@functools.cache
+def get_interactor_or_nil(root: pathlib.Path = pathlib.Path()) -> Optional[CodeItem]:
+    package = find_problem_package_or_die(root)
+    return package.interactor
+
+
+@functools.cache
+def get_interactor(root: pathlib.Path = pathlib.Path()) -> CodeItem:
+    interactor = get_interactor_or_nil(root)
+    if interactor is None:
+        console.console.print(
+            '[error]Problem does not have an interactor configured.[/error]'
+        )
+        raise typer.Exit(1)
+    return interactor
+
+
 @functools.cache
 def get_solutions(root: pathlib.Path = pathlib.Path()) -> List[Solution]:
     package = find_problem_package_or_die(root)
@@ -371,6 +400,18 @@ def get_empty_sentinel_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path
     return path
 
 
+@functools.cache
+def get_fifos(root: pathlib.Path = pathlib.Path()) -> Tuple[pathlib.Path, pathlib.Path]:
+    path = get_problem_cache_dir(root) / '.fifos'
+    shutil.rmtree(path, ignore_errors=True)
+    path.mkdir(parents=True, exist_ok=True)
+    fifo_in = path / 'fifo.in'
+    fifo_out = path / 'fifo.out'
+    os.mkfifo(fifo_in)
+    os.mkfifo(fifo_out)
+    return fifo_in, fifo_out
+
+
 def clear_package_cache():
     pkgs = [sys.modules[__name__]]
 

rbx/box/packaging/boca/packager.py

@@ -169,7 +169,8 @@ class BocaPackager(BasePackager):
             compile_text = compile_text.replace('{{rbxFlags}}', flags[language])
         return compile_text
 
-    def _copy_solutions(self, into_path: pathlib.Path):
+    def _copy_solutions(self, into_path: pathlib.Path, fix_java: bool = True):
+        into_path = into_path / 'solutions'
         for solution in package.get_solutions():
             dest_path = (
                 into_path

rbx/box/packaging/main.py

@@ -2,6 +2,7 @@ import pathlib
 import tempfile
 from typing import Type
 
+import syncer
 import typer
 
 from rbx import annotations, console
@@ -13,20 +14,21 @@ from rbx.box.statements.build_statements import build_statement
 app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
 
 
-def run_packager(
+async def run_packager(
     packager_cls: Type[BasePackager],
     verification: environment.VerificationParam,
+    **kwargs,
 ) -> pathlib.Path:
     from rbx.box import builder
 
-    if not builder.verify(verification=verification):
+    if not await builder.verify(verification=verification):
         console.console.print(
             '[error]Build or verification failed, check the report.[/error]'
         )
         raise typer.Exit(1)
 
     pkg = package.find_problem_package_or_die()
-    packager = packager_cls()
+    packager = packager_cls(**kwargs)
 
     statement_types = packager.statement_types()
     built_statements = []
@@ -55,18 +57,33 @@ def run_packager(
 
 
 @app.command('polygon', help='Build a package for Polygon.')
-def polygon(
+@syncer.sync
+async def polygon(
     verification: environment.VerificationParam,
 ):
     from rbx.box.packaging.polygon.packager import PolygonPackager
 
-    run_packager(PolygonPackager, verification=verification)
+    await run_packager(PolygonPackager, verification=verification)
 
 
 @app.command('boca', help='Build a package for BOCA.')
-def boca(
+@syncer.sync
+async def boca(
     verification: environment.VerificationParam,
 ):
     from rbx.box.packaging.boca.packager import BocaPackager
 
-    run_packager(BocaPackager, verification=verification)
+    await run_packager(BocaPackager, verification=verification)
+
+
+@app.command('moj', help='Build a package for MOJ.')
+@syncer.sync
+async def moj(
+    verification: environment.VerificationParam,
+    for_boca: bool = typer.Option(
+        False, help='Build a package for BOCA instead of MOJ.'
+    ),
+):
+    from rbx.box.packaging.moj.packager import MojPackager
+
+    await run_packager(MojPackager, verification=verification, for_boca=for_boca)

rbx/box/packaging/moj/packager.py

@@ -0,0 +1,164 @@
+import pathlib
+import shutil
+from typing import List
+
+import typer
+
+from rbx import console
+from rbx.box import package
+from rbx.box.environment import get_extension_or_default
+from rbx.box.packaging.boca.extension import BocaExtension
+from rbx.box.packaging.boca.packager import BocaPackager
+from rbx.box.packaging.packager import BuiltStatement
+from rbx.box.schema import ExpectedOutcome
+from rbx.config import get_default_app_path, get_testlib
+from rbx.grading.judge.digester import digest_cooperatively
+
+
+class MojPackager(BocaPackager):
+    def __init__(self, for_boca: bool = False):
+        super().__init__()
+        self.for_boca = for_boca
+
+    def _get_problem_info(self) -> str:
+        statement = self._get_main_statement()
+        return (
+            f'basename={self._get_problem_name()}\n'
+            f'fullname={statement.title}\n'
+            f'descfile={self._get_problem_name()}.pdf\n'
+        )
+
+    def _get_tl(self) -> str:
+        extension = get_extension_or_default('boca', BocaExtension)
+
+        pkg = package.find_problem_package_or_die()
+        res = f'TL[default]={pkg.timeLimit / 1000}\n'
+        for language in extension.languages:
+            res += f'TL[{language}]={self._get_pkg_timelimit(language) / 1000}\n'
+        return res
+
+    def _get_limits(self) -> str:
+        pkg = package.find_problem_package_or_die()
+        ml = pkg.memoryLimit
+        ol = pkg.outputLimit
+        return f'ULIMITS[-f]={ol}\n' f'ULIMITS[-v]={ml * 1024}\n'
+
+    def _get_compare(self) -> str:
+        extension = get_extension_or_default('boca', BocaExtension)
+
+        compare_path = (
+            get_default_app_path() / 'packagers' / 'moj' / 'scripts' / 'compare.sh'
+        )
+        if not compare_path.exists():
+            console.console.print(
+                '[error]MOJ template compare script not found.[/error]'
+            )
+            raise typer.Exit(1)
+        with package.get_checker().path.open('rb') as f:
+            checker_hash = digest_cooperatively(f)
+        return (
+            compare_path.read_text()
+            .replace('{{rbxFlags}}', extension.flags_with_defaults()['cc'])
+            .replace('{{checkerHash}}', checker_hash)
+        )
+
+    def _get_checker(self) -> str:
+        return package.get_checker().path.read_text()
+
+    def _copy_solutions_moj(self, into_path: pathlib.Path):
+        into_path = into_path / 'sols'
+        has_good = False
+        for solution in package.get_solutions():
+            tag = 'wrong'
+            if solution.outcome == ExpectedOutcome.ACCEPTED:
+                tag = 'good'
+                has_good = True
+            elif solution.outcome.is_slow():
+                tag = 'slow'
+            dest_path = into_path / tag / solution.path.name
+            dest_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(str(solution.path), dest_path)
+
+        if not has_good:
+            console.console.print('[error]No good solution found.[/error]')
+            raise typer.Exit(1)
+
+    def name(self) -> str:
+        return 'moj'
+
+    def package(
+        self,
+        build_path: pathlib.Path,
+        into_path: pathlib.Path,
+        built_statements: List[BuiltStatement],
+    ) -> pathlib.Path:
+        # Prepare dummy files
+        author_path = into_path / 'author'
+        author_path.parent.mkdir(parents=True, exist_ok=True)
+        author_path.write_text('Unknown\n')
+
+        tags_path = into_path / 'tags'
+        tags_path.parent.mkdir(parents=True, exist_ok=True)
+        tags_path.write_text('')
+
+        # Prepare limits
+        limits_path = into_path / 'conf'
+        limits_path.parent.mkdir(parents=True, exist_ok=True)
+        limits_path.write_text(self._get_limits())
+
+        # Prepare TL
+        if self.for_boca:
+            tl_path = into_path / 'tl'
+            tl_path.parent.mkdir(parents=True, exist_ok=True)
+            tl_path.write_text(self._get_tl())
+
+        # Prepare compare
+        compare_path = into_path / 'scripts' / 'compare.sh'
+        compare_path.parent.mkdir(parents=True, exist_ok=True)
+        compare_path.write_text(self._get_compare())
+        compare_path.chmod(0o755)
+
+        # Prepare testlib
+        testlib_path = into_path / 'scripts' / 'testlib.h'
+        testlib_path.parent.mkdir(parents=True, exist_ok=True)
+        testlib_path.write_text(get_testlib().read_text())
+
+        # Prepare checker
+        checker_path = into_path / 'scripts' / 'checker.cpp'
+        checker_path.parent.mkdir(parents=True, exist_ok=True)
+        checker_path.write_text(self._get_checker())
+
+        # Problem statement
+        enunciado_path = into_path / 'docs' / 'enunciado.pdf'
+        enunciado_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(
+            self._get_main_built_statement(built_statements).path,
+            enunciado_path,
+        )
+
+        # Copy solutions
+        if self.for_boca:
+            self._copy_solutions(into_path, fix_java=False)
+        else:
+            self._copy_solutions_moj(into_path)
+
+        # Prepare IO
+        inputs_path = into_path / 'tests' / 'input'
+        inputs_path.mkdir(parents=True, exist_ok=True)
+        outputs_path = into_path / 'tests' / 'output'
+        outputs_path.mkdir(parents=True, exist_ok=True)
+
+        testcases = self.get_flattened_built_testcases()
+        for i, testcase in enumerate(testcases):
+            shutil.copyfile(testcase.inputPath, inputs_path / f'{i+1:03d}')
+            if testcase.outputPath is not None:
+                shutil.copyfile(testcase.outputPath, outputs_path / f'{i+1:03d}')
+            else:
+                (outputs_path / f'{i+1:03d}').touch()
+
+        # Zip all.
+        shutil.make_archive(
+            str(build_path / self._get_problem_name()), 'zip', into_path
+        )
+
+        return (build_path / self._get_problem_name()).with_suffix('.zip')

rbx/box/retries.py

@@ -3,7 +3,7 @@ import pathlib
 import shutil
 import tempfile
 from contextlib import contextmanager
-from typing import Callable, List, Optional
+from typing import Awaitable, Callable, List, Optional
 
 from rbx.box import package
 from rbx.box.setter_config import RepeatsConfig, get_setter_config
@@ -104,18 +104,18 @@ class Retrier:
         self.retries_for_stress = self.config.retries_for_stress
         self.retry_index = 0
 
-    def repeat(
+    async def repeat(
         self,
-        func: Callable[[int], Evaluation],
+        func: Callable[[int], Awaitable[Evaluation]],
     ) -> Evaluation:
         self.retry_index += 1
-        eval = func(self.retry_index)
+        eval = await func(self.retry_index)
         if self.should_repeat(eval):
             with _temp_retry_dir() as temp_dir:
                 # Move files to temp dir to open run for repeat.
                 recover = _move_logs_to_temp_dir(eval, temp_dir)
                 # Actually repeat and choose the best evaluation.
-                next_eval = self.repeat(func)
+                next_eval = await self.repeat(func)
                 chosen_eval = _merge_evaluations(eval, next_eval)
 
                 if id(chosen_eval) == id(eval):

rbx/box/schema.py

@@ -82,16 +82,16 @@ class ExpectedOutcome(AutoEnum):
     RUNTIME_ERROR = alias('runtime error', 'rte', 're')  # type: ignore
     """Expected outcome solutions that finish with non-zero code (RTE)."""
 
-    TIME_LIMIT_EXCEEDED = alias('time limit exceeded', 'timeout', 'tle')  # type: ignore
+    TIME_LIMIT_EXCEEDED = alias('time limit exceeded', 'timeout', 'tle', 'tl')  # type: ignore
     """Expected outcome for solutions that do not finish in time."""
 
-    MEMORY_LIMIT_EXCEEDED = alias('memory limit exceeded', 'mle')  # type: ignore
+    MEMORY_LIMIT_EXCEEDED = alias('memory limit exceeded', 'mle', 'ml')  # type: ignore
     """Expected outcome for solutions that use more memory than allowed."""
 
-    OUTPUT_LIMIT_EXCEEDED = alias('output limit exceeded', 'ole')  # type: ignore
+    OUTPUT_LIMIT_EXCEEDED = alias('output limit exceeded', 'ole', 'ol')  # type: ignore
     """Expected outcome for solutions that use more output than allowed."""
 
-    TLE_OR_RTE = alias('tle or rte', 'tle/rte', 'tle+rte')  # type: ignore
+    TLE_OR_RTE = alias('tle or rte', 'tle/rte', 'tle+rte', 'tle or re', 'tle+re')  # type: ignore
     """Expected outcome for solutions that finish with either TLE or RTE.
 
     Especially useful for environments where TLE and RTE are indistinguishable."""
@@ -148,6 +148,22 @@ class ExpectedOutcome(AutoEnum):
         return bool(set(self.get_matches()) & set(rhs.get_matches()))
 
 
+class ValidatorOutcome(AutoEnum):
+    VALID = alias('valid')  # type: ignore
+    """Expected outcome for valid tests."""
+
+    INVALID = alias('invalid')  # type: ignore
+    """Expected outcome for invalid tests."""
+
+
+class TaskType(AutoEnum):
+    BATCH = alias('batch')  # type: ignore
+    """Batch task."""
+
+    COMMUNICATION = alias('communication')  # type: ignore
+    """Communication task."""
+
+
 class CodeItem(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
@@ -337,12 +353,69 @@ class LimitModifiers(BaseModel):
     )
 
 
+class ValidatorTest(BaseModel):
+    model_config = ConfigDict(extra='forbid')
+
+    input: pathlib.Path = Field(
+        description='The input file to be used as unit test input for the validator.'
+    )
+    outcome: ValidatorOutcome = Field(
+        default=ValidatorOutcome.VALID,
+        description='The expected outcome of the validator.',
+    )
+
+    validator: Optional[CodeItem] = Field(
+        default=None,
+        description='The validator to use for this test. If not specified, will use the package-level validator.',
+    )
+
+
+class CheckerTest(BaseModel):
+    model_config = ConfigDict(extra='forbid')
+
+    input: Optional[pathlib.Path] = Field(
+        default=None,
+        description='The input file to be used as unit test input for the checker. If not specified, will pass an empty file.',
+    )
+    output: Optional[pathlib.Path] = Field(
+        default=None,
+        description='The solution output file to be used as unit test output for the checker. If not specified, will pass an empty file.',
+    )
+    answer: Optional[pathlib.Path] = Field(
+        default=None,
+        description='The answer file to be used as unit test answer for the checker. If not specified, will pass an empty file.',
+    )
+
+    outcome: ExpectedOutcome = Field(
+        default=ExpectedOutcome.ACCEPTED,
+        description='The expected outcome of the checker.',
+    )
+
+
+class UnitTests(BaseModel):
+    model_config = ConfigDict(extra='forbid')
+
+    validator: List[ValidatorTest] = Field(
+        default=[],
+        description='Unit tests for the validator.',
+    )
+
+    checker: List[CheckerTest] = Field(
+        default=[],
+        description='Unit tests for the checker.',
+    )
+
+
 class Package(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
     # Name of the problem.
     name: str = NameField(description='The name of the problem.')
 
+    type: TaskType = Field(
+        default=TaskType.BATCH, description='The type of the problem.'
+    )
+
     timeLimit: int = Field(description='Time limit of the problem, in milliseconds.')
 
     memoryLimit: int = Field(description='Memory limit of the problem, in MB.')
@@ -362,6 +435,10 @@ class Package(BaseModel):
         default=None, description='The checker for this problem.'
     )
 
+    interactor: Optional[CodeItem] = Field(
+        default=None, description='The interactor for this problem.'
+    )
+
     validator: Optional[CodeItem] = Field(
         default=None, description='The validator for this problem.'
     )
@@ -399,6 +476,11 @@ that is correct and used as reference -- and should have the `accepted` outcome.
         default={}, description='Variables to be re-used across the package.'
     )
 
+    unitTests: UnitTests = Field(
+        default_factory=UnitTests,
+        description='Unit tests for components of this problem.',
+    )
+
     @property
     def expanded_vars(self) -> Dict[str, Primitive]:
         return {key: expand_var(value) for key, value in self.vars.items()}