rbx.cp 0.5.39__tar.gz → 0.5.40__tar.gz

{rbx_cp-0.5.39 → rbx_cp-0.5.40}/PKG-INFO

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

{rbx_cp-0.5.39 → rbx_cp-0.5.40}/pyproject.toml

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

{rbx_cp-0.5.39 → rbx_cp-0.5.40}/rbx/box/checkers.py

@@ -17,11 +17,15 @@ from rbx.grading.steps import (
     Outcome,
     RunLog,
 )
+from rbx.utils import StatusProgress
 
 
-def compile_checker() -> str:
+def compile_checker(progress: Optional[StatusProgress] = None) -> str:
     checker = package.get_checker()
 
+    if progress:
+        progress.update('Compiling checker...')
+
     try:
         digest = compile_item(checker, sanitized=SanitizationLevel.PREFER)
     except Exception as e:

{rbx_cp-0.5.39 → rbx_cp-0.5.40}/rbx/box/main.py

@@ -741,6 +741,18 @@ def validate(
     validators.print_validation_report([info])
 
 
+@app.command(
+    'unit',
+    rich_help_panel='Testing',
+    help='Run unit tests for the validator and checker.',
+)
+def unit_tests():
+    from rbx.box import unit
+
+    with utils.StatusProgress('Running unit tests...') as s:
+        unit.run_unit_tests(s)
+
+
 @app.command(
     'environment, env',
     rich_help_panel='Configuration',

{rbx_cp-0.5.39 → rbx_cp-0.5.40}/rbx/box/packaging/main.py

@@ -70,3 +70,12 @@ def boca(
     from rbx.box.packaging.boca.packager import BocaPackager
 
     run_packager(BocaPackager, verification=verification)
+
+
+@app.command('moj', help='Build a package for MOJ.')
+def moj(
+    verification: environment.VerificationParam,
+):
+    from rbx.box.packaging.moj.packager import MojPackager
+
+    run_packager(MojPackager, verification=verification)

rbx_cp-0.5.40/rbx/box/packaging/moj/packager.py

@@ -0,0 +1,125 @@
+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.config import get_default_app_path
+from rbx.grading.judge.digester import digest_cooperatively
+
+
+class MojPackager(BocaPackager):
+    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_limits(self) -> str:
+        extension = get_extension_or_default('boca', BocaExtension)
+
+        pkg = package.find_problem_package_or_die()
+        tl = pkg.timeLimit
+        ml = pkg.memoryLimit
+        ol = pkg.outputLimit
+        conf = f'ULIMITS[-f]={ol}\n' f'ULIMITS[-v]={ml}\n' f'TL[default]={tl / 1000}\n'
+        for language in extension.languages:
+            conf += f'TL[{language}]={self._get_pkg_timelimit(language) / 1000}\n'
+        return conf
+
+    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 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 compare
+        compare_path = into_path / 'scripts' / 'compare.sh'
+        compare_path.parent.mkdir(parents=True, exist_ok=True)
+        compare_path.write_text(self._get_compare())
+
+        # 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
+        solutions_path = into_path / 'solutions'
+        solutions_path.mkdir(parents=True, exist_ok=True)
+        self._copy_solutions(solutions_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_cp-0.5.39 → rbx_cp-0.5.40}/rbx/box/schema.py

@@ -148,6 +148,14 @@ 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 CodeItem(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
@@ -337,6 +345,59 @@ 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')
 
@@ -399,6 +460,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()}

rbx_cp-0.5.40/rbx/box/unit.py

@@ -0,0 +1,113 @@
+from typing import List, Optional
+
+from rbx import console
+from rbx.box import checkers, package, validators
+from rbx.box.schema import CodeItem, Testcase, ValidatorOutcome, ValidatorTest
+from rbx.utils import StatusProgress
+
+
+def _get_validator_for_test(test: ValidatorTest) -> Optional[CodeItem]:
+    pkg = package.find_problem_package_or_die()
+    if test.validator is not None:
+        return test.validator
+    return pkg.validator
+
+
+def run_validator_unit_tests(progress: StatusProgress):
+    pkg = package.find_problem_package_or_die()
+
+    vals: List[CodeItem] = []
+    for test in pkg.unitTests.validator:
+        val = _get_validator_for_test(test)
+        if val is not None:
+            vals.append(val)
+
+    compiled_validators = validators.compile_validators(vals, progress=progress)
+
+    if progress:
+        progress.update('Running validator unit tests...')
+
+    console.console.rule('Validator tests', style='info')
+
+    for i, test in enumerate(pkg.unitTests.validator):
+        val = _get_validator_for_test(test)
+        if val is None:
+            console.console.print(
+                f'[warning]No validator found for test [item]#{i + 1}[/item], skipping.[/warning]'
+            )
+            continue
+
+        compiled_digest = compiled_validators[str(val.path)]
+        info = validators.validate_one_off(
+            test.input,
+            val,
+            compiled_digest,
+        )
+
+        is_valid = test.outcome == ValidatorOutcome.VALID
+
+        markup = (
+            '[success]OK[/success]' if info.ok == is_valid else '[error]FAIL[/error]'
+        )
+
+        console.console.print(
+            f'{markup} Unit test [item]#{i + 1}[/item] for [item]{test.input}[/item]'
+        )
+        console.console.print(f'  [status]Expected[/status] {test.outcome.value}')
+        if info.ok != is_valid:
+            if info.ok:
+                console.console.print('  [status]Actual[/status] VALID')
+            else:
+                console.console.print(f'  [status]Actual[/status] {info.message}')
+
+
+def run_checker_unit_tests(progress: StatusProgress):
+    pkg = package.find_problem_package_or_die()
+    if not pkg.unitTests.checker:
+        return
+
+    if not package.get_checker():
+        console.console.print(
+            '[warning]No checker found, skipping checker unit tests.[/warning]'
+        )
+        return
+
+    compiled_digest = checkers.compile_checker(progress=progress)
+
+    if progress:
+        progress.update('Running checker unit tests...')
+
+    console.console.rule('Checker tests', style='info')
+
+    empty_file = package.get_empty_sentinel_path()
+
+    for i, test in enumerate(pkg.unitTests.checker):
+        result = checkers.check(
+            compiled_digest,
+            run_log=None,
+            testcase=Testcase(
+                inputPath=test.input or empty_file,
+                outputPath=test.answer or empty_file,
+            ),
+            program_output=test.output or empty_file,
+            skip_run_log=True,
+        )
+
+        markup = (
+            '[success]OK[/success]'
+            if test.outcome.match(result.outcome)
+            else '[error]FAIL[/error]'
+        )
+
+        console.console.print(f'{markup} Unit test [item]#{i + 1}[/item]')
+        console.console.print(f'  [status]Expected[/status] {test.outcome.name}')
+
+        if not test.outcome.match(result.outcome):
+            console.console.print(f'  [status]Actual[/status] {result.outcome.name}')
+            if result.message:
+                console.console.print(f'  [status]Message[/status] {result.message}')
+
+
+def run_unit_tests(progress: StatusProgress):
+    run_validator_unit_tests(progress)
+    run_checker_unit_tests(progress)

{rbx_cp-0.5.39 → rbx_cp-0.5.40}/rbx/box/validators.py

@@ -177,15 +177,10 @@ def validate_one_off(
 
 
 def compile_validators(
-    validation_entries: List[GenerationTestcaseEntry],
+    validators: List[CodeItem],
     progress: Optional[StatusProgress] = None,
 ) -> Dict[str, str]:
-    validators = []
-
-    for entry in validation_entries:
-        if entry.validator is not None:
-            validators.append(entry.validator)
-        validators.extend(entry.extra_validators)
+    validator_to_compiled_digest = {}
 
     validator_to_compiled_digest = {}
 
@@ -202,6 +197,20 @@ def compile_validators(
     return validator_to_compiled_digest
 
 
+def compile_validators_for_entries(
+    validation_entries: List[GenerationTestcaseEntry],
+    progress: Optional[StatusProgress] = None,
+) -> Dict[str, str]:
+    validators = []
+
+    for entry in validation_entries:
+        if entry.validator is not None:
+            validators.append(entry.validator)
+        validators.extend(entry.extra_validators)
+
+    return compile_validators(validators, progress=progress)
+
+
 def validate_testcases(
     progress: Optional[StatusProgress] = None,
     groups: Optional[Set[str]] = None,
@@ -211,7 +220,7 @@ def validate_testcases(
             progress.step()
 
     validation_entries = extract_generation_testcases_from_groups(groups)
-    validator_to_compiled_digest = compile_validators(
+    validator_to_compiled_digest = compile_validators_for_entries(
         validation_entries, progress=progress
     )
 

rbx_cp-0.5.40/rbx/resources/packagers/moj/scripts/compare.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+# ////////////////////////////////////////////////////////////////////////////////
+# //BOCA Online Contest Administrator
+# //    Copyright (C) 2003-2012 by BOCA Development Team (bocasystem@gmail.com)
+# //
+# //    This program is free software: you can redistribute it and/or modify
+# //    it under the terms of the GNU General Public License as published by
+# //    the Free Software Foundation, either version 3 of the License, or
+# //    (at your option) any later version.
+# //
+# //    This program is distributed in the hope that it will be useful,
+# //    but WITHOUT ANY WARRANTY; without even the implied warranty of
+# //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# //    GNU General Public License for more details.
+# //    You should have received a copy of the GNU General Public License
+# //    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# ////////////////////////////////////////////////////////////////////////////////
+# // Last modified 21/jul/2012 by cassio@ime.usp.br
+#
+# This script receives:
+# $1 team_output
+# $2 sol_output
+# $3 problem_input (might be used by some specific checkers, here it is not)
+#
+# BOCA reads the last line of the standard output
+# and pass it to judges
+#
+if [ ! -r "$1" -o ! -r "$2" ]; then
+  echo "Parameter problem"
+  exit 43
+fi
+
+CHECKERSOURCE=$(dirname "$0")/checker.cpp
+
+if [ ! -r "$CHECKERSOURCE" ]; then
+  echo "Checker source not found"
+  exit 47
+fi
+
+CHECKERHASH={{checkerHash}}
+CHECKERPATH=/tmp/boca-chk/$CHECKERHASH
+
+compile_checker() {
+  mkdir -p /tmp/boca-chk
+
+  cc=$(which g++)
+  [ -x "$cc" ] || cc=/usr/bin/g++
+  if [ ! -x "$cc" ]; then
+    echo "$cc not found or it's not executable"
+    exit 47
+  fi
+
+  $cc {{rbxFlags}} $CHECKERSOURCE -o $CHECKERPATH
+
+  chmod 0755 "$CHECKERPATH"
+}
+
+if [ ! -x "$CHECKERPATH" ]; then
+  compile_checker
+fi
+
+# Next lines of this script just compares team_output and sol_output,
+# although it is possible to change them to more complex evaluations.
+output=$($CHECKERPATH $3 $1 $2 2>&1 >/dev/null)
+EC=$?
+
+echo "checker exitcode = $EC"
+echo "$output"
+
+if [ $EC -eq 0 ]; then
+  echo "checker found no differences"
+  exit 4
+elif [ $EC -eq 1 ]; then
+  echo "checker found differences"
+  exit 6
+elif [ $EC -eq 2 ]; then
+  echo "checker failed"
+  exit 5
+elif [ $EC -ne 3 ]; then
+  echo "unkown compare error $EC"
+  exit 43
+fi