rbx.cp 0.5.34__py3-none-any.whl → 0.5.36__py3-none-any.whl

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/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/box/contest/main.py

@@ -128,7 +128,8 @@ def edit():
 @app.command('add, a', help='Add new problem to contest.')
 @within_contest
 def add(path: str, short_name: str, preset: Optional[str] = None):
-    name = pathlib.Path(path).stem
+    problem_path = pathlib.Path(path)
+    name = problem_path.stem
     utils.validate_field(ContestProblem, 'short_name', short_name)
     utils.validate_field(Package, 'name', name)
 

rbx/box/creation.py

@@ -4,9 +4,8 @@ from typing import Annotated, Optional
 
 import typer
 
-from rbx import console
-from rbx.box import presets
-from rbx.box.contest.contest_package import find_contest_yaml
+from rbx import console, utils
+from rbx.box import package, presets
 from rbx.box.presets.fetch import get_preset_fetch_info
 
 
@@ -27,15 +26,6 @@ def create(
     ] = None,
     path: Optional[pathlib.Path] = None,
 ):
-    if find_contest_yaml() is not None:
-        console.console.print(
-            '[error]Cannot [item]rbx create[/item] a problem inside a contest.[/error]'
-        )
-        console.console.print(
-            '[error]Instead, use [item]rbx contest add[/item] to add a problem to a contest.[/error]'
-        )
-        raise typer.Exit(1)
-
     preset = preset or 'default'
     console.console.print(f'Creating new problem [item]{name}[/item]...')
 
@@ -80,4 +70,9 @@ def create(
     for lock in dest_path.rglob('.preset-lock.yml'):
         lock.unlink(missing_ok=True)
 
+    # Change problem name.
+    ru, problem = package.get_ruyaml(dest_path)
+    problem['name'] = name
+    utils.save_ruyaml(dest_path / 'problem.rbx.yml', ru, problem)
+
     presets.generate_lock(preset, root=dest_path)

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/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/box/main.py

@@ -37,8 +37,10 @@ from rbx.box import (
     validators,
 )
 from rbx.box.contest import main as contest
+from rbx.box.contest.contest_package import find_contest_yaml
 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 +51,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 +84,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 +174,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 +218,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.'
@@ -441,6 +449,15 @@ def create(
         Optional[str], typer.Option(help='Preset to use when creating the problem.')
     ] = None,
 ):
+    if find_contest_yaml() is not None:
+        console.console.print(
+            '[error]Cannot [item]rbx create[/item] a problem inside a contest.[/error]'
+        )
+        console.console.print(
+            '[error]Instead, use [item]rbx contest add[/item] to add a problem to a contest.[/error]'
+        )
+        raise typer.Exit(1)
+
     if preset is not None:
         creation.create(name, preset=preset)
         return

rbx/box/package.py

