rbx.cp 0.5.28__py3-none-any.whl → 0.5.30__py3-none-any.whl

rbx/box/generators_test.py

@@ -19,7 +19,7 @@ def test_generator_works(pkg_from_testdata: pathlib.Path):
     print_directory_tree(pkg_from_testdata)
 
     assert (
-        package.get_build_testgroup_path('gen1') / '0-main-000.in'
+        package.get_build_testgroup_path('gen1') / '0-000.in'
     ).read_text() == '777\n'
     assert (
         package.get_build_testgroup_path('gen1') / '1-gen-000.in'

rbx/box/main.py

@@ -25,6 +25,7 @@ from rbx.box import (
     builder,
     cd,
     setter_config,
+    state,
     creation,
     download,
     environment,
@@ -48,6 +49,7 @@ from rbx.box.solutions import (
     run_solutions,
 )
 from rbx.box.statements import build_statements
+from rbx.box.testcases import TestcaseEntry
 
 app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
 app.add_typer(
@@ -82,6 +84,11 @@ app.add_typer(
 )
 
 
+@app.callback()
+def main():
+    state.STATE.run_through_cli = True
+
+
 # @app.command('ui', hidden=True)
 # @package.within_problem
 # def ui():
@@ -254,6 +261,7 @@ def _time_impl(check: bool, detailed: bool) -> Optional[int]:
             tracked_solutions=tracked_solutions,
             check=check,
             verification=VerificationLevel(verification),
+            timelimit_override=600,  # 10 minute time limit for estimation
         )
 
     console.console.print()
@@ -343,6 +351,14 @@ def irun(
         '-g',
         help='Generator call to use to generate a single test for execution.',
     ),
+    testcase: Optional[str] = typer.Option(
+        None,
+        '--testcase',
+        '--test',
+        '-tc',
+        '-t',
+        help='Testcase to run, in the format "[group]/[index]". If not specified, will run interactively.',
+    ),
     print: bool = typer.Option(
         False, '--print', '-p', help='Whether to print outputs to terminal.'
     ),
@@ -370,13 +386,6 @@ def irun(
         )
         return
 
-    main_solution = package.get_main_solution()
-    if check and main_solution is None:
-        console.console.print(
-            '[warning]No main solution found, running without checkers.[/warning]'
-        )
-        check = False
-
     tracked_solutions = None
     if outcome is not None:
         tracked_solutions = {
@@ -411,6 +420,7 @@ def irun(
                 generator=generators.get_call_from_string(generator)
                 if generator is not None
                 else None,
+                testcase_entry=TestcaseEntry.parse(testcase) if testcase else None,
                 print=print,
                 sanitized=sanitized,
             )

rbx/box/schema.py

@@ -20,6 +20,12 @@ def NameField(**kwargs):
     )
 
 
+def FNameField(**kwargs):
+    return Field(
+        pattern=r'^[a-zA-Z0-9][a-zA-Z0-9\-_]*$', min_length=3, max_length=128, **kwargs
+    )
+
+
 def _check_oneof(model_obj: BaseModel, fields: List[str]):
     has = []
     for field in fields:
@@ -100,9 +106,9 @@ class ExpectedOutcome(AutoEnum):
         if self.match(Outcome.TIME_LIMIT_EXCEEDED):
             return 'yellow'
         if self.match(Outcome.RUNTIME_ERROR):
-            return 'lnumber'
+            return 'blue'
         if self.match(Outcome.MEMORY_LIMIT_EXCEEDED):
-            return 'cyan'
+            return 'yellow'
         return 'magenta'
 
     def is_slow(self) -> bool:
@@ -150,11 +156,11 @@ class CodeItem(BaseModel):
     )
 
     language: Optional[str] = Field(
-        None, description="""The language of the code file."""
+        default=None, description="""The language of the code file."""
     )
 
     compilationFiles: Optional[List[str]] = Field(
-        [],
+        default=[],
         description="""
 Extra files that should be placed alongside the code file during its compilation,
 such as testlib.h, jngen.h, etc.
@@ -173,17 +179,17 @@ class Testcase(BaseModel):
     inputPath: pathlib.Path = Field(description="""The path of the input file.""")
 
     outputPath: Optional[pathlib.Path] = Field(
-        None, description="""The path of the output file."""
+        default=None, description="""The path of the output file."""
     )
 
 
 class GeneratorCall(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
-    name: str = NameField(description='The name of the generator to call.')
+    name: str = FNameField(description='The name of the generator to call.')
 
     args: Optional[str] = Field(
-        None, description='The arguments to pass to the generator.'
+        default=None, description='The arguments to pass to the generator.'
     )
 
 
@@ -193,31 +199,31 @@ class TestcaseSubgroup(BaseModel):
     name: str = NameField(description='The name of the test group.')
 
     testcases: List[Testcase] = Field(
-        [],
+        default=[],
         description="""
 The path of testcases to add to this group,
 in the order they're defined.""",
     )
 
     testcaseGlob: Optional[str] = Field(
-        None,
+        default=None,
         description="""
 A Python glob that matches input file paths relative to the
 package directory. The globbed files should end with the extension
 ".in", and their corresponding outputs, if defined, should have the same file name,
-but ending with ".out".
+but ending with ".ans".
 """,
     )
 
     generators: List[GeneratorCall] = Field(
-        [],
+        default=[],
         description="""
 A list of generators to call to generate testcases for this group.
 """,
     )
 
     generatorScript: Optional[CodeItem] = Field(
-        None,
+        default=None,
         description="""
 A generator script to call to generate testcases for this group.
 """,
@@ -241,14 +247,14 @@ class TestcaseGroup(TestcaseSubgroup):
     model_config = ConfigDict(extra='forbid')
 
     subgroups: List[TestcaseSubgroup] = Field(
-        [],
+        default=[],
         description="""
 A list of test subgroups to define for this group.
         """,
     )
 
     validator: Optional[CodeItem] = Field(
-        None,
+        default=None,
         description="""
 A validator to use to validate the testcases of this group.
 If not specified, will use the package-level validator.
@@ -257,7 +263,7 @@ Useful in cases where the constraints vary across test groups.
     )
 
     weight: Optional[float] = Field(
-        1.0,
+        default=1.0,
         description="""
 The weight of this group in the final score. Useful for
 problems that have points.
@@ -295,29 +301,29 @@ class Stress(BaseModel):
 
 class Limits(BaseModel):
     time: Optional[int] = Field(
-        None, description='Value to override time limit with, in milliseconds.'
+        default=None, description='Value to override time limit with, in milliseconds.'
     )
     memory: Optional[int] = Field(
-        None, description='Value to override memory limit with, in MB.'
+        default=None, description='Value to override memory limit with, in MB.'
     )
     output: Optional[int] = Field(
-        None, description='Value to override output limit with, in KB.'
+        default=None, description='Value to override output limit with, in KB.'
     )
 
     isDoubleTL: bool = Field(
-        False, description='Whether to use double TL for this language.'
+        default=False, description='Whether to use double TL for this language.'
     )
 
 
 class LimitModifiers(BaseModel):
     timeMultiplier: Optional[float] = Field(
-        None, description='Multiplier for time limit.'
+        default=None, description='Multiplier for time limit.'
     )
     time: Optional[int] = Field(
-        None, description='Value to override time limit with, in milliseconds.'
+        default=None, description='Value to override time limit with, in milliseconds.'
     )
     memory: Optional[int] = Field(
-        None, description='Value to override memory limit with, in MB.'
+        default=None, description='Value to override memory limit with, in MB.'
     )
 
 
@@ -332,28 +338,30 @@ class Package(BaseModel):
     memoryLimit: int = Field(description='Memory limit of the problem, in MB.')
 
     outputLimit: int = Field(
-        4 * 1024, description='Output limit of the problem, in KB.'
+        default=4 * 1024, description='Output limit of the problem, in KB.'
     )
 
     modifiers: Dict[str, LimitModifiers] = Field(
-        {},
+        default={},
         description="""
     Limit modifiers that can be specified per language.
     """,
     )
 
     checker: Optional[CodeItem] = Field(
-        None, description='The checker for this problem.'
+        default=None, description='The checker for this problem.'
     )
 
     validator: Optional[CodeItem] = Field(
-        None, description='The validator for this problem.'
+        default=None, description='The validator for this problem.'
     )
 
-    generators: List[Generator] = Field([], description='Generators for this problem.')
+    generators: List[Generator] = Field(
+        default=[], description='Generators for this problem.'
+    )
 
     solutions: List[Solution] = Field(
-        [],
+        default=[],
         description="""
 All tested solutions for this problem.
 
@@ -362,17 +370,23 @@ that is correct and used as reference -- and should have the `accepted` outcome.
 """,
     )
 
-    testcases: List[TestcaseGroup] = Field([], description='Testcases for the problem.')
+    testcases: List[TestcaseGroup] = Field(
+        default=[], description='Testcases for the problem.'
+    )
 
-    stresses: List[Stress] = Field([], description='Stress tests for the problem.')
+    stresses: List[Stress] = Field(
+        default=[], description='Stress tests for the problem.'
+    )
 
-    statements: List[Statement] = Field([], description='Statements for the problem.')
+    statements: List[Statement] = Field(
+        default=[], description='Statements for the problem.'
+    )
 
     # Vars to be re-used across the package.
     #   - It will be passed as --key=value arguments to the validator.
     #   - It will be available as \VAR{key} variables in the rbx statement.
     vars: Dict[str, Primitive] = Field(
-        {}, description='Variables to be re-used across the package.'
+        default={}, description='Variables to be re-used across the package.'
     )
 
     @property
@@ -403,12 +417,15 @@ that is correct and used as reference -- and should have the `accepted` outcome.
         return res
 
     @model_validator(mode='after')
-    def check_first_solution_is_main(self):
+    def check_first_solution_is_main_if_there_is_ac(self):
+        if all(sol.outcome != Outcome.ACCEPTED for sol in self.solutions):
+            # No main solution.
+            return self
         if self.solutions:
             if self.solutions[0].outcome != ExpectedOutcome.ACCEPTED:
                 raise PydanticCustomError(
                     'MISSING_MAIN_SOLUTION',
-                    'The first solution in the package must have the "ACCEPTED" outcome.',
+                    'The first solution in the package must have the "ACCEPTED" outcome if there are ACCEPTED solutions.',
                 )
         return self
 

rbx/box/setter_config.py

@@ -19,36 +19,36 @@ _CONFIG_FILE_NAME_MAC = 'default_setter_config.mac.yml'
 
 class SanitizersConfig(BaseModel):
     enabled: bool = Field(
-        False,
+        default=False,
         description='Whether to use sanitizers when running solutions.',
     )
 
     command_substitutions: Dict[str, str] = Field(
-        {},
+        default={},
         description='Substitutions to apply to commands before running them with sanitizers.',
     )
 
 
 class WarningsConfig(BaseModel):
     enabled: bool = Field(
-        False,
+        default=False,
         description='Whether to use warning flags when running solutions.',
     )
 
 
 class RepeatsConfig(BaseModel):
     reps: int = Field(
-        1,
+        default=1,
         description='Number of times to repeat the solution.',
     )
 
     retries: int = Field(
-        0,
+        default=0,
         description='Number of times to retry if the solution TLs.',
     )
 
     retries_for_stress: int = Field(
-        0,
+        default=0,
         description='Number of times to retry in stress mode if the solution TLs.',
     )
 
@@ -69,7 +69,7 @@ class SetterConfig(BaseModel):
     )
 
     command_substitutions: Dict[str, str] = Field(
-        {},
+        default={},
         description='Substitutions to apply to commands before running them.',
     )
 

rbx/box/solutions.py

@@ -16,7 +16,7 @@ import rich.text
 import typer
 from pydantic import BaseModel
 
-from rbx import console
+from rbx import console, utils
 from rbx.box import checkers, package
 from rbx.box.code import SanitizationLevel, compile_item, find_language_name, run_item
 from rbx.box.deferred import Deferred
@@ -25,7 +25,14 @@ from rbx.box.environment import (
     ExecutionConfig,
     VerificationLevel,
 )
-from rbx.box.generators import generate_output_for_testcase, generate_standalone
+from rbx.box.formatting import get_formatted_memory, get_formatted_time
+from rbx.box.generators import (
+    GenerationMetadata,
+    expand_generator_call,
+    extract_generation_testcases,
+    generate_output_for_testcase,
+    generate_standalone,
+)
 from rbx.box.retries import Retrier
 from rbx.box.schema import (
     ExpectedOutcome,
@@ -35,7 +42,7 @@ from rbx.box.schema import (
     Testcase,
     TestcaseGroup,
 )
-from rbx.box.testcases import find_built_testcases
+from rbx.box.testcases import TestcaseEntry, find_built_testcases
 from rbx.grading.steps import (
     DigestOrDest,
     DigestOrSource,
@@ -419,26 +426,97 @@ def run_solutions(
     )
 
 
-def _run_interactive_solutions(
+async def _generate_testcase_interactively(
     progress: Optional[StatusProgress] = None,
-    tracked_solutions: Optional[Set[str]] = None,
-    verification: VerificationLevel = VerificationLevel.NONE,
     generator: Optional[GeneratorCall] = None,
+    testcase_entry: Optional[TestcaseEntry] = None,
     check: bool = True,
-    print: bool = False,
     sanitized: bool = False,
-) -> Iterator[EvaluationItem]:
-    pkg = package.find_problem_package_or_die()
+    print: bool = False,
+) -> Testcase:
     main_solution = package.get_main_solution()
-    check = check and main_solution is not None
-
-    checker_digest = checkers.compile_checker() if check else None
-    compiled_solutions = compile_solutions(
-        progress=progress, tracked_solutions=tracked_solutions, sanitized=sanitized
+    irun_dir = package.get_problem_iruns_dir()
+    inputs_dir = irun_dir / 'inputs'
+    inputs_dir.mkdir(parents=True, exist_ok=True)
+    testcase = Testcase(
+        inputPath=inputs_dir / '000.in',
+        outputPath=(inputs_dir / '000.out') if check else None,
     )
 
+    is_manual = False
+    generation_metadata = None
+    if generator is not None:
+        generation_metadata = GenerationMetadata(
+            generator_call=expand_generator_call(generator),
+            copied_to=testcase,
+        )
+    elif testcase_entry is not None:
+        extracted = extract_generation_testcases([testcase_entry])
+        if not extracted:
+            console.console.print(
+                f'[error]Failed searching for testcase [item]{testcase_entry}[/item].[/error]'
+            )
+            raise typer.Exit(1)
+        generation_metadata = extracted[0].metadata
+        # Replace destination with the irun testcase we're using.
+        generation_metadata.copied_to = testcase
+    else:
+        with utils.no_progress(progress):
+            input = console.multiline_prompt('Testcase input')
+        testcase.inputPath.write_text(input)
+        console.console.print()
+
+        if (
+            testcase.outputPath is not None
+            and not testcase.outputPath.is_file()
+            and main_solution is None
+        ):
+            with utils.no_progress(progress):
+                output = console.multiline_prompt('Testcase output')
+                testcase.outputPath.write_text(output)
+                console.console.print()
+
+        generation_metadata = GenerationMetadata(
+            copied_to=testcase,
+        )
+        is_manual = True
+
+    # 1. Generate testcase.
+    if generation_metadata is not None:
+        generate_standalone(
+            generation_metadata,
+            progress=progress,
+            validate=True,
+        )
+        if testcase_entry is not None:
+            console.console.print(
+                f'Using input from testcase [item]{testcase_entry}[/item].'
+            )
+        elif generation_metadata.generator_call is not None:
+            console.console.print(
+                f'Using input from generator call [item]{generation_metadata.generator_call.name} {generation_metadata.generator_call.args}[/item].'
+            )
+        if print and not is_manual:
+            console.console.print(testcase.inputPath.read_text())
+        else:
+            console.console.print(
+                f'Input was written to [item]{testcase.inputPath.resolve()}[/item]'
+            )
+        console.console.print()
+
+    # 2. Generate test output from reference
     main_solution_digest = None
-    if check and main_solution is not None:
+    if check and not (
+        testcase.outputPath is not None and testcase.outputPath.is_file()
+    ):
+        if main_solution is None:
+            console.console.print(
+                '[error]Checking is enabled but no main solution or custom output was specified.[/error]'
+            )
+            raise typer.Exit(1)
+
+        if progress:
+            progress.update('Compiling main solution...')
         try:
             main_solution_digest = compile_item(
                 main_solution,
@@ -452,6 +530,42 @@ def _run_interactive_solutions(
             )
             raise
 
+    if main_solution_digest is not None:
+        if progress:
+            progress.update('Generating output for test...')
+        # TODO: Add stderr path
+        generate_output_for_testcase(main_solution_digest, testcase)
+
+    if check and testcase.outputPath is not None and not testcase.outputPath.is_file():
+        # Output was not created, throw an error.
+        console.console.print(
+            '[error]Checking is enabled but no output could be generated for this testcase.[/error]'
+        )
+        console.console.print(
+            '[error]Either specify it explicitly or provide a main solution.[/error]'
+        )
+        raise typer.Exit(1)
+
+    return testcase
+
+
+def _run_interactive_solutions(
+    testcase: Testcase,
+    progress: Optional[StatusProgress] = None,
+    tracked_solutions: Optional[Set[str]] = None,
+    verification: VerificationLevel = VerificationLevel.NONE,
+    check: bool = True,
+    sanitized: bool = False,
+) -> Iterator[EvaluationItem]:
+    pkg = package.find_problem_package_or_die()
+
+    if check and progress:
+        progress.update('Compiling checker...')
+    checker_digest = checkers.compile_checker() if check else None
+    compiled_solutions = compile_solutions(
+        progress=progress, tracked_solutions=tracked_solutions, sanitized=sanitized
+    )
+
     solutions = list(enumerate(pkg.solutions))
     if tracked_solutions is not None:
         solutions = [
@@ -459,33 +573,9 @@ def _run_interactive_solutions(
         ]
 
     irun_dir = package.get_problem_iruns_dir()
-    shutil.rmtree(str(irun_dir), ignore_errors=True)
-    irun_dir.mkdir(parents=True, exist_ok=True)
-    inputs_dir = irun_dir / 'inputs'
-    inputs_dir.mkdir(parents=True, exist_ok=True)
-    input_path = inputs_dir / '000.in'
-    output_path = input_path.with_suffix('.out')
 
-    if generator is not None:
-        expanded_call = generate_standalone(generator, input_path)
-        console.console.print(
-            f'Using input from generator call [item]{expanded_call.name} {expanded_call.args}[/item].'
-        )
-        if print:
-            console.console.print(input_path.read_text())
-        else:
-            console.console.print(
-                f'Input was written to [item]{input_path.resolve()}[/item]'
-            )
-        console.console.print()
-    else:
-        input = console.multiline_prompt('Testcase input')
-        input_path.write_text(input)
-    testcase = Testcase(inputPath=input_path, outputPath=output_path if check else None)
-
-    if main_solution_digest is not None:
-        # TODO: Add stderr path
-        generate_output_for_testcase(main_solution_digest, testcase)
+    if progress:
+        progress.update('Running solutions...')
 
     for i, solution in solutions:
         output_dir = irun_dir / f'{i}'
@@ -513,27 +603,38 @@ async def run_and_print_interactive_solutions(
     tracked_solutions: Optional[Set[str]] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
     generator: Optional[GeneratorCall] = None,
+    testcase_entry: Optional[TestcaseEntry] = None,
     check: bool = True,
     print: bool = False,
     sanitized: bool = False,
 ):
+    # Ensure path is new.
+    irun_dir = package.get_problem_iruns_dir()
+    shutil.rmtree(str(irun_dir), ignore_errors=True)
+    irun_dir.mkdir(parents=True, exist_ok=True)
+
     pkg = package.find_problem_package_or_die()
+    testcase = await _generate_testcase_interactively(
+        progress=progress,
+        generator=generator,
+        testcase_entry=testcase_entry,
+        check=check,
+        sanitized=sanitized,
+        print=print,
+    )
     items = _run_interactive_solutions(
+        testcase,
         progress=progress,
         tracked_solutions=tracked_solutions,
         verification=verification,
         check=check,
-        generator=generator,
         sanitized=sanitized,
-        print=print,
     )
 
-    if progress:
-        progress.stop()
-
     for item in items:
         sol = pkg.solutions[item.solution_index]
-        _print_solution_header(sol, console.console, is_irun=True)
+        with utils.no_progress(progress):
+            _print_solution_header(sol, console.console, is_irun=True)
 
         eval = await item.eval()
 
@@ -557,7 +658,7 @@ async def run_and_print_interactive_solutions(
 
 
 def _get_solution_repr(sol: Solution) -> List[Tuple[str, str]]:
-    fg_color = sol.outcome.style().replace('lnumber', 'cyan')
+    fg_color = sol.outcome.style()
     return [
         ('', f'{str(sol.path)} '),
         (f'fg:{fg_color}', sol.outcome.name),
@@ -590,9 +691,9 @@ def get_outcome_style_verdict(outcome: Outcome) -> str:
     if outcome == Outcome.TIME_LIMIT_EXCEEDED:
         return 'yellow'
     if outcome == Outcome.RUNTIME_ERROR:
-        return 'lnumber'
+        return 'blue'
     if outcome == Outcome.MEMORY_LIMIT_EXCEEDED:
-        return 'cyan'
+        return 'yellow'
     return 'magenta'
 
 
@@ -629,10 +730,6 @@ def _get_evals_memory_in_bytes(evals: List[Evaluation]) -> int:
     return max(int(eval.log.memory or 0) for eval in evals)
 
 
-def get_formatted_time(time_in_ms: int) -> str:
-    return f'{time_in_ms} ms'
-
-
 def get_evals_formatted_time(evals: List[Evaluation]) -> str:
     max_time = _get_evals_time_in_ms(evals)
     return get_formatted_time(max_time)
@@ -665,14 +762,6 @@ def get_capped_evals_formatted_time(
     return f'{max_time} ms'
 
 
-def get_formatted_memory(memory_in_bytes: int) -> str:
-    if memory_in_bytes < 1024 * 1024:
-        if memory_in_bytes < 1024:
-            return f'{memory_in_bytes} B'
-        return f'{memory_in_bytes // 1024} KiB'
-    return f'{memory_in_bytes // (1024 * 1024)} MiB'
-
-
 def get_evals_formatted_memory(evals: List[Evaluation]) -> str:
     max_memory = _get_evals_memory_in_bytes(evals)
     return get_formatted_memory(max_memory)

rbx/box/state.py

@@ -0,0 +1,9 @@
+import dataclasses
+
+
+@dataclasses.dataclass
+class State:
+    run_through_cli: bool = False
+
+
+STATE = State()