rbx.cp 0.5.73__py3-none-any.whl → 0.6.1__py3-none-any.whl

rbx/box/presets/lock_schema.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import List
 
 from pydantic import BaseModel
 
@@ -11,7 +11,6 @@ class LockedAsset(TrackedAsset):
 
 class PresetLock(BaseModel):
     name: str
-    uri: Optional[str] = None
 
     @property
     def preset_name(self) -> str:

rbx/box/presets/schema.py

@@ -1,8 +1,10 @@
 import pathlib
 from typing import List, Optional
 
+import typer
 from pydantic import BaseModel, Field
 
+from rbx import console
 from rbx.box.presets.fetch import PresetFetchInfo, get_preset_fetch_info
 
 
@@ -32,8 +34,9 @@ class Preset(BaseModel):
     # Name of the preset, or a GitHub repository containing it.
     name: str = NameField()
 
-    # URI of the preset to be fetched.
-    uri: Optional[str] = None
+    # URI of the preset to be fetched. Uniquely identifies the preset.
+    # Should usually be a GitHub repository.
+    uri: str
 
     # Path to the environment file that will be installed with this preset.
     # When copied to the box environment, the environment will be named `name`.
@@ -52,8 +55,13 @@ class Preset(BaseModel):
 
     @property
     def fetch_info(self) -> PresetFetchInfo:
-        if self.uri is None:
-            return PresetFetchInfo(name=self.name)
         res = get_preset_fetch_info(self.uri)
-        assert res is not None
+        if res is None:
+            console.console.print(
+                f'[error]Preset URI [item]{self.uri}[/item] is not valid.[/error]'
+            )
+            console.console.print(
+                '[error]Please check that the URI is correct and that the directory/asset really exists.[/error]'
+            )
+            raise typer.Exit(1)
         return res

rbx/box/remote.py

@@ -52,14 +52,14 @@ class BocaExpander(Expander):
         return [str(self.get_boca_path(run_number, site_number)) + '.*']
 
     def expand(self, path: pathlib.Path) -> Optional[pathlib.Path]:
-        from rbx.box.packaging.boca import upload as boca_upload
+        from rbx.box.tooling.boca import scraper as boca_upload
 
         match = self.get_match(str(path))
         if match is None:
             return None
         run_number, site_number = match
 
-        boca_uploader = boca_upload.get_boca_uploader()
+        boca_uploader = boca_upload.get_boca_scraper()
         boca_uploader.login()
         sol_path = boca_uploader.download_run(
             run_number, site_number, self.get_boca_folder()

rbx/box/retries.py

@@ -90,6 +90,14 @@ def _move_logs_to_temp_dir(
     return recover
 
 
+def get_retrier_config(nruns: int = 0) -> RepeatsConfig:
+    if nruns == 0:
+        return get_setter_config().repeats
+    repeats = get_setter_config().repeats.model_copy(deep=True)
+    repeats.reps = nruns
+    return repeats
+
+
 class Retrier:
     def __init__(self, config: Optional[RepeatsConfig] = None, is_stress: bool = False):
         self.config = config or get_setter_config().repeats

rbx/box/schema.py

@@ -2,30 +2,21 @@ from __future__ import annotations
 
 import os
 import pathlib
-from typing import Dict, List, Optional, Union
+import re
+from typing import Annotated, Any, Dict, List, Optional, Union
 
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import AfterValidator, BaseModel, ConfigDict, Field, model_validator
 from pydantic_core import PydanticCustomError
 
 from rbx.autoenum import AutoEnum, alias
+from rbx.box.fields import FNameField, NameField
+from rbx.box.statements.expander import expand_statements
 from rbx.box.statements.schema import Statement
 from rbx.grading.steps import Outcome
 
 Primitive = Union[str, int, float, bool]
 
 
-def NameField(**kwargs):
-    return Field(
-        pattern=r'^[a-zA-Z0-9][a-zA-Z0-9\-_]*$', min_length=3, max_length=32, **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:
@@ -56,6 +47,44 @@ def expand_var(value: Primitive) -> Primitive:
     )
 
 
+def expand_vars(vars: Dict[str, Primitive]) -> Dict[str, Primitive]:
+    return {key: expand_var(value) for key, value in vars.items()}
+
+
+def _represents_int(s: str) -> bool:
+    return re.match(r'[-+]?\d+$', s.strip()) is not None
+
+
+def _represents_float(s: str) -> bool:
+    return re.match(r'[-+]?\d+\.\d+$', s.strip()) is not None
+
+
+def _represents_bool(s: str) -> bool:
+    return s.lower().strip() in ['true', 'false', 'True', 'False']
+
+
+def convert_to_primitive(value: Any) -> Primitive:
+    if _represents_int(value):
+        return int(value)
+    if _represents_float(value):
+        return float(value)
+    if _represents_bool(value):
+        return value.lower().strip() == 'true'
+    return str(value)
+
+
+def expand_any_vars(vars: Dict[str, Any]) -> Dict[str, Primitive]:
+    converted_vars = {key: convert_to_primitive(value) for key, value in vars.items()}
+    return expand_vars(converted_vars)
+
+
+def is_unique_by_name(statements: List['Statement']) -> List['Statement']:
+    names = {st.name for st in statements}
+    if len(names) != len(statements):
+        raise ValueError('Statement names must be unique.')
+    return statements
+
+
 class ExpectedOutcome(AutoEnum):
     ANY = alias('any')  # type: ignore
     """Expected outcome for any outcome."""
@@ -204,6 +233,17 @@ Testlib and jngen are already included by default.
     )
 
 
+class Interactor(CodeItem):
+    model_config = ConfigDict(extra='forbid')
+
+    legacy: bool = Field(
+        default=False,
+        description="""
+Whether this interactor is a legacy interactor and needs a checker to be specified.
+""",
+    )
+
+
 class Testcase(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
@@ -429,7 +469,7 @@ class Package(BaseModel):
         default=None, description='The checker for this problem.'
     )
 
-    interactor: Optional[CodeItem] = Field(
+    interactor: Optional[Interactor] = Field(
         default=None, description='The interactor for this problem.'
     )
 
@@ -459,9 +499,10 @@ that is correct and used as reference -- and should have the `accepted` outcome.
         default=[], description='Stress tests for the problem.'
     )
 
-    statements: List[Statement] = Field(
-        default=[], description='Statements for the problem.'
-    )
+    statements: Annotated[
+        List[Statement],
+        AfterValidator(is_unique_by_name),
+    ] = 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.
@@ -475,9 +516,13 @@ that is correct and used as reference -- and should have the `accepted` outcome.
         description='Unit tests for components of this problem.',
     )
 