@@ -121,8 +121,8 @@ def save_package(
     problem_yaml_path.write_text(utils.model_to_yaml(package))
 
 
-def get_ruyaml() -> Tuple[ruyaml.YAML, ruyaml.Any]:
-    problem_yaml_path = find_problem_yaml()
+def get_ruyaml(root: pathlib.Path = pathlib.Path()) -> Tuple[ruyaml.YAML, ruyaml.Any]:
+    problem_yaml_path = find_problem_yaml(root)
     if problem_yaml_path is None:
         console.console.print(
             f'Problem not found in {pathlib.Path().absolute()}', style='error'

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/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/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/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/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 not prefix:
+            return '*'
+        if self.index is None:
+            return f'{prefix}/'
+        return f'{prefix}/{self.index}'
+
+    @classmethod
+    def parse(cls, spec: str) -> 'TestcasePattern':
+        spec = spec.strip()
+        if spec == '*':
+            return cls(group_prefix=[], index=None)
+
+        parts = spec.split('/')
+        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
+    ]

rbx/box/testcases/main.py

@@ -0,0 +1,158 @@
+import pathlib
+from typing import Annotated, List, Optional
+
+import typer
+
+from rbx import annotations, config, utils
+from rbx.box import package
+from rbx.box.generators import (
+    GenerationTestcaseEntry,
+    extract_generation_testcases,
+    extract_generation_testcases_from_patterns,
+    generate_outputs_for_testcases,
+    generate_standalone,
+)
+from rbx.box.testcase_utils import TestcaseEntry, TestcasePattern
+from rbx.console import console
+
+app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
+
+
+def _find_testcase(entry: TestcaseEntry) -> GenerationTestcaseEntry:
+    extracted = extract_generation_testcases([entry])
+    if not extracted:
+        console.print(f'[error]Testcase [item]{entry}[/item] not found.[/error]')
+        raise typer.Exit(1)
+    return extracted[0]
+
+
+def _should_generate_output(entry: GenerationTestcaseEntry) -> bool:
+    return (
+        entry.metadata.copied_from is None
+        or entry.metadata.copied_from.outputPath is None
+    ) and package.get_main_solution() is not None
+
+
+def _generate_input_for_editing(
+    entry: GenerationTestcaseEntry,
+    output: bool = True,
+    progress: Optional[utils.StatusProgress] = None,
+) -> pathlib.Path:
+    if (
+        output and _should_generate_output(entry)
+    ) or entry.metadata.copied_from is None:
+        generate_standalone(
+            entry.metadata,
+            validate=False,
+            group_entry=entry.group_entry,
+            progress=progress,
+        )
+    if entry.metadata.copied_from is not None:
+        return entry.metadata.copied_from.inputPath
+    return entry.metadata.copied_to.inputPath
+
+
+def _generate_output_for_editing(
+    entry: GenerationTestcaseEntry,
+    progress: Optional[utils.StatusProgress] = None,
+) -> Optional[pathlib.Path]:
+    if (
+        entry.metadata.copied_from is not None
+        and entry.metadata.copied_from.outputPath is not None
+    ):
+        return entry.metadata.copied_from.outputPath
+    if not _should_generate_output(entry):
+        return None
+    generate_outputs_for_testcases([entry.group_entry], progress=progress)
+    return entry.metadata.copied_to.outputPath
+
+
+def _generate_for_editing(
+    entry: GenerationTestcaseEntry,
+    input: bool,
+    output: bool,
+    progress: Optional[utils.StatusProgress] = None,
+) -> List[pathlib.Path]:
+    res = []
+    input_path = _generate_input_for_editing(entry, output=output, progress=progress)
+    if input:
+        res.append(input_path)
+    if output:
+        output_path = _generate_output_for_editing(entry, progress=progress)
+        if output_path is not None:
+            res.append(output_path)
+    return res
+
+
+@app.command('view, v', help='View a testcase in your default editor.')
+def view(
+    tc: Annotated[
+        str,
+        typer.Argument(help='Testcase to view. Format: [group]/[index].'),
+    ],
+    input_only: bool = typer.Option(
+        False,
+        '--input',
+        '-i',
+        help='Whether to open only the input file in the editor.',
+    ),
+    output_only: bool = typer.Option(
+        False,
+        '--output',
+        '-o',
+        help='Whether to open only the output file in the editor.',
+    ),
+):
+    if input_only and output_only:
+        console.print(
+            '[error]Flags --input and --output cannot be used together.[/error]'
+        )
+        raise typer.Exit(1)
+
+    entry = TestcaseEntry.parse(tc)
+    testcase = _find_testcase(entry)
+
+    with utils.StatusProgress('Preparing testcase...') as s:
+        items = _generate_for_editing(
+            testcase, input=not output_only, output=not input_only, progress=s
+        )
+    config.edit_multiple(items, readonly=True)
+
+
+@app.command('info, i', help='Show information about testcases.')
+def info(
+    pattern: Annotated[
+        Optional[str],
+        typer.Argument(
+            help='Testcases to detail, as a pattern. Might be a group, or a specific test in the format [group]/[index].'
+        ),
+    ] = None,
+):
+    tc_pattern = TestcasePattern.parse(pattern or '*')
+    testcases = extract_generation_testcases_from_patterns([tc_pattern])
+    if not testcases:
+        console.print(
+            f'[error]No testcases found matching pattern [item]{pattern}[/item].[/error]'
+        )
+        raise typer.Exit(1)
+
+    for testcase in testcases:
+        console.print(f'[status]Identifier:[/status] {testcase.group_entry}')
+        if testcase.metadata.generator_call is not None:
+            console.print(
+                f'[status]Generator call:[/status] {testcase.metadata.generator_call}'
+            )
+        if testcase.metadata.copied_from is not None:
+            console.print(
+                f'[status]Input file:[/status] {testcase.metadata.copied_from.inputPath}'
+            )
+            if testcase.metadata.copied_from.outputPath is not None:
+                console.print(
+                    f'[status]Output file:[/status] {testcase.metadata.copied_from.outputPath}'
+                )
+
+        if testcase.metadata.generator_script is not None:
+            console.print(
+                f'[status]Generator script:[/status] {testcase.metadata.generator_script.path}, line {testcase.metadata.generator_script.line}'
+            )
+        console.print()

rbx/box/validators.py

@@ -9,7 +9,7 @@ from rbx import console
 from rbx.box import package
 from rbx.box.code import SanitizationLevel, compile_item, run_item
 from rbx.box.schema import CodeItem, Primitive
-from rbx.box.testcases import find_built_testcase_inputs
+from rbx.box.testcase_utils import find_built_testcase_inputs
 from rbx.grading.judge.sandbox import SandboxBase
 from rbx.grading.steps import (
     DigestHolder,

rbx/config.py

@@ -5,6 +5,7 @@ import os
 import pathlib
 import shutil
 import subprocess
+import tempfile
 from typing import Any, Dict, List, Optional
 
 import requests
@@ -213,13 +214,40 @@ def get_editor():
     return get_config().editor or os.environ.get('EDITOR', None)
 
 
-def open_editor(path: pathlib.Path, *args):
+def is_vim_editor() -> bool:
+    editor = get_editor()
+    if editor is None:
+        return False
+    return editor.endswith('vim')
+
+
+def open_editor(path: Any, *args):
     editor = get_editor()
     if editor is None:
         raise Exception('No editor found. Please set the EDITOR environment variable.')
     subprocess.run([editor, str(path), *[str(arg) for arg in args]])
 
 
+def _readonly_copy(path: pathlib.Path) -> pathlib.Path:
+    temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False)
+    shutil.copy(str(path), temp_file.name)
+    temp_file.close()
+    return pathlib.Path(temp_file.name)
+
+
+def edit_multiple(paths: List[pathlib.Path], readonly: bool = False):
+    if is_vim_editor():
+        if readonly:
+            open_editor('-R', '-O', *paths)
+        else:
+            open_editor('-O', *paths)
+        return
+
+    if readonly:
+        paths = [_readonly_copy(path) for path in paths]
+    open_editor(*paths)
+
+
 @functools.cache
 def get_config() -> Config:
     config_path = get_config_path()

{rbx_cp-0.5.34.dist-info → rbx_cp-0.5.36.dist-info}/METADATA

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

{rbx_cp-0.5.34.dist-info → rbx_cp-0.5.36.dist-info}/RECORD

@@ -2,29 +2,29 @@ rbx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rbx/annotations.py,sha256=Z3jBUyZoXkrz34jko3Rft0bnMME6nWb0vsV5I3HlgR0,3064
 rbx/autoenum.py,sha256=cusv8ClXRlDVvhZ8eDrtYcL_2peXlHugAey_ht8roXk,12025
 rbx/box/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rbx/box/builder.py,sha256=eynVPyRdpYtSNmr8MP7-8jspNH74lj-DclwtiIcJrvM,3280
+rbx/box/builder.py,sha256=HeJMjzp78tbJS_9rvMR0qJXC6cmXIi6F59xAruX8Rpk,3483
 rbx/box/cd.py,sha256=9a_SOnzoJBXxxffp4Wbf3UKXIwKuN3Hvj7K6SocALwE,1194
 rbx/box/checkers.py,sha256=VpgDzevOK7hrffG2zJGxquNiu-a9Fl3wquLn7xadcK0,6285
 rbx/box/code.py,sha256=UFy7jOeTvxtIu9pdVUDv2-D6IW-beJGPC3uCanIKZh0,13412
 rbx/box/compile.py,sha256=OJLthDQ921w9vyoE6Gk1Df54i5RwtRJ2YG-8XEfefcs,2489
 rbx/box/conftest.py,sha256=sEmciXSeDC-wmrZ1JSxbsUenKNP_VWW32mrCun2pY3I,1070
 rbx/box/contest/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rbx/box/contest/build_contest_statements.py,sha256=FjkO-TaT9YqkWySyQEaa69_ZwwyrsNvEBT5hE4qSFgk,11375
+rbx/box/contest/build_contest_statements.py,sha256=H2MwmkiPO_cHUEenzfPxHuJ3XcwjHakGZwKojNJQt74,11380
 rbx/box/contest/contest_package.py,sha256=OaUbpBtkhkgOPzJ1ccI_Vq4FMSaJvZm3gMOKfVY8oy4,3032
 rbx/box/contest/contest_utils.py,sha256=TDE7I6YQJlu4dQd68wzOp019bNgqiT0RlM-LMQMjL9w,301
-rbx/box/contest/main.py,sha256=fFYeZn8KTLt9j-OFFkcBeQWw8RsTLUauFV6drM2hT48,7404
+rbx/box/contest/main.py,sha256=oL-GbyLKdpMjIWiSuWTQgRhQ9hcb7DuNn0axkunx0io,7436
 rbx/box/contest/schema.py,sha256=JMAig5WpaOahNgAHxA9vX4zYeVYDxpjKP_PFGvmmkE0,4954
 rbx/box/contest/statements.py,sha256=Pe4uo1hxvEON8O11VAzsOP3DxUel0vmwiAmolh4ltEs,2910
-rbx/box/creation.py,sha256=YOWn0zUFvt3ABGIYdc-bn_49UIhBzcDMarL7yjI1hqc,2662
+rbx/box/creation.py,sha256=Evz7K6JoarD-4JJQsZsgoxU9FgCF9Z7-LfuroG4Cqls,2444
 rbx/box/deferred.py,sha256=II3X9e87JCOZtmspnHh-n4PFqh-FsH_oc0XJHZ9ZYVQ,691
 rbx/box/download.py,sha256=MFP-R26JiYGAP89I0TK-0fYc69Fsd20tsBqgtRCy5AE,2234
 rbx/box/environment.py,sha256=47NtyuVC6zSQKAtQaXPEXvqcD-KJiuWRpWF8pYvcG4c,11158
 rbx/box/extensions.py,sha256=Von8kIeXvNFTkGlMRMTvL2HIHPwlkuiMswr-ydbGV1w,519
 rbx/box/formatting.py,sha256=3phFRHzqVXj4Ok1yDhCq6Clbw6KlqwJNpMhs--oTWFI,405
-rbx/box/generators.py,sha256=XJsWXNjtQXUDX2huAUsl-q7OWFyIPc42CyS557jLYxk,20594
-rbx/box/generators_test.py,sha256=BqWf-A0u0ifZJZlvrMuOHOHQPfMox2Jy6540GmnTnkc,1753
-rbx/box/main.py,sha256=9G21yVefrVLwM9NERozTe-w2xeEZROD2tDL82Gpc-AE,23722
-rbx/box/package.py,sha256=Z_voytvhDknhRKiLf1UsomvdRxlDxdXANNbUzL1HcD8,12042
+rbx/box/generators.py,sha256=OYAOhLQJMQFoQ2Tl-o2QO5sJL_HaWFPH9vnISr9rMno,22404
+rbx/box/generators_test.py,sha256=WvS5GH8QMInAXvR2nyeEfgtx8FHIH1ZSqYGkyEa1sqE,1910
+rbx/box/main.py,sha256=0lrPLJTGvatcGZCYgLRKKaRkWKEFmNKyA48Shm-uof8,24308
+rbx/box/package.py,sha256=80SDHvSzfraCUYutMn_kwsFsmmrSZiaeRHhhrWGmIY4,12081
 rbx/box/packaging/boca/extension.py,sha256=hQhcbocNfW2ESv5RalS1wf6uvOoOfOnR_gHvbXUbSzY,852
 rbx/box/packaging/boca/packager.py,sha256=FOhSRg5K5Y4qNB0WyTR3DKgrpObf9I0JbyGpJHOtxpo,10673
 rbx/box/packaging/contest_main.py,sha256=Hbxh7geNqrePs5tWhPgdg5W2qhaW5yoreK_VP0Sm19k,2727
@@ -39,13 +39,13 @@ rbx/box/presets/lock_schema.py,sha256=6sRPnyePOC8yy-5WcD5JRZdDJHf8loqbvpQ1IPiOU9
 rbx/box/presets/schema.py,sha256=mZmSPkQsw7eQM0lQN6er1MO_LiW1ObwwAZFDK0F5fxE,1962
 rbx/box/retries.py,sha256=z7cIh1QmLVUsTr3Attt_28dbwNg6KWTwpulcWCFwMPo,4667
 rbx/box/sanitizers/warning_stack.py,sha256=RI97_GJgdjTKIXY_r0EKp5h0qQQSDSdNDh5K7zINrqs,2861
-rbx/box/schema.py,sha256=iu6S2A2d_7SAQNFd34galQHxFAI2CQrIgXnSBlKgBCk,14307
+rbx/box/schema.py,sha256=n2CMfoDlS0GHqt7gT3GOv6ICA8_eZnjDildMnSY-wEs,14380
 rbx/box/setter_config.py,sha256=ZM7_G2tbaixaFr0NvRaXkowwfxSWF2Gb4XHBsr2Prpc,4279
-rbx/box/solutions.py,sha256=oSlKeublgwSeaz_qt79d9OQqKuK6MINxa4kkiavutZo,43974
-rbx/box/solutions_test.py,sha256=Cx7Goon_0sz_PaUcD8qa8gmjgzOVub6VHss3CB0GaA0,1524
+rbx/box/solutions.py,sha256=3lb0IJWjbF_RBaxr9fr6B9HYA-v-_cnkCx6n_Ps5lcg,43979
+rbx/box/solutions_test.py,sha256=9l5yk6vLtCk-2XDK-5NNUbgjvWmwTUa9lsvLvQ3KgSI,1681
 rbx/box/state.py,sha256=yTpjfASpnSXkRB3JiDNvCg5b9JNnNxuYT4uMcbdr59s,109
 rbx/box/statements/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rbx/box/statements/build_statements.py,sha256=GyCI_aiQpWSqz_ihDq5XCYXVOiWFRLXqhOesSRlmU1E,12019
+rbx/box/statements/build_statements.py,sha256=qR6WxUNvSQTBs241qH-qDRbD8IoN_hKeZ2TwY7NXJBQ,12024
 rbx/box/statements/builders.py,sha256=pKevMe3GwiXN_k0L2l155sY1rSLneSs0DLJ5T7WhxKQ,11152
 rbx/box/statements/joiners.py,sha256=ZbxomnMjEFT8yf5WSWUB4tBa3DL3AhjGEuh8uqHyDdg,2837
 rbx/box/statements/latex.py,sha256=LkcHwXjMFxbw--Gj9T1VkFKQFsXhY9dN7xZHpZycNW8,1346
@@ -55,17 +55,19 @@ rbx/box/stresses.py,sha256=ceFpkZVKBfKKVrKFjeARdub5VGKmU9JPZwj-FxcqYjQ,11771
 rbx/box/stressing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rbx/box/stressing/finder_parser.py,sha256=jXpYNa4FyugzmHi3r96Uv4rU1krRQJc5Ihr9jf1cvNo,11918
 rbx/box/stressing/generator_parser.py,sha256=oHZryjR3YohgaSO9WEirQ7b2e-98WgZStF0N99W4Thw,7380
-rbx/box/testcases.py,sha256=d10qlOLK-gzedL3PYm56eq5R4D_kBjTBC1S9VKlRkz0,1850
+rbx/box/testcase_utils.py,sha256=hlVvrmf7lp6DiRd2E-sFHVsvbctQujXCr7DrGi0040I,4035
+rbx/box/testcases/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rbx/box/testcases/main.py,sha256=6ywg3fSMW1hllHobg6Wcgw1pQczwjlJ3J10dgQtCdss,5212
 rbx/box/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rbx/box/ui/captured_log.py,sha256=ptICDPViVnz-_2NfrcB0SSBXNW5L74zI-vAZNN7kSok,11319
 rbx/box/ui/css/app.tcss,sha256=apd5PkPEvl5jK3kE2qrxPyVED1VnvSsj08QQwzUPwEA,786
 rbx/box/ui/main.py,sha256=b0rHcBF42W4AOCv7WhtiGf_rUnY0yxpqO5oj3wfR4R4,984
 rbx/box/ui/run.py,sha256=wMEXrEFdQvMHz2hRKAFIithTnTtaL0kNQZu0jKmb8jI,7060
-rbx/box/validators.py,sha256=f6595hPsNSCxp8Q9IiGwWTrSNOBiJlQw63NVo0v1cRQ,9023
+rbx/box/validators.py,sha256=RtXyuiBDourcBp__YEibWLpr4Wj7YcIYOpkR8Vk6oro,9028
 rbx/box/validators_test.py,sha256=hriR6rD32Ouu64eKYYTPLZVvqMxXj7Q2h1l_JAefL7U,344
 rbx/checker.py,sha256=pj1jO3my48ru-qugbER5onccANCjoR0-PaFe3H3VGEY,4118
 rbx/clone.py,sha256=wpHyED0_7ST7LD3vj7HjXhzqEzlwh6dRQvKQVDYhGeU,6744
-rbx/config.py,sha256=gM0-3ORnCoXNpIxIA3EAXEaiNY7s_NPzD7WbFYGbrlA,7436
+rbx/config.py,sha256=78xKH0zddEF32uIbIs10snqvACx20DmzjQTCex7w95Y,8136
 rbx/conftest.py,sha256=ouilbOIpvX8jTEdCAiWT85CbdBQKUUf41BjmDI82u-Y,967
 rbx/console.py,sha256=X8EJy68OROgh6ao3ZcUjZm5Y56VFMzen58ywAuQ7pAU,990
 rbx/create.py,sha256=ezUq9KiSA-88ASd8CtjWXw8UB4LCaQ3Gib3OgvsLK-Q,986
@@ -165,8 +167,8 @@ rbx/testdata/caching/executable.py,sha256=WKRHNf_fprFJd1Fq1ubmQtR3mZzTYVNwKPLWuZ
 rbx/testdata/compatible,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rbx/testing_utils.py,sha256=ZZLKMUHlZ4HwsuNY50jqSBJ9HhpnFdba7opjDsvXE1U,2084
 rbx/utils.py,sha256=AITbkWpWtSp-x3Xept_aObfj_jPL7XL0JJoz5-F9Fp8,4671
-rbx_cp-0.5.34.dist-info/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-rbx_cp-0.5.34.dist-info/METADATA,sha256=iLu8QtrjNShKSOL-kXyqAys7nYVTJDSKH6NY9EyZpJE,3263
-rbx_cp-0.5.34.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-rbx_cp-0.5.34.dist-info/entry_points.txt,sha256=qBTLBOeifT1F00LWaEewRRE_jQPgvH7BUdJfZ-dYsFU,57
-rbx_cp-0.5.34.dist-info/RECORD,,
+rbx_cp-0.5.36.dist-info/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+rbx_cp-0.5.36.dist-info/METADATA,sha256=5_8xG48aXtFz3-953WgYq5CUXpHu4snzLQ5iQKmbdhA,3263
+rbx_cp-0.5.36.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+rbx_cp-0.5.36.dist-info/entry_points.txt,sha256=qBTLBOeifT1F00LWaEewRRE_jQPgvH7BUdJfZ-dYsFU,57
+rbx_cp-0.5.36.dist-info/RECORD,,

rbx/box/testcases.py

@@ -1,70 +0,0 @@
-import pathlib
-import shutil
-from typing import List, 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':
-        group, index = spec.split('/')
-        return TestcaseEntry(group=group.strip(), index=int(index))
-
-
-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
-    ]