rbx.cp 0.5.11__tar.gz → 0.5.13__tar.gz

{rbx_cp-0.5.11 → rbx_cp-0.5.13}/PKG-INFO

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

{rbx_cp-0.5.11 → rbx_cp-0.5.13}/pyproject.toml

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

{rbx_cp-0.5.11 → rbx_cp-0.5.13}/rbx/box/builder.py

@@ -9,14 +9,23 @@ from rbx.box.solutions import (
     print_run_report,
     run_solutions,
 )
-from rbx.box.validators import print_validation_report, validate_testcases
+from rbx.box.validators import (
+    has_validation_errors,
+    print_validation_report,
+    validate_testcases,
+)
 
 
 def build(
     verification: environment.VerificationParam,
     groups: Optional[Set[str]] = None,
-    output: bool = True,
-) -> None:
+    output: Optional[bool] = True,
+) -> bool:
+    no_main_solution_report = False
+    if output is None:
+        output = package.get_main_solution() is not None
+        no_main_solution_report = not output
+
     with utils.StatusProgress(
         'Building testcases...',
         'Built [item]{processed}[/item] testcases...',
@@ -24,6 +33,28 @@ def build(
     ) as s:
         generate_testcases(s, groups=groups)
 
+    if verification > 0:
+        validator = package.get_validator_or_nil()
+        if validator is None:
+            console.console.print(
+                '[warning]No validator found, skipping validation.[/warning]'
+            )
+
+        if validator is not None:
+            with utils.StatusProgress(
+                'Validating testcases...',
+                'Validated [item]{processed}[/item] testcases...',
+                keep=True,
+            ) as s:
+                infos = validate_testcases(s, groups=groups)
+                print_validation_report(infos)
+
+        if has_validation_errors(infos):
+            console.console.print(
+                '[error]Validation failed, check the report above.[/error]'
+            )
+            return False
+
     with utils.StatusProgress(
         'Building outputs for testcases...',
         'Built [item]{processed}[/item] outputs...',
@@ -32,23 +63,22 @@ def build(
         if output:
             generate_outputs_for_testcases(s, groups=groups)
 
-    if verification > 0:
-        with utils.StatusProgress(
-            'Validating testcases...',
-            'Validated [item]{processed}[/item] testcases...',
-            keep=True,
-        ) as s:
-            infos = validate_testcases(s, groups=groups)
-            print_validation_report(infos)
-
     console.console.print(
         '[success]Problem built.[/success] '
         '[warning]Check the output for verification errors![/warning]'
     )
 
+    if no_main_solution_report:
+        console.console.print(
+            '[warning]No main solution found, skipping generating samples for the statement.[/warning]'
+        )
+
+    return True
+
 
 def verify(verification: environment.VerificationParam) -> bool:
-    build(verification=verification)
+    if not build(verification=verification):
+        return False
 
     if verification < VerificationLevel.FAST_SOLUTIONS.value:
         return True

{rbx_cp-0.5.11 → rbx_cp-0.5.13}/rbx/box/cd.py

@@ -3,9 +3,8 @@ import pathlib
 from typing import Optional
 
 import typer
-from rich import console
 
-from rbx import utils
+from rbx import console, utils
 
 
 def find_package(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Path]:

{rbx_cp-0.5.11 → rbx_cp-0.5.13}/rbx/box/checkers.py

@@ -119,6 +119,31 @@ def check(
     )
     message = package.get_digest_as_string(error.value or '') or ''
 
+    if (
+        checker_run_log is not None
+        and checker_run_log.exitcode != 0
+        and (
+            checker_run_log.exitstatus != SandboxBase.EXIT_NONZERO_RETURN
+            or checker_run_log.exitcode not in [0, 1, 2, 3]
+        )
+    ):
+        console.console.print(
+            f'[error]Checker [item]{package.get_checker().path}[/item] failed unexpectedly.[/error]'
+        )
+        console.console.print(
+            f'[error]Summary:[/error] {checker_run_log.get_summary()}'
+        )
+        console.console.print(
+            f'[error]Testcase input:[/error] [item]{testcase.inputPath}[/item]'
+        )
+        console.console.print(
+            f'[error]Testcase output:[/error] [item]{testcase.outputPath}[/item]'
+        )
+        console.console.print(
+            f'[error]Program output:[/error] [item]{program_output}[/item]'
+        )
+        raise typer.Exit(1)
+
     if checker_run_log is None or checker_run_log.exitcode not in [0, 1, 2, 3]:
         return CheckerResult(outcome=Outcome.INTERNAL_ERROR)
 

{rbx_cp-0.5.11 → rbx_cp-0.5.13}/rbx/box/compile.py

@@ -22,35 +22,29 @@ def _compile(item: CodeItem):
     out_path.chmod(0o755)
 
     console.console.print(
-        f'[success]Compiled file written at [item]{out_path}[/item].[/success]'
+        f'[success]Compiled file written at [item]{out_path}[/item][/success]'
     )
 
 
-@app.command('any, a', help='Compile an asset given its path.')
-@package.within_problem
 def any(path: str):
-    _compile(CodeItem(path=pathlib.Path(path)))
-
-
-@app.command('solution, s', help='Compile a solution given its path.')
-@package.within_problem
-def solution(path: str):
-    _compile(package.get_solution(path))
+    pkg = package.find_problem_package_or_die()
 
+    solution = package.get_solution_or_nil(path)
+    if solution is not None:
+        _compile(solution)
+        return
 
-@app.command('generator, gen, g', help='Compile a generator given its name.')
-@package.within_problem
-def generator(name: str):
-    _compile(package.get_generator(name))
+    for generator in pkg.generators:
+        if generator.path == pathlib.Path(path) or generator.name == path:
+            _compile(generator)
+            return
 
+    if pkg.checker is not None and pkg.checker.path == pathlib.Path(path):
+        _compile(pkg.checker)
+        return
 
-@app.command('checker, c', help='Compile the checker.')
-@package.within_problem
-def checker():
-    _compile(package.get_checker())
+    if pkg.validator is not None and pkg.validator.path == pathlib.Path(path):
+        _compile(pkg.validator)
+        return
 
-
-@app.command('validator, v', help='Compile the main validator.')
-@package.within_problem
-def validator():
-    _compile(package.get_validator())
+    _compile(CodeItem(path=pathlib.Path(path)))

{rbx_cp-0.5.11 → rbx_cp-0.5.13}/rbx/box/contest/contest_package.py

@@ -3,6 +3,7 @@ import pathlib
 from typing import List, Optional
 
 import typer
+from pydantic import ValidationError
 
 from rbx import console, utils
 from rbx.box.contest.schema import Contest
@@ -30,7 +31,12 @@ def find_contest_package(root: pathlib.Path = pathlib.Path()) -> Optional[Contes
     contest_yaml_path = find_contest_yaml(root)
     if not contest_yaml_path:
         return None
-    return utils.model_from_yaml(Contest, contest_yaml_path.read_text())
+    try:
+        return utils.model_from_yaml(Contest, contest_yaml_path.read_text())
+    except ValidationError as e:
+        console.console.print(e)
+        console.console.print('[error]Error parsing contest.rbx.yml.[/error]')
+        raise typer.Exit(1) from e
 
 
 def find_contest_package_or_die(root: pathlib.Path = pathlib.Path()) -> Contest:

{rbx_cp-0.5.11 → rbx_cp-0.5.13}/rbx/box/contest/main.py

@@ -160,6 +160,32 @@ def add(path: str, short_name: str, preset: Optional[str] = None):
     )
 
 
+@app.command('remove, r', help='Remove problem from contest.')
+@within_contest
+def remove(path_or_short_name: str):
+    contest = find_contest_package_or_die()
+
+    kept_problems = []
+    removed_problems = []
+    for problem in contest.problems:
+        if (
+            problem.path == pathlib.Path(path_or_short_name)
+            or problem.short_name == path_or_short_name
+        ):
+            removed_problems.append(problem)
+        else:
+            kept_problems.append(problem)
+
+    contest.problems = kept_problems
+    save_contest(contest)
+
+    for problem in removed_problems:
+        shutil.rmtree(str(problem.path), ignore_errors=True)
+        console.console.print(
+            f'Problem [item]{problem.short_name}[/item] removed from contest at [item]{problem.path}[/item].'
+        )
+
+
 @app.command(
     'each',
     help='Run a command for each problem in the contest.',

{rbx_cp-0.5.11 → rbx_cp-0.5.13}/rbx/box/contest/statements.py

@@ -51,7 +51,14 @@ def build(
             )
             with utils.new_cd(problem.get_path()):
                 contest_utils.clear_package_cache()
-                builder.build(verification=verification, groups=set(['samples']))
+
+                if not builder.build(
+                    verification=verification, groups=set(['samples']), output=None
+                ):
+                    console.console.print(
+                        '[error]Failed to build statements with samples, aborting.[/error]'
+                    )
+                    raise typer.Exit(1)
 
     contest = find_contest_package_or_die()
     candidate_languages = languages

{rbx_cp-0.5.11 → rbx_cp-0.5.13}/rbx/box/environment.py

@@ -4,7 +4,7 @@ from enum import Enum
 from typing import Annotated, List, Optional, Type, TypeVar
 
 import typer
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, ValidationError
 
 from rbx import config, console, utils
 from rbx.box.extensions import Extensions, LanguageExtensions
@@ -19,9 +19,8 @@ class VerificationLevel(Enum):
     NONE = 0
     VALIDATE = 1
     FAST_SOLUTIONS = 2
-    ASAN = 3
-    ALL_SOLUTIONS = 4
-    FULL = 5
+    ALL_SOLUTIONS = 3
+    FULL = 4
 
 
 VerificationParam = Annotated[
@@ -31,7 +30,7 @@ VerificationParam = Annotated[
         '--verification',
         '-v',
         help='Verification level to use when building package.',
-        default_factory=lambda: VerificationLevel.ALL_SOLUTIONS.value,
+        default_factory=lambda: VerificationLevel.FULL.value,
     ),
 ]
 
@@ -193,7 +192,14 @@ def get_environment(env: Optional[str] = None) -> Environment:
             f'Environment file [item]{env_path}[/item] not found.', style='error'
         )
         raise typer.Exit()
-    return utils.model_from_yaml(Environment, env_path.read_text())
+    try:
+        return utils.model_from_yaml(Environment, env_path.read_text())
+    except ValidationError as e:
+        console.console.print(e)
+        console.console.print(
+            f'[error]Error parsing environment file [item]{env_path}[/item].[/error]'
+        )
+        raise typer.Exit(1) from e
 
 
 @functools.cache

{rbx_cp-0.5.11 → rbx_cp-0.5.13}/rbx/box/generators.py

@@ -82,6 +82,8 @@ def _run_generator(
         console.console.print(
             f'[error]Failed generating test {i} from group path {group_path}[/error]',
         )
+        if run_log is not None:
+            console.console.print(f'[error]Summary:[/error] {run_log.get_summary()}')
         if generation_stderr.value is not None:
             console.console.print('[error]Stderr:[/error]')
             console.console.print(
@@ -142,9 +144,7 @@ def generate_output_for_testcase(
             f'[error]Failed generating output for [item]{testcase.inputPath}[/item][/error]',
         )
         if run_log is not None:
-            console.console.print(
-                f'[error]Main solution exited with code [item]{-run_log.exitcode}[/item][/error]',
-            )
+            console.console.print(f'[error]Summary:[/error] {run_log.get_summary()}')
             checker_result = checkers.check_with_no_output(run_log)
             console.console.print(
                 f'[warning]Time: [item]{run_log.time:.2f}s[/item][/warning]',
@@ -238,7 +238,7 @@ def _run_generator_script(testcase: TestcaseSubgroup, cacher: FileCacher) -> str
             )
             if run_log is not None:
                 console.console.print(
-                    f'[error]Script exited with code [item]{-run_log.exitcode}[/item][/error]',
+                    f'[error]Summary:[/error] {run_log.get_summary()}'
                 )
             if run_stderr.value is not None:
                 console.console.print('[error]Stderr:[/error]')
@@ -341,6 +341,10 @@ def generate_standalone(
         console.console.print(
             f'[error]Failed generating test using generator call [info]{call.name} {expanded_args_str}[/info].[/error]',
         )
+        if generation_log is not None:
+            console.console.print(
+                f'[error]Summary:[/error] {generation_log.get_summary()}'
+            )
         if generation_stderr.value is not None:
             console.console.print('[error]Stderr:[/error]')
             console.console.print(

{rbx_cp-0.5.11 → rbx_cp-0.5.13}/rbx/box/main.py

@@ -3,11 +3,12 @@ from gevent import monkey
 
 monkey.patch_all()
 
+import tempfile
 import shlex
 import sys
 import typing
 
-from rbx.box.schema import CodeItem, ExpectedOutcome
+from rbx.box.schema import CodeItem, ExpectedOutcome, TestcaseGroup
 
 
 import pathlib
@@ -31,6 +32,7 @@ from rbx.box import (
     compile,
     presets,
     stresses,
+    validators,
 )
 from rbx.box.contest import main as contest
 from rbx.box.environment import VerificationLevel, get_environment_path
@@ -69,9 +71,6 @@ app.add_typer(
 app.add_typer(
     contest.app, name='contest', cls=annotations.AliasGroup, help='Contest management.'
 )
-app.add_typer(
-    compile.app, name='compile', cls=annotations.AliasGroup, help='Compile assets.'
-)
 
 
 @app.command('ui', hidden=True)
@@ -96,13 +95,6 @@ def build(verification: environment.VerificationParam):
     builder.build(verification=verification)
 
 
-@app.command('verify, v', help='Build and verify all the tests for the problem.')
-@package.within_problem
-def verify(verification: environment.VerificationParam):
-    if not builder.verify(verification=verification):
-        console.console.print('[error]Verification failed, check the report.[/error]')
-
-
 @app.command('run, r', help='Build and run solution(s).')
 @package.within_problem
 def run(
@@ -139,7 +131,14 @@ def run(
         )
         check = False
 
-    builder.build(verification=verification, output=check)
+    if not builder.build(verification=verification, output=check):
+        return
+
+    if verification <= VerificationLevel.VALIDATE.value:
+        console.console.print(
+            '[warning]Verification level is set to [item]validate (-v1)[/item], so rbx only build tests and validated them.[/warning]'
+        )
+        return
 
     with utils.StatusProgress('Running solutions...') as s:
         tracked_solutions = None
@@ -206,6 +205,12 @@ def irun(
         console.console.print(
             '[warning]Outputs will be written to files. If you wish to print them to the terminal, use the "-p" parameter.'
         )
+    if verification < VerificationLevel.ALL_SOLUTIONS.value:
+        console.console.print(
+            '[warning]Verification level should be at least [item]all solutions (-v4)[/item] to run solutions interactively.'
+        )
+        return
+
     main_solution = package.get_main_solution()
     if check and main_solution is None:
         console.console.print(
@@ -248,7 +253,13 @@ def create(
 @app.command('stress', help='Run a stress test.')
 @package.within_problem
 def stress(
-    name: str,
+    name: Annotated[
+        str,
+        typer.Argument(
+            help='Name of the stress test to run (specified in problem.rbx.yml), '
+            'or the generator to run, in case -g is specified.'
+        ),
+    ],
     generator_args: Annotated[
         Optional[str],
         typer.Option(
@@ -325,9 +336,27 @@ def stress(
 
         testgroup = questionary.select(
             'Choose the testgroup to add the tests to.\nOnly test groups that have a .txt generatorScript are shown below: ',
-            choices=list(groups_by_name) + ['(skip)'],
+            choices=list(groups_by_name) + ['(create new script)', '(skip)'],
         ).ask()
 
+        if testgroup == '(create new script)':
+            new_script_name = questionary.text(
+                'Enter the name of the new .txt generatorScript file: '
+            ).ask()
+            new_script_path = pathlib.Path(new_script_name).with_suffix('.txt')
+            new_script_path.parent.mkdir(parents=True, exist_ok=True)
+            new_script_path.touch()
+
+            # Temporarily create a new testgroup with the new script.
+            testgroup = new_script_path.stem
+            groups_by_name[testgroup] = TestcaseGroup(
+                name=testgroup, generatorScript=CodeItem(path=new_script_path)
+            )
+            console.console.print(
+                f'[warning]A testgroup for [item]{new_script_path}[/item] will not be automatically added to the problem.rbx.yml file for you.\n'
+                'Please add it manually. [/warning]'
+            )
+
         if testgroup not in groups_by_name:
             break
         try:
@@ -355,6 +384,47 @@ def stress(
         break
 
 
+@app.command('compile', help='Compile an asset given its path.')
+@package.within_problem
+def compile_command(
+    path: Annotated[str, typer.Argument(help='Path to the asset to compile.')],
+):
+    compile.any(path)
+
+
+@app.command('validate', help='Run the validator in a one-off fashion, interactively.')
+@package.within_problem
+def validate(
+    path: Annotated[
+        Optional[str],
+        typer.Option('--path', '-p', help='Path to the testcase to validate.'),
+    ] = None,
+):
+    validator_tuple = validators.compile_main_validator()
+    if validator_tuple is None:
+        console.console.print('[error]No validator found for this problem.[/error]')
+        raise typer.Exit(1)
+
+    validator, validator_digest = validator_tuple
+
+    input = console.multiline_prompt('Testcase input')
+
+    if path is None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmppath = pathlib.Path(tmpdir) / '000.in'
+            tmppath.write_text(input)
+
+            info = validators.validate_one_off(
+                pathlib.Path(tmppath), validator, validator_digest
+            )
+    else:
+        info = validators.validate_one_off(
+            pathlib.Path(path), validator, validator_digest
+        )
+
+    validators.print_validation_report([info])
+
+
 @app.command('environment, env', help='Set or show the current box environment.')
 def environment_command(
     env: Annotated[Optional[str], typer.Argument()] = None,
@@ -417,10 +487,17 @@ def activate():
             console.console.print(
                 '[error]Preset is not installed. Install it manually, or specify a URI in [item].preset-lock.yml[/item].[/error]'
             )
-            raise
+            raise typer.Exit(1)
         presets.install(preset_lock.uri)
 
     preset = presets.get_installed_preset(preset_lock.preset_name)
+
+    # Install the environment from the preset if it's not already installed.
+    presets.optionally_install_environment_from_preset(
+        preset, root=presets.get_preset_installation_path(preset_lock.name)
+    )
+
+    # Activate the environment.
     if preset.env is not None:
         environment_command(preset.name)
 

{rbx_cp-0.5.11 → rbx_cp-0.5.13}/rbx/box/package.py

@@ -3,6 +3,7 @@ import pathlib
 from typing import Dict, List, Optional, Tuple
 
 import typer
+from pydantic import ValidationError
 
 from rbx import config, console, utils
 from rbx.box import environment
@@ -74,7 +75,12 @@ def find_problem_package(root: pathlib.Path = pathlib.Path()) -> Optional[Packag
     problem_yaml_path = find_problem_yaml(root)
     if not problem_yaml_path:
         return None
-    return utils.model_from_yaml(Package, problem_yaml_path.read_text())
+    try:
+        return utils.model_from_yaml(Package, problem_yaml_path.read_text())
+    except ValidationError as e:
+        console.console.print(e)
+        console.console.print('[error]Error parsing problem.rbx.yml.[/error]')
+        raise typer.Exit(1) from e
 
 
 def find_problem_package_or_die(root: pathlib.Path = pathlib.Path()) -> Package:

{rbx_cp-0.5.11 → rbx_cp-0.5.13}/rbx/box/presets/__init__.py

@@ -294,6 +294,18 @@ def get_installed_preset(name: str, root: pathlib.Path = pathlib.Path()) -> Pres
     return preset
 
 
+def optionally_install_environment_from_preset(
+    preset: Preset, root: pathlib.Path = pathlib.Path()
+):
+    if preset.env is None:
+        return
+    env_path = get_environment_path(preset.name)
+    if env_path.is_file():
+        return
+    env_path.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copyfile(str(root / preset.env), env_path)
+
+
 def _install(root: pathlib.Path = pathlib.Path(), force: bool = False):
     preset = get_preset_yaml(root)
 

{rbx_cp-0.5.11 → rbx_cp-0.5.13}/rbx/box/solutions.py

@@ -378,6 +378,7 @@ def _run_interactive_solutions(
     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')
 
@@ -479,10 +480,14 @@ def get_testcase_markup_verdict(eval: Evaluation) -> str:
 
 
 def _get_evals_time_in_ms(evals: List[Evaluation]) -> int:
+    if not evals:
+        return 0
     return max(int((eval.log.time or 0.0) * 1000) for eval in evals)
 
 
 def _get_evals_memory_in_mb(evals: List[Evaluation]) -> int:
+    if not evals:
+        return 0
     return max(int(eval.log.memory or 0) // (1024 * 1024) for eval in evals)
 
 
@@ -504,6 +509,7 @@ def _print_solution_outcome(
 ) -> bool:
     pkg = package.find_problem_package_or_die()
 
+    has_plain_tle = False
     bad_verdicts = set()
     no_tle_bad_verdicts = set()
     for eval in evals:
@@ -514,6 +520,10 @@ def _print_solution_outcome(
             and eval.result.no_tle_outcome != Outcome.ACCEPTED
         ):
             no_tle_bad_verdicts.add(eval.result.no_tle_outcome)
+        has_plain_tle = has_plain_tle or (
+            eval.result.outcome == Outcome.TIME_LIMIT_EXCEEDED
+            and eval.result.no_tle_outcome is None
+        )
 
     unmatched_bad_verdicts = set(
         v for v in bad_verdicts if not solution.outcome.match(v)
@@ -542,16 +552,27 @@ def _print_solution_outcome(
         verification.value >= VerificationLevel.FULL.value
         # Solution expects a TLE.
         and expected_outcome_is_tle
-        # A TLE (or similar) has happened.
-        and matched_bad_verdicts
-        # The solution has no other bad verdicts except for TLEs in double TL.
-        and not ((bad_verdicts | no_tle_bad_verdicts) - {Outcome.TIME_LIMIT_EXCEEDED})
-        # The solution passes in double TL.
+        # Solution does not have a plain TLE.
+        and not has_plain_tle
+        # A TLE has happened.
+        and Outcome.TIME_LIMIT_EXCEEDED in matched_bad_verdicts
+        # The solution runs in double TL.
         and evals_time < pkg.timelimit_for_language(solution.language) * 2
     ):
-        console.print(
-            '[yellow]WARNING[/yellow] The solution still passed in double TL.'
-        )
+        other_verdicts = (bad_verdicts | no_tle_bad_verdicts) - {
+            Outcome.TIME_LIMIT_EXCEEDED
+        }
+        if not other_verdicts:
+            # The solution has no other bad verdicts except for TLEs in double TL.
+            console.print(
+                '[yellow]WARNING[/yellow] The solution still passed in double TL.'
+            )
+        elif not (bad_verdicts - {Outcome.TIME_LIMIT_EXCEEDED}):
+            # The solution has other bad soft TLE outcomes.
+            other_verdicts_names = ' '.join(v.name for v in other_verdicts)
+            console.print(
+                f'[yellow]WARNING[/yellow] The solution could still run under double TL, but failed with [item]{other_verdicts_names}[/item].'
+            )
     console.print(f'Time: {get_evals_formatted_time(evals)}')
     console.print(f'Memory: {get_evals_formatted_memory(evals)}')
     return len(unmatched_bad_verdicts) == 0
@@ -787,6 +808,9 @@ def print_run_report(
     print_last_solution()
 
     items.seek(0)
-    _print_timing(console, result.skeleton, list(structured_evaluations)[-1])
+    structured_evaluations_list = list(structured_evaluations)
+
+    if structured_evaluations_list:
+        _print_timing(console, result.skeleton, structured_evaluations_list[-1])
 
     return ok