+    @property
+    def expanded_statements(self) -> List[Statement]:
+        return expand_statements(self.statements)
+
     @property
     def expanded_vars(self) -> Dict[str, Primitive]:
-        return {key: expand_var(value) for key, value in self.vars.items()}
+        return expand_vars(self.vars)
 
     def timelimit_for_language(self, language: Optional[str]) -> int:
         res = self.timeLimit
@@ -525,3 +570,21 @@ that is correct and used as reference -- and should have the `accepted` outcome.
                     {'i': i + 1},
                 )
         return self
+
+    @model_validator(mode='after')
+    def check_checker_and_interactor_for_task_type(self):
+        if self.type == TaskType.BATCH:
+            if self.interactor is not None:
+                raise PydanticCustomError(
+                    'INTERACTOR_NOT_ALLOWED',
+                    'Interactor is not allowed for batch problems. Change the task type to COMMUNICATION.',
+                )
+        if self.type == TaskType.COMMUNICATION:
+            if self.checker is not None and (
+                self.interactor is None or not self.interactor.legacy
+            ):
+                raise PydanticCustomError(
+                    'CHECKER_NOT_ALLOWED',
+                    'Checkers should not be specified for communication problems.',
+                )
+        return self

rbx/box/solutions.py

@@ -48,6 +48,7 @@ from rbx.box.tasks import (
 from rbx.box.testcase_extractors import extract_generation_testcases
 from rbx.box.testcase_utils import (
     TestcaseEntry,
+    TestcaseInteractionParsingError,
     find_built_testcases,
     parse_interaction,
     print_interaction,
@@ -191,6 +192,7 @@ def _run_solution(
     progress: Optional[StatusProgress] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
     timelimit_override: Optional[int] = None,
+    nruns: int = 0,
 ) -> List[Deferred[Evaluation]]:
     group = package.get_testgroup(group_name)
     testcases = find_built_testcases(group)
@@ -216,6 +218,7 @@ def _run_solution(
                 testcase_index=i,
                 verification=verification,
                 timelimit_override=timelimit_override,
+                nruns=nruns,
             )
 
         res.append(Deferred(run_fn))
@@ -314,6 +317,7 @@ def _produce_solution_items(
     check: bool = True,
     timelimit_override: Optional[int] = None,
     sanitized: bool = False,
+    nruns: int = 0,
 ) -> List[EvaluationItem]:
     pkg = package.find_problem_package_or_die()
 
@@ -347,6 +351,7 @@ def _produce_solution_items(
                 progress=progress,
                 verification=verification,
                 timelimit_override=timelimit_override,
+                nruns=nruns,
             )
         ):
             res.append(
@@ -374,7 +379,11 @@ def print_best_output(output_files: List[pathlib.Path], empty_warning: bool = Fa
         if not output_file.is_file():
             continue
         if output_file.suffix == '.pio':
-            print_interaction(parse_interaction(output_file))
+            try:
+                print_interaction(parse_interaction(output_file))
+            except TestcaseInteractionParsingError:
+                # Ignore parsing errors and proceed to next file.
+                continue
         else:
             console.console.print(output_file.read_text())
         return
@@ -389,6 +398,7 @@ def run_solutions(
     check: bool = True,
     timelimit_override: Optional[int] = None,
     sanitized: bool = False,
+    nruns: int = 0,
 ) -> RunSolutionResult:
     skeleton = _get_report_skeleton(
         tracked_solutions,
@@ -404,6 +414,7 @@ def run_solutions(
             check=check,
             timelimit_override=timelimit_override,
             sanitized=sanitized,
+            nruns=nruns,
         ),
     )
     return result
@@ -679,7 +690,7 @@ async def run_and_print_interactive_solutions(
             console.console.print(get_testcase_markup_verdict(eval), end=' ')
             _print_solution_header(sol, console.console)
             _print_solution_outcome(
-                sol, [eval], console.console, verification, subset=True
+                sol, skeleton, [eval], console.console, verification, subset=True
             )
 
         stdout_path = eval.log.stdout_absolute_path
@@ -907,6 +918,7 @@ class SolutionOutcomeReport(BaseModel):
     solution: Solution
     evals: List[Evaluation]
     ok: bool
+    message: Optional[Tuple[TestcaseEntry, str]]
     expectedOutcome: Optional[ExpectedOutcome]
     gotVerdicts: Set[Outcome]
     runUnderDoubleTl: bool
@@ -944,15 +956,22 @@ class SolutionOutcomeReport(BaseModel):
             res += '\n[bold yellow]WARNING[/bold yellow] The solution had sanitizer errors or warnings, marked with [bold yellow]*[/bold yellow]. See their stderr for more details.'
         return res
 
-    def get_outcome_markup(self) -> str:
+    def get_outcome_markup(self, print_message: bool = True) -> str:
         res = self.get_verdict_markup_with_warnings()
         res += f'\nTime: {get_capped_evals_formatted_time(self.solution, self.evals, self.verification)}'
         res += f'\nMemory: {get_evals_formatted_memory(self.evals)}'
+        if print_message and self.message is not None:
+            tc, msg = self.message
+            if msg:
+                if len(msg) > 100:
+                    msg = msg[:100] + '... (truncated)'
+                res += f'\nMessage for {tc}: {msg}'
         return res
 
 
 def get_solution_outcome_report(
     solution: Solution,
+    skeleton: SolutionReportSkeleton,
     evals: List[Evaluation],
     verification: VerificationLevel = VerificationLevel.NONE,
     subset: bool = False,
@@ -964,7 +983,8 @@ def get_solution_outcome_report(
     bad_verdicts = set()
     no_tle_bad_verdicts = set()
     has_sanitizer_warnings = False
-    for eval in evals:
+    message: Optional[Tuple[TestcaseEntry, str]] = None
+    for eval, entry in zip(evals, skeleton.entries):
         all_verdicts.add(eval.result.outcome)
         if eval.result.outcome != Outcome.ACCEPTED:
             bad_verdicts.add(eval.result.outcome)
@@ -979,6 +999,16 @@ def get_solution_outcome_report(
         has_sanitizer_warnings = (
             has_sanitizer_warnings or eval.result.sanitizer_warnings
         )
+        if (
+            eval.result.outcome
+            in [
+                Outcome.WRONG_ANSWER,
+                Outcome.JUDGE_FAILED,
+            ]
+            and message is None
+        ):
+            message = (entry, eval.result.message)
+
     unmatched_bad_verdicts = set(
         v for v in bad_verdicts if not solution.outcome.match(v)
     )
@@ -1037,6 +1067,7 @@ def get_solution_outcome_report(
         solution=solution,
         evals=evals,
         ok=not has_failed,
+        message=message,
         expectedOutcome=report_expected_outcome,
         gotVerdicts=report_got_verdicts,
         runUnderDoubleTl=report_run_under_double_tl,
@@ -1048,13 +1079,17 @@ def get_solution_outcome_report(
 
 def _print_solution_outcome(
     solution: Solution,
+    skeleton: SolutionReportSkeleton,
     evals: List[Evaluation],
     console: rich.console.Console,
     verification: VerificationLevel = VerificationLevel.NONE,
     subset: bool = False,
+    print_message: bool = True,
 ) -> bool:
-    report = get_solution_outcome_report(solution, evals, verification, subset)
-    console.print(report.get_outcome_markup())
+    report = get_solution_outcome_report(
+        solution, skeleton, evals, verification, subset
+    )
+    console.print(report.get_outcome_markup(print_message))
     return report.ok
 
 
@@ -1338,6 +1373,7 @@ async def _print_detailed_run_report(
         _print_solution_header(solution, console)
         cur_ok = _print_solution_outcome(
             solution,
+            result.skeleton,
             all_evals,
             console,
             verification=verification,
@@ -1399,44 +1435,70 @@ async def print_run_report(
         )
 
     ok = True
+    single_solution = len(result.skeleton.solutions) == 1
 
     for solution in result.skeleton.solutions:
         _print_solution_header(solution, console)
+        if single_solution:
+            console.print()
         solution_evals = []
         for group in result.skeleton.groups:
-            console.print(f'[bold][status]{group.name}[/status][/bold] ', end='')
+            if not single_solution:
+                console.print(f'[bold][status]{group.name}[/status][/bold] ', end='')
             group_evals = []
             for i, _ in enumerate(group.testcases):
                 eval = structured_evaluations[str(solution.path)][group.name][i]
                 if eval is None:
                     continue
                 eval = await eval()
-                console.print(f'{i}/', end='')
-                console.print(get_testcase_markup_verdict(eval), end='')
-                if eval.result.sanitizer_warnings:
-                    console.print('[warning]*[/warning]', end='')
-                console.print('', end=' ')
+                if single_solution:
+                    console.print(get_testcase_markup_verdict(eval), end=' ')
+                    console.print(f'{group.name}/{i}', end='')
+                    if eval.result.sanitizer_warnings:
+                        console.print('[warning]*[/warning]', end='')
+                    time = get_capped_evals_formatted_time(
+                        solution, [eval], verification
+                    )
+                    memory = get_evals_formatted_memory([eval])
+                    console.print(f' ({time}, {memory})', end='')
+                    checker_msg = eval.result.message
+                    if checker_msg:
+                        console.print(f': [i]{checker_msg}[/i]', end='')
+                else:
+                    console.print(f'{i}/', end='')
+                    console.print(get_testcase_markup_verdict(eval), end='')
+                    if eval.result.sanitizer_warnings:
+                        console.print('[warning]*[/warning]', end='')
+
+                console.print('', end='\n' if single_solution else ' ')
                 group_evals.append(eval)
                 solution_evals.append(eval)
 
+            if single_solution:
+                console.print(f'  [status]{group.name}[/status]', end=' ')
             console.print(
                 f'({get_capped_evals_formatted_time(solution, group_evals, verification)}, {get_evals_formatted_memory(group_evals)})',
                 end='',
             )
             console.print()
+            if single_solution:
+                console.print()
 
         cur_ok = _print_solution_outcome(
             solution,
+            result.skeleton,
             solution_evals,
             console,
             verification=verification,
+            print_message=not single_solution,
         )
         ok = ok and cur_ok
         console.print()
 
-    await _print_timing(
-        console, result.skeleton, structured_evaluations, verification=verification
-    )
+    if not single_solution:
+        await _print_timing(
+            console, result.skeleton, structured_evaluations, verification=verification
+        )
 
     return ok
 

rbx/box/statements/build_statements.py

@@ -1,7 +1,7 @@
 import pathlib
 import tempfile
 import typing
-from typing import Annotated, Dict, List, Optional, Tuple
+from typing import Annotated, Any, Dict, List, Optional, Tuple
 
 import syncer
 import typer
@@ -9,7 +9,7 @@ import typer
 from rbx import annotations, console
 from rbx.box import environment, naming, package
 from rbx.box.formatting import href
-from rbx.box.schema import Package
+from rbx.box.schema import Package, expand_any_vars
 from rbx.box.statements.builders import (
     BUILDER_LIST,
     PROBLEM_BUILDER_LIST,
@@ -217,7 +217,7 @@ def build_statement_bytes(
     overridden_params: Optional[Dict[ConversionType, ConversionStep]] = None,
     overridden_assets: Optional[List[Tuple[pathlib.Path, pathlib.Path]]] = None,
     use_samples: bool = True,
-    is_editorial: bool = False,
+    custom_vars: Optional[Dict[str, Any]] = None,
 ) -> Tuple[bytes, StatementType]:
     overridden_params = overridden_params or {}
     overridden_assets = overridden_assets or []
@@ -258,10 +258,11 @@ def build_statement_bytes(
             output = bdr.build(
                 input=last_content,
                 context=StatementBuilderContext(
+                    lang=statement.language,
                     languages=get_environment_languages_for_statement(),
                     params=params,
                     root=pathlib.Path(td),
-                    editorial=is_editorial,
+                    custom_vars=custom_vars,
                 ),
                 item=StatementBuilderProblem(
                     package=pkg,
@@ -284,24 +285,23 @@ def build_statement(
     pkg: Package,
     output_type: Optional[StatementType] = None,
     use_samples: bool = True,
-    is_editorial: bool = False,
+    custom_vars: Optional[Dict[str, Any]] = None,
 ) -> pathlib.Path:
     last_content, last_output = build_statement_bytes(
         statement,
         pkg,
         output_type=output_type,
         use_samples=use_samples,
-        is_editorial=is_editorial,
+        custom_vars=custom_vars,
         short_name=naming.get_problem_shortname(),
     )
-    statement_path = (
-        package.get_build_path()
-        / f'{statement.path.stem}{last_output.get_file_suffix()}'
+    statement_path = (package.get_build_path() / statement.name).with_suffix(
+        last_output.get_file_suffix()
     )
     statement_path.parent.mkdir(parents=True, exist_ok=True)
     statement_path.write_bytes(last_content)
     console.console.print(
-        f'Statement built successfully for language '
+        f'Statement [item]{statement.name}[/item] built successfully for language '
         f'[item]{statement.language}[/item] at '
         f'{href(statement_path)}'
     )
@@ -313,13 +313,18 @@ def build_statement(
 @syncer.sync
 async def build(
     verification: environment.VerificationParam,
+    names: Annotated[
+        Optional[List[str]],
+        typer.Argument(
+            help='Names of statements to build.',
+        ),
+    ] = None,
     languages: Annotated[
         Optional[List[str]],
         typer.Option(
-            default_factory=list,
             help='Languages to build statements for. If not specified, build statements for all available languages.',
         ),
-    ],
+    ] = None,
     output: Annotated[
         Optional[StatementType],
         typer.Option(
@@ -331,9 +336,14 @@ async def build(
         bool,
         typer.Option(help='Whether to build the statement with samples or not.'),
     ] = True,
-    editorial: Annotated[
-        bool, typer.Option(help='Whether to add editorial blocks to the statements.')
-    ] = False,
+    vars: Annotated[
+        Optional[List[str]],
+        typer.Option(
+            '-v',
+            '--vars',
+            help='Variables to be used in the statements.',
+        ),
+    ] = None,
 ):
     # At most run the validators, only in samples.
     if samples:
@@ -350,24 +360,31 @@ async def build(
             raise typer.Exit(1)
 
     pkg = package.find_problem_package_or_die()
-    candidate_languages = languages
-    if not candidate_languages:
-        candidate_languages = sorted(set([st.language for st in pkg.statements]))
+    candidate_languages = set(languages or [])
+    candidate_names = set(names or [])
 
-    for language in candidate_languages:
-        candidates_for_lang = [st for st in pkg.statements if st.language == language]
-        if not candidates_for_lang:
-            console.console.print(
-                f'[error]No statement found for language [item]{language}[/item].[/error]',
-            )
-            raise typer.Exit(1)
+    def should_process(st: Statement) -> bool:
+        if candidate_languages and st.language not in candidate_languages:
+            return False
+        if candidate_names and st.name not in candidate_names:
+            return False
+        return True
+
+    valid_statements = [st for st in pkg.expanded_statements if should_process(st)]
+
+    if not valid_statements:
+        console.console.print(
+            '[error]No statement found according to the specified criteria.[/error]',
+        )
+        raise typer.Exit(1)
 
+    for statement in valid_statements:
         build_statement(
-            candidates_for_lang[0],
+            statement,
             pkg,
             output_type=output,
             use_samples=samples,
-            is_editorial=editorial,
+            custom_vars=expand_any_vars(annotations.parse_dictionary_items(vars)),
         )