rbx.cp 0.5.34__tar.gz → 0.5.35__tar.gz

{rbx_cp-0.5.34 → rbx_cp-0.5.35}/PKG-INFO

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

{rbx_cp-0.5.34 → rbx_cp-0.5.35}/pyproject.toml

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

{rbx_cp-0.5.34 → rbx_cp-0.5.35}/rbx/box/builder.py

@@ -3,7 +3,11 @@ from typing import Optional, Set
 from rbx import console, utils
 from rbx.box import environment, package
 from rbx.box.environment import VerificationLevel
-from rbx.box.generators import generate_outputs_for_testcases, generate_testcases
+from rbx.box.generators import (
+    extract_generation_testcases_from_groups,
+    generate_outputs_for_testcases,
+    generate_testcases,
+)
 from rbx.box.solutions import (
     is_fast,
     print_run_report,
@@ -61,7 +65,11 @@ def build(
         keep=True,
     ) as s:
         if output:
-            generate_outputs_for_testcases(s, groups=groups)
+            entries = [
+                entry.group_entry
+                for entry in extract_generation_testcases_from_groups(groups)
+            ]
+            generate_outputs_for_testcases(entries, s)
 
     console.console.print(
         '[success]Problem built.[/success] '

{rbx_cp-0.5.34 → rbx_cp-0.5.35}/rbx/box/contest/build_contest_statements.py

@@ -31,7 +31,7 @@ from rbx.box.statements.joiners import (
     StatementJoinerContext,
 )
 from rbx.box.statements.schema import Statement, StatementType
-from rbx.box.testcases import get_samples
+from rbx.box.testcase_utils import get_samples
 
 
 @dataclasses.dataclass

{rbx_cp-0.5.34 → rbx_cp-0.5.35}/rbx/box/generators.py

@@ -3,13 +3,13 @@ import pathlib
 import shlex
 import shutil
 from pathlib import PosixPath
-from typing import Dict, List, Optional, Set
+from typing import Dict, Iterable, List, Optional, Set, Tuple
 
 import typer
 from pydantic import BaseModel
 
 from rbx import console
-from rbx.box import checkers, package, testcases, validators
+from rbx.box import checkers, package, testcase_utils, validators
 from rbx.box.code import SanitizationLevel, compile_item, run_item
 from rbx.box.environment import (
     EnvironmentSandbox,
@@ -22,7 +22,7 @@ from rbx.box.schema import (
     TestcaseSubgroup,
 )
 from rbx.box.stressing import generator_parser
-from rbx.box.testcases import TestcaseEntry, find_built_testcases
+from rbx.box.testcase_utils import TestcaseEntry, TestcasePattern, find_built_testcases
 from rbx.grading.steps import (
     DigestHolder,
     DigestOrDest,
@@ -141,15 +141,20 @@ def _run_generator_script(testcase: TestcaseSubgroup) -> str:
     return script
 
 
-def _extract_script_lines(script: str):
+def _extract_script_lines(script: str) -> Iterable[Tuple[str, str, int]]:
     lines = script.splitlines()
-    for line in lines:
+    for i, line in enumerate(lines):
         line = line.strip()
         if not line:
             continue
         if line.startswith('#'):
             continue
-        yield shlex.split(line)[0], shlex.join(shlex.split(line)[1:])
+        yield shlex.split(line)[0], shlex.join(shlex.split(line)[1:]), i + 1
+
+
+class GeneratorScriptEntry(BaseModel):
+    path: pathlib.Path
+    line: int
 
 
 class GenerationMetadata(BaseModel):
@@ -157,6 +162,7 @@ class GenerationMetadata(BaseModel):
 
     copied_from: Optional[Testcase] = None
     generator_call: Optional[GeneratorCall] = None
+    generator_script: Optional[GeneratorScriptEntry] = None
 
 
 class GenerationTestcaseEntry(BaseModel):
@@ -280,7 +286,7 @@ def run_testcase_visitor(visitor: TestcaseVisitor):
             script = _run_generator_script(subgroup)
 
             # Run each line from generator script.
-            for generator_name, args in _extract_script_lines(script):
+            for generator_name, args, line_number in _extract_script_lines(script):
                 call = GeneratorCall(name=generator_name, args=args)
                 visitor.visit(
                     GenerationTestcaseEntry(
@@ -288,6 +294,10 @@ def run_testcase_visitor(visitor: TestcaseVisitor):
                         subgroup_entry=_sub_entry(i),
                         metadata=GenerationMetadata(
                             generator_call=call,
+                            generator_script=GeneratorScriptEntry(
+                                path=subgroup.generatorScript.path,
+                                line=line_number,
+                            ),
                             copied_to=_copied_to(i),
                         ),
                     )
@@ -457,7 +467,7 @@ def generate_testcases(
         else None,
     )
 
-    testcases.clear_built_testcases()
+    testcase_utils.clear_built_testcases()
 
     class BuildTestcaseVisitor(TestcaseGroupVisitor):
         def visit(self, entry: GenerationTestcaseEntry):
@@ -487,6 +497,8 @@ def generate_output_for_testcase(
     stderr_path: Optional[pathlib.Path] = 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.
@@ -540,8 +552,70 @@ def generate_output_for_testcase(
         raise typer.Exit(1)
 
 
+def extract_generation_testcases(
+    entries: List[TestcaseEntry],
+) -> List[GenerationTestcaseEntry]:
+    # TODO: support subgroups.
+    groups = set(entry.group for entry in entries)
+    entry_keys = set(entry.key() for entry in entries)
+
+    res: List[GenerationTestcaseEntry] = []
+
+    class ExtractGenerationTestcasesVisitor(TestcaseVisitor):
+        def should_visit_group(self, group_name: str) -> bool:
+            return group_name in groups
+
+        def visit(self, entry: GenerationTestcaseEntry):
+            # TODO: support subgroups.
+            if entry.group_entry.key() not in entry_keys:
+                return
+            res.append(entry)
+
+    run_testcase_visitor(ExtractGenerationTestcasesVisitor())
+    return res
+
+
+def extract_generation_testcases_from_groups(
+    groups: Optional[Set[str]] = None,
+) -> List[GenerationTestcaseEntry]:
+    res: List[GenerationTestcaseEntry] = []
+
+    class ExtractGenerationTestcasesVisitor(TestcaseGroupVisitor):
+        def visit(self, entry: GenerationTestcaseEntry):
+            res.append(entry)
+
+    run_testcase_visitor(ExtractGenerationTestcasesVisitor(groups))
+    return res
+
+
+def extract_generation_testcases_from_patterns(
+    patterns: List[TestcasePattern],
+) -> List[GenerationTestcaseEntry]:
+    res: List[GenerationTestcaseEntry] = []
+
+    class ExtractGenerationTestcasesVisitor(TestcaseVisitor):
+        def should_visit_group(self, group_name: str) -> bool:
+            return any(pattern.intersecting_group(group_name) for pattern in patterns)
+
+        def should_visit_subgroup(self, subgroup_path: str) -> bool:
+            return any(
+                pattern.intersecting_group(subgroup_path) for pattern in patterns
+            )
+
+        def visit(self, entry: GenerationTestcaseEntry):
+            if not any(
+                pattern.match(entry.group_entry) for pattern in patterns
+            ) and not any(pattern.match(entry.subgroup_entry) for pattern in patterns):
+                return
+            res.append(entry)
+
+    run_testcase_visitor(ExtractGenerationTestcasesVisitor())
+    return res
+
+
 def generate_outputs_for_testcases(
-    progress: Optional[StatusProgress] = None, groups: Optional[Set[str]] = None
+    entries: List[TestcaseEntry],
+    progress: Optional[StatusProgress] = None,
 ):
     def step():
         if progress is not None:
@@ -563,50 +637,26 @@ def generate_outputs_for_testcases(
     shutil.rmtree(str(gen_runs_dir), ignore_errors=True)
     gen_runs_dir.mkdir(parents=True, exist_ok=True)
 
-    class GenerateOutputsVisitor(TestcaseGroupVisitor):
-        def visit(self, entry: GenerationTestcaseEntry):
-            tc = entry.metadata.copied_to
-            if not tc.inputPath.is_file():
-                return
-            assert tc.outputPath is not None
+    generation_entries = extract_generation_testcases(entries)
 
-            if (
-                main_solution is None or solution_digest is None
-            ) and not tc.outputPath.is_file():
-                console.console.print(
-                    '[error]No main solution found to generate outputs for testcases.[/error]',
-                )
-                raise typer.Exit(1)
+    for entry in generation_entries:
+        tc = entry.metadata.copied_to
+        if not tc.inputPath.is_file():
+            return
+        assert tc.outputPath is not None
 
-            assert solution_digest is not None
-            generate_output_for_testcase(
-                solution_digest,
-                tc,
-                gen_runs_dir / 'main.stderr',
+        if (
+            main_solution is None or solution_digest is None
+        ) and not tc.outputPath.is_file():
+            console.console.print(
+                '[error]No main solution found to generate outputs for testcases.[/error]',
             )
-            step()
-
-    run_testcase_visitor(GenerateOutputsVisitor(groups))
-
-
-def extract_generation_testcases(
-    entries: List[TestcaseEntry],
-) -> List[GenerationTestcaseEntry]:
-    # TODO: support subgroups.
-    groups = set(entry.group for entry in entries)
-    entry_keys = set(entry.key() for entry in entries)
-
-    res: List[GenerationTestcaseEntry] = []
-
-    class ExtractGenerationTestcasesVisitor(TestcaseVisitor):
-        def should_visit_group(self, group_name: str) -> bool:
-            return group_name in groups
-
-        def visit(self, entry: GenerationTestcaseEntry):
-            # TODO: support subgroups.
-            if entry.group_entry.key() not in entry_keys:
-                return
-            res.append(entry)
+            raise typer.Exit(1)
 
-    run_testcase_visitor(ExtractGenerationTestcasesVisitor())
-    return res
+        assert solution_digest is not None
+        generate_output_for_testcase(
+            solution_digest,
+            tc,
+            gen_runs_dir / 'main.stderr',
+        )
+        step()

{rbx_cp-0.5.34 → rbx_cp-0.5.35}/rbx/box/generators_test.py

@@ -4,6 +4,7 @@ import pytest
 
 from rbx.box import package
 from rbx.box.generators import (
+    extract_generation_testcases_from_groups,
     generate_outputs_for_testcases,
     generate_testcases,
 )
@@ -13,7 +14,10 @@ from rbx.testing_utils import print_directory_tree
 @pytest.mark.test_pkg('box1')
 def test_generator_works(pkg_from_testdata: pathlib.Path):
     generate_testcases()
-    generate_outputs_for_testcases()
+    entries = [
+        entry.group_entry for entry in extract_generation_testcases_from_groups()
+    ]
+    generate_outputs_for_testcases(entries)
 
     # Debug when fail.
     print_directory_tree(pkg_from_testdata)

{rbx_cp-0.5.34 → rbx_cp-0.5.35}/rbx/box/main.py

@@ -39,6 +39,7 @@ from rbx.box import (
 from rbx.box.contest import main as contest
 from rbx.box.environment import VerificationLevel, get_environment_path
 from rbx.box.packaging import main as packaging
+from rbx.box.testcases import main as testcases
 from rbx.box.solutions import (
     estimate_time_limit,
     get_exact_matching_solutions,
@@ -49,7 +50,7 @@ from rbx.box.solutions import (
     run_solutions,
 )
 from rbx.box.statements import build_statements
-from rbx.box.testcases import TestcaseEntry
+from rbx.box.testcase_utils import TestcaseEntry
 
 app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
 app.add_typer(
@@ -82,6 +83,12 @@ app.add_typer(
 app.add_typer(
     contest.app, name='contest', cls=annotations.AliasGroup, help='Contest management.'
 )
+app.add_typer(
+    testcases.app,
+    name='testcases, tc, t',
+    cls=annotations.AliasGroup,
+    help='Testcase management.',
+)
 
 
 @app.callback()
@@ -166,6 +173,21 @@ def run(
         )
         check = False
 
+    tracked_solutions = None
+    if outcome is not None:
+        tracked_solutions = {
+            str(solution.path)
+            for solution in get_matching_solutions(ExpectedOutcome(outcome))
+        }
+    if solution:
+        tracked_solutions = {solution}
+
+    if choice:
+        tracked_solutions = set(pick_solutions(tracked_solutions))
+        if not tracked_solutions:
+            console.console.print('[error]No solutions selected. Exiting.[/error]')
+            raise typer.Exit(1)
+
     if not builder.build(verification=verification, output=check):
         return
 
@@ -195,21 +217,6 @@ def run(
             'and the environment default time limit will be used instead.[/warning]'
         )
 
-    tracked_solutions = None
-    if outcome is not None:
-        tracked_solutions = {
-            str(solution.path)
-            for solution in get_matching_solutions(ExpectedOutcome(outcome))
-        }
-    if solution:
-        tracked_solutions = {solution}
-
-    if choice:
-        tracked_solutions = set(pick_solutions(tracked_solutions))
-        if not tracked_solutions:
-            console.console.print('[error]No solutions selected. Exiting.[/error]')
-            raise typer.Exit(1)
-
     if sanitized and tracked_solutions is None:
         console.console.print(
             '[warning]Sanitizers are running, and no solutions were specified to run. Will only run [item]ACCEPTED[/item] solutions.'

{rbx_cp-0.5.34 → rbx_cp-0.5.35}/rbx/box/schema.py

@@ -192,6 +192,9 @@ class GeneratorCall(BaseModel):
         default=None, description='The arguments to pass to the generator.'
     )
 
+    def __str__(self) -> str:
+        return f'{self.name} {self.args}'
+
 
 class TestcaseSubgroup(BaseModel):
     model_config = ConfigDict(extra='forbid')

{rbx_cp-0.5.34 → rbx_cp-0.5.35}/rbx/box/solutions.py

@@ -42,7 +42,7 @@ from rbx.box.schema import (
     Testcase,
     TestcaseGroup,
 )
-from rbx.box.testcases import TestcaseEntry, find_built_testcases
+from rbx.box.testcase_utils import TestcaseEntry, find_built_testcases
 from rbx.grading.steps import (
     DigestOrDest,
     DigestOrSource,

{rbx_cp-0.5.34 → rbx_cp-0.5.35}/rbx/box/solutions_test.py

@@ -5,6 +5,7 @@ import pytest
 
 from rbx.box.environment import VerificationLevel
 from rbx.box.generators import (
+    extract_generation_testcases_from_groups,
     generate_outputs_for_testcases,
     generate_testcases,
 )
@@ -18,7 +19,10 @@ from rbx.grading.steps import Outcome
 @pytest.mark.test_pkg('box1')
 def test_solutions(pkg_from_testdata: pathlib.Path):
     generate_testcases()
-    generate_outputs_for_testcases()
+    entries = [
+        entry.group_entry for entry in extract_generation_testcases_from_groups()
+    ]
+    generate_outputs_for_testcases(entries)
 
     result = run_solutions(verification=VerificationLevel.FULL)
     res = asyncio.run(convert_list_of_solution_evaluations_to_dict(result.items))

{rbx_cp-0.5.34 → rbx_cp-0.5.35}/rbx/box/statements/build_statements.py

@@ -24,7 +24,7 @@ from rbx.box.statements.schema import (
     Statement,
     StatementType,
 )
-from rbx.box.testcases import get_samples
+from rbx.box.testcase_utils import get_samples
 
 app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
 

rbx_cp-0.5.35/rbx/box/testcase_utils.py

@@ -0,0 +1,135 @@
+import pathlib
+import shutil
+from typing import List, Optional, Tuple
+
+import typer
+from pydantic import BaseModel
+
+from rbx import console
+from rbx.box import package
+from rbx.box.package import get_build_testgroup_path, get_build_tests_path
+from rbx.box.schema import Testcase, TestcaseGroup
+
+
+class TestcaseEntry(BaseModel):
+    group: str
+    index: int
+
+    def key(self) -> Tuple[str, int]:
+        return self.group, self.index
+
+    def __str__(self) -> str:
+        return f'{self.group}/{self.index}'
+
+    @classmethod
+    def parse(cls, spec: str) -> 'TestcaseEntry':
+        if spec.count('/') != 1:
+            console.console.print(
+                f'[error]Invalid testcase spec [item]{spec}[/item]. Format should be [item]<group>/<index>[/item].[/error]',
+            )
+            raise typer.Exit(1)
+        group, index = spec.split('/')
+        return TestcaseEntry(group=group.strip(), index=int(index))
+
+
+class TestcasePattern(BaseModel):
+    group_prefix: List[str]
+    index: Optional[int] = None
+
+    def group(self) -> str:
+        return '/'.join(self.group_prefix)
+
+    def match(self, group_entry: TestcaseEntry) -> bool:
+        # TODO: support subgroups.
+        entry_parts = tuple(group_entry.group.split('/'))
+        if self.index is not None:
+            if self.index != group_entry.index:
+                return False
+            if tuple(self.group_prefix) != entry_parts:
+                return False
+            return True
+
+        if len(self.group_prefix) > len(entry_parts):
+            return False
+
+        return tuple(self.group_prefix) == entry_parts[: len(self.group_prefix)]
+
+    def with_no_index(self) -> 'TestcasePattern':
+        return self.model_copy(update={'index': None})
+
+    def intersecting_group(self, group: str) -> bool:
+        if self.with_no_index().match(TestcaseEntry(group=group, index=0)):
+            # If the group is inside the pattern, then it is a match.
+            return True
+        if TestcasePattern.parse(group).match(
+            TestcaseEntry(group=self.group(), index=0)
+        ):
+            # If the group is a prefix of the pattern, then it is a match.
+            return True
+        return False
+
+    def __str__(self) -> str:
+        prefix = '/'.join(self.group_prefix)
+        if self.index is None:
+            return f'{prefix}/'
+        return f'{prefix}/{self.index}'
+
+    @classmethod
+    def parse(cls, spec: str) -> 'TestcasePattern':
+        parts = spec.split('/')
+        if not parts:
+            console.console.print(
+                f'[error]Invalid testcase pattern [item]{spec}[/item].[/error]',
+            )
+            raise typer.Exit(1)
+
+        if len(parts) == 1:
+            return cls(group_prefix=parts, index=None)
+
+        if parts[-1].isdigit():
+            return cls(group_prefix=parts[:-1], index=int(parts[-1]))
+
+        return cls(group_prefix=parts, index=None)
+
+
+class TestcaseData(BaseModel):
+    input: str
+    output: str
+
+
+def find_built_testcases(group: TestcaseGroup) -> List[Testcase]:
+    inputs = find_built_testcase_inputs(group)
+
+    testcases = []
+    for input in inputs:
+        output = input.with_suffix('.out')
+        testcases.append(Testcase(inputPath=input, outputPath=output))
+    return testcases
+
+
+def find_built_testcase_inputs(group: TestcaseGroup) -> List[pathlib.Path]:
+    testgroup_path = get_build_testgroup_path(group.name)
+    if not testgroup_path.is_dir():
+        console.console.print(
+            f'Testgroup {group.name} is not generated in build folder'
+        )
+        raise typer.Exit(1)
+
+    return sorted(testgroup_path.glob('*.in'))
+
+
+def clear_built_testcases():
+    shutil.rmtree(str(get_build_tests_path()), ignore_errors=True)
+
+
+def get_samples() -> List[Testcase]:
+    tcs = find_built_testcases(package.get_testgroup('samples'))
+    return [
+        Testcase(
+            inputPath=tc.inputPath.resolve(),
+            outputPath=tc.outputPath.resolve()
+            if tc.outputPath is not None and tc.outputPath.is_file()
+            else None,
+        )
+        for tc in tcs
+    ]