rbx.cp 0.5.48__tar.gz → 0.5.50__tar.gz

{rbx_cp-0.5.48 → rbx_cp-0.5.50}/PKG-INFO

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

{rbx_cp-0.5.48 → rbx_cp-0.5.50}/pyproject.toml

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

{rbx_cp-0.5.48 → rbx_cp-0.5.50}/rbx/box/cli.py

@@ -747,6 +747,7 @@ async def validate(
     rich_help_panel='Testing',
     help='Run unit tests for the validator and checker.',
 )
+@package.within_problem
 def unit_tests():
     from rbx.box import unit
 

{rbx_cp-0.5.48 → rbx_cp-0.5.50}/rbx/box/packaging/main.py

@@ -64,6 +64,7 @@ async def run_packager(
 
 
 @app.command('polygon', help='Build a package for Polygon.')
+@package.within_problem
 @syncer.sync
 async def polygon(
     verification: environment.VerificationParam,
@@ -74,6 +75,7 @@ async def polygon(
 
 
 @app.command('boca', help='Build a package for BOCA.')
+@package.within_problem
 @syncer.sync
 async def boca(
     verification: environment.VerificationParam,
@@ -84,6 +86,7 @@ async def boca(
 
 
 @app.command('moj', help='Build a package for MOJ.')
+@package.within_problem
 @syncer.sync
 async def moj(
     verification: environment.VerificationParam,

{rbx_cp-0.5.48 → rbx_cp-0.5.50}/rbx/box/schema.py

@@ -356,8 +356,8 @@ 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.'
+    glob: str = Field(
+        description='A glob pattern for the input files to be used as unit test input for the validator.'
     )
     outcome: ValidatorOutcome = Field(
         default=ValidatorOutcome.VALID,
@@ -373,17 +373,12 @@ class ValidatorTest(BaseModel):
 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.',
+    glob: str = Field(
+        description="""
+A glob pattern for the files to be used as unit test input for the checker.
+This glob should simultaneously match the input, output, and answer files (.in, .out, .ans).
+If one of them is not present, an empty file will be used instead.
+""",
     )
 
     outcome: ExpectedOutcome = Field(

{rbx_cp-0.5.48 → rbx_cp-0.5.50}/rbx/box/solutions.py

@@ -47,7 +47,12 @@ from rbx.box.tasks import (
     run_solution_on_testcase,
 )
 from rbx.box.testcase_extractors import extract_generation_testcases
-from rbx.box.testcase_utils import TestcaseEntry, find_built_testcases
+from rbx.box.testcase_utils import (
+    TestcaseEntry,
+    find_built_testcases,
+    parse_interaction,
+    print_interaction,
+)
 from rbx.grading.steps import (
     Evaluation,
     Outcome,
@@ -323,6 +328,19 @@ def _produce_solution_items(
     return res
 
 
+def print_best_output(output_files: List[pathlib.Path], empty_warning: bool = False):
+    for output_file in output_files:
+        if not output_file.is_file():
+            continue
+        if output_file.suffix == '.pio':
+            print_interaction(parse_interaction(output_file))
+        else:
+            console.console.print(output_file.read_text())
+        return
+    if empty_warning:
+        console.console.print('[warning]Solution produced no output.[/warning]')
+
+
 def run_solutions(
     progress: Optional[StatusProgress] = None,
     tracked_solutions: Optional[Set[str]] = None,
@@ -528,6 +546,7 @@ def _run_interactive_solutions(
                 output_dir=output_dir,
                 interactor_digest=interactor_digest,
                 verification=verification,
+                capture_pipes=True,
             )
 
         yield EvaluationItem(
@@ -589,18 +608,28 @@ async def run_and_print_interactive_solutions(
             )
 
         stdout_path = eval.log.stdout_absolute_path
-        if print:
+        if print and stdout_path is not None:
+            if pkg.type == TaskType.COMMUNICATION:
+                console.console.rule('Interaction', style='status')
+                output_files = [
+                    stdout_path.with_suffix('.pio'),
+                    stdout_path.with_suffix('.pout'),
+                ]
+                print_best_output(output_files, empty_warning=True)
+
             console.console.rule('Output', style='status')
-            if (
-                eval.testcase.output is not None
-                and stdout_path is not None
-                and stdout_path.is_file()
-            ):
-                console.console.print(stdout_path.read_text())
-            else:
-                console.console.print('[warning]Solution produced no output.[/warning]')
+            output_files = [stdout_path]
+            print_best_output(output_files, empty_warning=True)
         elif stdout_path is not None:
-            console.console.print(f'[status]Output:[/status] {stdout_path}')
+            if stdout_path.with_suffix('.pout').is_file():
+                stdout_path = stdout_path.with_suffix('.pout')
+
+            if stdout_path.is_file():
+                console.console.print(f'[status]Output:[/status] {stdout_path}')
+            if stdout_path.with_suffix('.pio').is_file():
+                console.console.print(
+                    f'[status]Interaction:[/status] {stdout_path.with_suffix(".pio")}'
+                )
             if eval.log.stderr_absolute_path is not None:
                 console.console.print(
                     f'[status]Stderr:[/status] {eval.log.stderr_absolute_path}'

{rbx_cp-0.5.48 → rbx_cp-0.5.50}/rbx/box/testcase_utils.py

@@ -2,6 +2,8 @@ import pathlib
 import shutil
 from typing import List, Optional, Tuple
 
+import rich
+import rich.text
 import typer
 from pydantic import BaseModel
 
@@ -209,3 +211,13 @@ def parse_interaction(file: pathlib.Path) -> TestcaseInteraction:
         prefixes=(interactor_prefix, solution_prefix),
         entries=entries,
     )
+
+
+def print_interaction(interaction: TestcaseInteraction):
+    for entry in interaction.entries:
+        text = rich.text.Text(entry.data)
+        if entry.pipe == 0:
+            text.stylize('status')
+        else:
+            text.stylize('info')
+        console.console.print(text, end='')

{rbx_cp-0.5.48 → rbx_cp-0.5.50}/rbx/box/testcases/main.py

@@ -90,6 +90,7 @@ async def _generate_for_editing(
 
 
 @app.command('view, v', help='View a testcase in your default editor.')
+@package.within_problem
 @syncer.sync
 async def view(
     tc: Annotated[
@@ -126,6 +127,7 @@ async def view(
 
 
 @app.command('info, i', help='Show information about testcases.')
+@package.within_problem
 @syncer.sync
 async def info(
     pattern: Annotated[

rbx_cp-0.5.50/rbx/box/unit.py

@@ -0,0 +1,206 @@
+import pathlib
+from typing import List, Optional, Set
+
+import syncer
+from pydantic import BaseModel
+
+from rbx import console
+from rbx.box import checkers, package, validators
+from rbx.box.schema import (
+    CheckerTest,
+    CodeItem,
+    ExpectedOutcome,
+    Testcase,
+    ValidatorOutcome,
+    ValidatorTest,
+)
+from rbx.utils import StatusProgress
+
+
+class ValidatorTestEntry(BaseModel):
+    input: pathlib.Path
+    outcome: ValidatorOutcome
+    validator: Optional[CodeItem]
+
+
+class CheckerTestEntry(BaseModel):
+    input: Optional[pathlib.Path] = None
+    output: Optional[pathlib.Path] = None
+    answer: Optional[pathlib.Path] = None
+    outcome: ExpectedOutcome
+
+    def running_tests_formatted_string(self) -> str:
+        res = []
+        if self.input:
+            res.append(f'[item]{self.input}[/item]')
+        if self.output:
+            res.append(f'[item]{self.output}[/item]')
+        if self.answer:
+            res.append(f'[item]{self.answer}[/item]')
+        return ', '.join(res)
+
+
+def _extract_validator_test_entries(
+    tests: List[ValidatorTest],
+) -> List[ValidatorTestEntry]:
+    res: List[ValidatorTestEntry] = []
+    for test in tests:
+        for input in pathlib.Path().glob(str(test.glob)):
+            if not input.is_file():
+                continue
+            res.append(
+                ValidatorTestEntry(
+                    input=input, outcome=test.outcome, validator=test.validator
+                )
+            )
+    return sorted(res, key=lambda x: x.input.name)
+
+
+def _extract_checker_test_entries(tests: List[CheckerTest]) -> List[CheckerTestEntry]:
+    res: List[CheckerTestEntry] = []
+    seen: Set[pathlib.Path] = set()
+    for test in tests:
+        for file in pathlib.Path().glob(str(test.glob)):
+            if not file.is_file():
+                continue
+            if file.suffix not in ['.in', '.out', '.ans']:
+                continue
+            basefile = file.with_suffix('')
+            if basefile in seen:
+                continue
+            seen.add(basefile)
+            input = basefile.with_suffix('.in')
+            output = basefile.with_suffix('.out')
+            answer = basefile.with_suffix('.ans')
+            res.append(
+                CheckerTestEntry(
+                    input=input if input.is_file() else None,
+                    output=output if output.is_file() else None,
+                    answer=answer if answer.is_file() else None,
+                    outcome=test.outcome,
+                )
+            )
+    return res
+
+
+def _get_validator_for_test(test: ValidatorTestEntry) -> Optional[CodeItem]:
+    pkg = package.find_problem_package_or_die()
+    if test.validator is not None:
+        return test.validator
+    return pkg.validator
+
+
+async def run_validator_unit_tests(progress: StatusProgress):
+    pkg = package.find_problem_package_or_die()
+
+    entries = _extract_validator_test_entries(pkg.unitTests.validator)
+
+    vals: List[CodeItem] = []
+    for test in entries:
+        val = _get_validator_for_test(test)
+        if val is not None:
+            vals.append(val)
+
+    console.console.rule('Validator tests', style='info')
+    if not entries:
+        console.console.print(']No validator unit tests found.')
+        return
+
+    compiled_validators = validators.compile_validators(vals, progress=progress)
+
+    if progress:
+        progress.update('Running validator unit tests...')
+
+    for i, test in enumerate(entries):
+        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 = await 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('  [status]Actual[/status] INVALID')
+
+        if info.message:
+            console.console.print(f'  [status]Message[/status] {info.message}')
+
+
+async 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
+
+    console.console.rule('Checker tests', style='info')
+
+    entries = _extract_checker_test_entries(pkg.unitTests.checker)
+    if not entries:
+        console.console.print('No checker unit tests found.')
+        return
+
+    compiled_digest = checkers.compile_checker(progress=progress)
+
+    if progress:
+        progress.update('Running checker unit tests...')
+
+    empty_file = package.get_empty_sentinel_path()
+
+    for i, test in enumerate(entries):
+        result = await 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] ({test.running_tests_formatted_string()})'
+        )
+        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}')
+
+
+@syncer.sync
+async def run_unit_tests(progress: StatusProgress):
+    await run_validator_unit_tests(progress)
+    await run_checker_unit_tests(progress)

rbx_cp-0.5.48/rbx/box/unit.py

@@ -1,116 +0,0 @@
-from typing import List, Optional
-
-import syncer
-
-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
-
-
-async 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 = await 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}')
-
-
-async 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 = await 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}')
-
-
-@syncer.sync
-async def run_unit_tests(progress: StatusProgress):
-    await run_validator_unit_tests(progress)
-    await run_checker_unit_tests(progress)