rbx.cp 0.5.40__py3-none-any.whl → 0.5.45__py3-none-any.whl

rbx/box/statements/build_statements.py

@@ -3,6 +3,7 @@ import tempfile
 import typing
 from typing import Annotated, Dict, List, Optional, Tuple
 
+import syncer
 import typer
 
 from rbx import annotations, console
@@ -307,7 +308,8 @@ def build_statement(
 
 @app.command('build, b', help='Build statements.')
 @package.within_problem
-def build(
+@syncer.sync
+async def build(
     verification: environment.VerificationParam,
     languages: Annotated[
         Optional[List[str]],
@@ -335,7 +337,7 @@ def build(
     if samples:
         from rbx.box import builder
 
-        if not builder.build(
+        if not await builder.build(
             verification=verification,
             groups=set(['samples']),
             output=None,

rbx/box/stresses.py

@@ -3,6 +3,7 @@ import time
 from shutil import rmtree
 from typing import List, Optional
 
+import syncer
 import typer
 from pydantic import BaseModel
 
@@ -15,7 +16,7 @@ from rbx.box.generators import (
     generate_standalone,
 )
 from rbx.box.retries import Retrier
-from rbx.box.schema import CodeItem, GeneratorCall, Stress, Testcase
+from rbx.box.schema import CodeItem, GeneratorCall, Stress, TaskType, Testcase
 from rbx.box.solutions import compile_solutions, get_outcome_style_verdict
 from rbx.box.stressing import finder_parser
 from rbx.grading.steps import (
@@ -49,7 +50,8 @@ def _compile_finder(finder: CodeItem) -> str:
     return digest
 
 
-def run_stress(
+@syncer.sync
+async def run_stress(
     name: str,
     timeoutInSeconds: int,
     finder: Optional[str] = None,
@@ -59,6 +61,13 @@ def run_stress(
     progress: Optional[StatusProgress] = None,
     sanitized: bool = False,
 ) -> StressReport:
+    pkg = package.find_problem_package_or_die()
+    if pkg.type == TaskType.COMMUNICATION:
+        console.console.print(
+            '[error]Communication problems do not support stress testing.[/error]'
+        )
+        raise typer.Exit(1)
+
     if finder:
         stress = Stress(
             name=f'{name}',
@@ -128,7 +137,7 @@ def run_stress(
         input_path.parent.mkdir(parents=True, exist_ok=True)
 
         expanded_generator_call = expand_generator_call(stress.generator)
-        generate_standalone(
+        await generate_standalone(
             GenerationMetadata(
                 generator_call=expanded_generator_call,
                 copied_to=Testcase(inputPath=input_path),
@@ -140,7 +149,7 @@ def run_stress(
         )
 
         @functools.cache
-        def run_solution_fn(
+        async def run_solution_fn(
             solution: str,
             retry_index: Optional[int] = None,
             input_path=input_path,
@@ -150,7 +159,7 @@ def run_stress(
             output_path = input_path.with_stem(f'{index}').with_suffix('.out')
             stderr_path = output_path.with_suffix('.err')
 
-            run_log = run_item(
+            run_log = await run_item(
                 sol,
                 DigestOrSource.create(solutions_digest[sol.path]),
                 stdin=DigestOrSource.create(input_path),
@@ -168,7 +177,7 @@ def run_stress(
         # Get main solution output.
         expected_output_path = empty_path
         if needs_expected_output:
-            main_testcase_log = run_solution_fn(str(solutions[0].path))
+            main_testcase_log = await run_solution_fn(str(solutions[0].path))
             main_checker_result = checkers.check_with_no_output(main_testcase_log)
             if main_checker_result.outcome != Outcome.ACCEPTED:
                 console.console.print(
@@ -190,23 +199,23 @@ def run_stress(
             expected_output_path = main_testcase_log.stdout_absolute_path
 
         @functools.cache
-        def run_solution_and_checker_fn(
+        async def run_solution_and_checker_fn(
             call: finder_parser.FinderCall,
             input_path=input_path,
             expected_output_path=expected_output_path,
         ) -> finder_parser.FinderResult:
-            def run_fn(retry_index: int) -> Evaluation:
+            async def run_fn(retry_index: int) -> Evaluation:
                 solution = call.solution
                 checker = call.checker
 
-                testcase_log = run_solution_fn(solution, retry_index=retry_index)
+                testcase_log = await run_solution_fn(solution, retry_index=retry_index)
                 assert testcase_log.stdout_absolute_path is not None
 
                 if checker is None:
                     checker_result = checkers.check_with_no_output(testcase_log)
                 else:
                     checker_digest = finders_digest[checker.path]
-                    checker_result = checkers.check(
+                    checker_result = await checkers.check(
                         checker_digest,
                         testcase_log,
                         Testcase(inputPath=input_path, outputPath=expected_output_path),
@@ -224,7 +233,7 @@ def run_stress(
                 )
 
             retrier = Retrier(is_stress=True)
-            eval = retrier.repeat(run_fn)
+            eval = await retrier.repeat(run_fn)
 
             return finder_parser.FinderResult(
                 solution=call.solution,
@@ -234,7 +243,9 @@ def run_stress(
                 checker_result=eval.result,
             )
 
-        runner = finder_parser.FinderTreeRunner(runner=run_solution_and_checker_fn)
+        runner = finder_parser.FinderTreeRunner(
+            runner=syncer.sync(run_solution_and_checker_fn)
+        )
         finder_outcome: finder_parser.FinderOutcome = runner.transform(parsed_finder)
 
         internal_error_results = [

rbx/box/tasks.py

@@ -0,0 +1,277 @@
+import pathlib
+from typing import Optional
+
+from rbx.box import checkers, package, state
+from rbx.box.code import CommunicationItem, run_communication, run_item
+from rbx.box.environment import EnvironmentSandbox, ExecutionConfig, VerificationLevel
+from rbx.box.retries import Retrier
+from rbx.box.schema import Limits, Solution, Testcase
+from rbx.grading.judge.sandbox import SandboxBase
+from rbx.grading.steps import (
+    DigestOrDest,
+    DigestOrSource,
+    Evaluation,
+    GradingFileInput,
+    GradingFileOutput,
+    TestcaseIO,
+    TestcaseLog,
+)
+from rbx.utils import model_to_yaml
+
+
+def get_limits_for_language(
+    lang: Optional[str],
+    verification: VerificationLevel,
+    timelimit_override: Optional[int],
+    use_timelimit: bool = True,
+) -> Limits:
+    pkg = package.find_problem_package_or_die()
+    time = timelimit_override or pkg.timelimit_for_language(lang)
+    isDoubleTL = verification.value >= VerificationLevel.FULL.value
+    memory = pkg.memorylimit_for_language(lang)
+    return Limits(
+        time=time if use_timelimit else None,
+        memory=memory,
+        output=pkg.outputLimit,
+        isDoubleTL=isDoubleTL,
+    )
+
+
+async def run_solution_on_testcase(
+    solution: Solution,
+    compiled_digest: str,
+    checker_digest: Optional[str],
+    testcase: Testcase,
+    output_dir: pathlib.Path,
+    interactor_digest: Optional[str] = None,
+    testcase_index: int = 0,
+    verification: VerificationLevel = VerificationLevel.NONE,
+    timelimit_override: Optional[int] = None,
+    use_retries: bool = True,
+    use_timelimit: bool = True,
+    capture_pipes: bool = False,
+) -> Evaluation:
+    if interactor_digest is not None:
+        return await _run_communication_solution_on_testcase(
+            solution,
+            compiled_digest,
+            interactor_digest,
+            checker_digest,
+            testcase,
+            output_dir,
+            testcase_index=testcase_index,
+            verification=verification,
+            timelimit_override=timelimit_override,
+            use_retries=use_retries,
+            use_timelimit=use_timelimit,
+            capture_pipes=capture_pipes,
+        )
+
+    async def run_fn(retry_index: int) -> Evaluation:
+        actual_sandbox = package.get_singleton_sandbox()
+
+        limits = get_limits_for_language(
+            solution.language,
+            verification,
+            timelimit_override,
+            use_timelimit=use_timelimit,
+        )
+        extra_config = _get_execution_config(limits, actual_sandbox)
+
+        output_path = output_dir / testcase.inputPath.with_suffix('.out').name
+        error_path = output_path.with_suffix('.err')
+        log_path = output_path.with_suffix('.log')
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        run_log = await run_item(
+            solution,
+            DigestOrSource.create(compiled_digest),
+            stdin=DigestOrSource.create(testcase.inputPath),
+            stdout=DigestOrDest.create(output_path),
+            stderr=DigestOrDest.create(error_path),
+            extra_config=extra_config,
+            retry_index=retry_index,
+        )
+
+        if checker_digest is not None:
+            checker_result = await checkers.check(
+                checker_digest,
+                run_log,
+                testcase,
+                program_output=output_path,
+            )
+        else:
+            checker_result = checkers.check_with_no_output(run_log)
+
+        eval = Evaluation(
+            result=checker_result,
+            testcase=TestcaseIO(
+                index=testcase_index,
+                input=testcase.inputPath,
+                output=testcase.outputPath,
+            ),
+            log=TestcaseLog(
+                **(run_log.model_dump() if run_log is not None else {}),
+                stdout_absolute_path=output_path.absolute(),
+                stderr_absolute_path=error_path.absolute(),
+                log_absolute_path=log_path.absolute(),
+            ),
+        )
+
+        log_path.write_text(model_to_yaml(eval))
+        return eval
+
+    if not use_retries:
+        return await run_fn(0)
+
+    retrier = Retrier()
+    return await retrier.repeat(run_fn)
+
+
+def _get_execution_config(
+    limits: Limits,
+    actual_sandbox: SandboxBase,
+) -> ExecutionConfig:
+    sandbox = EnvironmentSandbox()
+    sandbox.timeLimit = limits.time
+    if limits.isDoubleTL and sandbox.timeLimit is not None:
+        # Double TL.
+        sandbox.timeLimit = sandbox.timeLimit * 2
+    sandbox.wallTimeLimit = sandbox.timeLimit
+    if sandbox.timeLimit is not None and actual_sandbox.use_soft_timeout():
+        sandbox.wallTimeLimit = sandbox.timeLimit * 2
+    sandbox.memoryLimit = limits.memory
+    sandbox.fileSizeLimit = limits.output
+    return ExecutionConfig(sandbox=sandbox)
+
+
+async def _run_communication_solution_on_testcase(
+    solution: Solution,
+    compiled_digest: str,
+    interactor_digest: str,
+    checker_digest: Optional[str],
+    testcase: Testcase,
+    output_dir: pathlib.Path,
+    testcase_index: int = 0,
+    verification: VerificationLevel = VerificationLevel.NONE,
+    timelimit_override: Optional[int] = None,
+    use_retries: bool = True,
+    use_timelimit: bool = True,
+    capture_pipes: bool = False,
+) -> Evaluation:
+    capture_pipes = capture_pipes or state.STATE.debug_logs
+
+    async def run_fn(retry_index: int) -> Evaluation:
+        actual_sandbox = package.get_singleton_sandbox()
+        interactor_sandbox = package.get_singleton_interactor_sandbox()
+
+        limits = get_limits_for_language(
+            solution.language,
+            verification,
+            timelimit_override,
+            use_timelimit=use_timelimit,
+        )
+
+        extra_config = _get_execution_config(limits, actual_sandbox)
+        interactor_extra_config = _get_execution_config(limits, interactor_sandbox)
+        if (
+            interactor_extra_config.sandbox is not None
+            and interactor_extra_config.sandbox.wallTimeLimit is not None
+            and extra_config.sandbox is not None
+            and extra_config.sandbox.wallTimeLimit is not None
+        ):
+            interactor_extra_config.sandbox.wallTimeLimit += (
+                extra_config.sandbox.wallTimeLimit
+            )
+        # TODO: maybe combine wall time limits?
+
+        output_path = output_dir / testcase.inputPath.with_suffix('.out').name
+        error_path = output_path.with_suffix('.err')
+        log_path = output_path.with_suffix('.log')
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        interactor_capture_path = (
+            output_path.with_suffix('.pin') if capture_pipes else None
+        )
+        interactor_item = CommunicationItem(
+            code=package.get_interactor(),
+            executable=DigestOrSource.create(interactor_digest),
+            stderr=DigestOrDest.create(error_path),
+            extra_config=interactor_extra_config,
+            extra_args='interactor.in interactor.out',
+            inputs=[
+                GradingFileInput(
+                    src=testcase.inputPath,
+                    dest=pathlib.PosixPath('interactor.in'),
+                )
+            ],
+            outputs=[
+                GradingFileOutput(
+                    src=pathlib.PosixPath('interactor.out'),
+                    dest=output_path,
+                    touch=True,
+                )
+            ],
+            capture=DigestOrDest.create(interactor_capture_path)
+            if interactor_capture_path
+            else None,
+        )
+        solution_capture_path = (
+            output_path.with_suffix('.pout') if capture_pipes else None
+        )
+        solution_item = CommunicationItem(
+            code=solution,
+            executable=DigestOrSource.create(compiled_digest),
+            extra_config=extra_config,
+            capture=DigestOrDest.create(solution_capture_path)
+            if solution_capture_path
+            else None,
+        )
+
+        merged_capture_path = output_path.with_suffix('.pio') if capture_pipes else None
+        interactor_run_log, run_log = await run_communication(
+            interactor=interactor_item,
+            solution=solution_item,
+            retry_index=retry_index,
+            merged_capture=merged_capture_path,
+        )
+
+        checker_result = await checkers.check_communication(
+            checker_digest,
+            run_log,
+            interactor_run_log,
+            error_path,
+            testcase,
+            output_path,
+        )
+
+        eval = Evaluation(
+            result=checker_result,
+            testcase=TestcaseIO(
+                index=testcase_index,
+                input=testcase.inputPath,
+                output=testcase.outputPath,
+            ),
+            log=TestcaseLog(
+                **(run_log.model_dump() if run_log is not None else {}),
+                stdout_absolute_path=output_path.absolute(),
+                stderr_absolute_path=error_path.absolute(),
+                log_absolute_path=log_path.absolute(),
+            ),
+        )
+
+        log_path.write_text(model_to_yaml(eval))
+
+        if interactor_run_log is not None:
+            interactor_log_path = output_path.with_suffix('.int.log')
+            interactor_log_path.write_text(model_to_yaml(interactor_run_log))
+        if run_log is not None:
+            solution_log_path = output_path.with_suffix('.sol.log')
+            solution_log_path.write_text(model_to_yaml(run_log))
+        return eval
+
+    if not use_retries:
+        return await run_fn(0)
+
+    retrier = Retrier()
+    return await retrier.repeat(run_fn)

rbx/box/testcase_extractors.py

@@ -30,7 +30,7 @@ def _get_group_output(
     return group_path / f'{subgroup_prefix}{i:03d}.out'
 
 
-def _run_generator_script(testcase: TestcaseSubgroup) -> str:
+async def _run_generator_script(testcase: TestcaseSubgroup) -> str:
     assert testcase.generatorScript is not None
 
     cacher = package.get_file_cacher()
@@ -54,7 +54,7 @@ def _run_generator_script(testcase: TestcaseSubgroup) -> str:
             raise
 
         run_stderr = DigestHolder()
-        run_log = run_item(
+        run_log = await run_item(
             testcase.generatorScript,
             DigestOrSource.create(compiled_digest),
             stdout=DigestOrDest.create(script_digest),
@@ -116,7 +116,7 @@ class GenerationTestcaseEntry(BaseModel):
 
 class TestcaseVisitor(abc.ABC):
     @abc.abstractmethod
-    def visit(self, entry: GenerationTestcaseEntry):
+    async def visit(self, entry: GenerationTestcaseEntry):
         pass
 
     def should_visit_group(self, group_name: str) -> bool:
@@ -139,10 +139,10 @@ class TestcaseGroupVisitor(TestcaseVisitor):
         return self.groups is None or group_name in self.groups
 
 
-def run_testcase_visitor(visitor: TestcaseVisitor):
+async def run_testcase_visitor(visitor: TestcaseVisitor):
     pkg = package.find_problem_package_or_die()
 
-    def _explore_subgroup(
+    async def _explore_subgroup(
         subgroup: TestcaseSubgroup,
         subgroup_index: Optional[int],
         prefix: List[str],
@@ -179,7 +179,7 @@ def run_testcase_visitor(visitor: TestcaseVisitor):
         i = 0
         # Individual testcases.
         for tc in subgroup.testcases or []:
-            visitor.visit(
+            await visitor.visit(
                 GenerationTestcaseEntry(
                     group_entry=_entry(i),
                     subgroup_entry=_sub_entry(i),
@@ -202,7 +202,7 @@ def run_testcase_visitor(visitor: TestcaseVisitor):
                     continue
 
                 tc = Testcase(inputPath=input_path)
-                visitor.visit(
+                await visitor.visit(
                     GenerationTestcaseEntry(
                         group_entry=_entry(i),
                         subgroup_entry=_sub_entry(i),
@@ -218,7 +218,7 @@ def run_testcase_visitor(visitor: TestcaseVisitor):
 
         # Single generators.
         for generator_call in subgroup.generators:
-            visitor.visit(
+            await visitor.visit(
                 GenerationTestcaseEntry(
                     group_entry=_entry(i),
                     subgroup_entry=_sub_entry(i),
@@ -237,12 +237,12 @@ def run_testcase_visitor(visitor: TestcaseVisitor):
 
         # Run generator script.
         if subgroup.generatorScript is not None:
-            script = _run_generator_script(subgroup)
+            script = await _run_generator_script(subgroup)
 
             # Run each line from generator script.
             for generator_name, args, line_number in _extract_script_lines(script):
                 call = GeneratorCall(name=generator_name, args=args)
-                visitor.visit(
+                await visitor.visit(
                     GenerationTestcaseEntry(
                         group_entry=_entry(i),
                         subgroup_entry=_sub_entry(i),
@@ -269,7 +269,7 @@ def run_testcase_visitor(visitor: TestcaseVisitor):
             group_validator = group.validator
 
         extra_validators = group.extraValidators
-        _explore_subgroup(
+        await _explore_subgroup(
             group,
             0 if group.subgroups else None,
             [group.name],
@@ -278,7 +278,7 @@ def run_testcase_visitor(visitor: TestcaseVisitor):
         )
 
         for i, subgroup in enumerate(group.subgroups):
-            _explore_subgroup(
+            await _explore_subgroup(
                 subgroup,
                 i + 1,
                 [group.name, subgroup.name],
@@ -287,7 +287,7 @@ def run_testcase_visitor(visitor: TestcaseVisitor):
             )
 
 
-def extract_generation_testcases(
+async def extract_generation_testcases(
     entries: List[TestcaseEntry],
 ) -> List[GenerationTestcaseEntry]:
     # TODO: support subgroups.
@@ -300,30 +300,30 @@ def extract_generation_testcases(
         def should_visit_group(self, group_name: str) -> bool:
             return group_name in groups
 
-        def visit(self, entry: GenerationTestcaseEntry):
+        async 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())
+    await run_testcase_visitor(ExtractGenerationTestcasesVisitor())
     return res
 
 
-def extract_generation_testcases_from_groups(
+async def extract_generation_testcases_from_groups(
     groups: Optional[Set[str]] = None,
 ) -> List[GenerationTestcaseEntry]:
     res: List[GenerationTestcaseEntry] = []
 
     class ExtractGenerationTestcasesVisitor(TestcaseGroupVisitor):
-        def visit(self, entry: GenerationTestcaseEntry):
+        async def visit(self, entry: GenerationTestcaseEntry):
             res.append(entry)
 
-    run_testcase_visitor(ExtractGenerationTestcasesVisitor(groups))
+    await run_testcase_visitor(ExtractGenerationTestcasesVisitor(groups))
     return res
 
 
-def extract_generation_testcases_from_patterns(
+async def extract_generation_testcases_from_patterns(
     patterns: List[TestcasePattern],
 ) -> List[GenerationTestcaseEntry]:
     res: List[GenerationTestcaseEntry] = []
@@ -337,12 +337,12 @@ def extract_generation_testcases_from_patterns(
                 pattern.intersecting_group(subgroup_path) for pattern in patterns
             )
 
-        def visit(self, entry: GenerationTestcaseEntry):
+        async 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())
+    await run_testcase_visitor(ExtractGenerationTestcasesVisitor())
     return res

rbx/box/testcases/main.py

@@ -1,6 +1,7 @@
 import pathlib
 from typing import Annotated, List, Optional
 
+import syncer
 import typer
 
 from rbx import annotations, config, utils
@@ -20,8 +21,8 @@ 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])
+async def _find_testcase(entry: TestcaseEntry) -> GenerationTestcaseEntry:
+    extracted = await extract_generation_testcases([entry])
     if not extracted:
         console.print(f'[error]Testcase [item]{entry}[/item] not found.[/error]')
         raise typer.Exit(1)
@@ -35,7 +36,7 @@ def _should_generate_output(entry: GenerationTestcaseEntry) -> bool:
     ) and package.get_main_solution() is not None
 
 
-def _generate_input_for_editing(
+async def _generate_input_for_editing(
     entry: GenerationTestcaseEntry,
     output: bool = True,
     progress: Optional[utils.StatusProgress] = None,
@@ -43,7 +44,7 @@ def _generate_input_for_editing(
     if (
         output and _should_generate_output(entry)
     ) or entry.metadata.copied_from is None:
-        generate_standalone(
+        await generate_standalone(
             entry.metadata,
             validate=False,
             group_entry=entry.group_entry,
@@ -54,7 +55,7 @@ def _generate_input_for_editing(
     return entry.metadata.copied_to.inputPath
 
 
-def _generate_output_for_editing(
+async def _generate_output_for_editing(
     entry: GenerationTestcaseEntry,
     progress: Optional[utils.StatusProgress] = None,
 ) -> Optional[pathlib.Path]:
@@ -65,29 +66,32 @@ def _generate_output_for_editing(
         return entry.metadata.copied_from.outputPath
     if not _should_generate_output(entry):
         return None
-    generate_outputs_for_testcases([entry.group_entry], progress=progress)
+    await generate_outputs_for_testcases([entry.group_entry], progress=progress)
     return entry.metadata.copied_to.outputPath
 
 
-def _generate_for_editing(
+async 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)
+    input_path = await _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)
+        output_path = await _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(
+@syncer.sync
+async def view(
     tc: Annotated[
         str,
         typer.Argument(help='Testcase to view. Format: [group]/[index].'),
@@ -112,17 +116,18 @@ def view(
         raise typer.Exit(1)
 
     entry = TestcaseEntry.parse(tc)
-    testcase = _find_testcase(entry)
+    testcase = await _find_testcase(entry)
 
     with utils.StatusProgress('Preparing testcase...') as s:
-        items = _generate_for_editing(
+        items = await _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(
+@syncer.sync
+async def info(
     pattern: Annotated[
         Optional[str],
         typer.Argument(
@@ -131,7 +136,7 @@ def info(
     ] = None,
 ):
     tc_pattern = TestcasePattern.parse(pattern or '*')
-    testcases = extract_generation_testcases_from_patterns([tc_pattern])
+    testcases = await extract_generation_testcases_from_patterns([tc_pattern])
     if not testcases:
         console.print(
             f'[error]No testcases found matching pattern [item]{pattern}[/item].[/error]'