rbx.cp 0.5.72__py3-none-any.whl → 0.6.0__py3-none-any.whl

rbx/annotations.py

@@ -1,7 +1,7 @@
 import importlib.resources
 import pathlib
 import re
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 
 import typer
 import typer.core
@@ -112,6 +112,26 @@ Checker = Annotated[
 ]
 
 
+def parse_dictionary(value: Optional[str]) -> Dict[str, Any]:
+    if value is None:
+        return {}
+    res = {}
+    for item in value.split(','):
+        key, value = item.split('=', 1)
+        res[key] = value
+    return res
+
+
+def parse_dictionary_items(items: Optional[List[str]]) -> Dict[str, Any]:
+    if items is None:
+        return {}
+    res = {}
+    for item in items:
+        key, value = item.split('=', 1)
+        res[key] = value
+    return res
+
+
 class AliasGroup(typer.core.TyperGroup):
     _CMD_SPLIT_P = re.compile(r', ?')
 

rbx/box/cli.py

@@ -42,6 +42,7 @@ from rbx.box.solutions import (
 from rbx.box.statements import build_statements
 from rbx.box.testcase_utils import TestcaseEntry
 from rbx.box.testcases import main as testcases
+from rbx.box.tooling import main as tooling
 
 app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
 app.add_typer(
@@ -60,7 +61,7 @@ app.add_typer(
 )
 app.add_typer(
     download.app,
-    name='download',
+    name='download, down',
     cls=annotations.AliasGroup,
     help='Download an asset from supported repositories (sub-command).',
     rich_help_panel='Management',
@@ -93,6 +94,13 @@ app.add_typer(
     help='Manage testcases (sub-command).',
     rich_help_panel='Management',
 )
+app.add_typer(
+    tooling.app,
+    name='tool, tooling',
+    cls=annotations.AliasGroup,
+    help='Manage tooling (sub-command).',
+    rich_help_panel='Misc',
+)
 
 
 @app.callback()
@@ -104,12 +112,11 @@ def main(
         help='Whether to compile and run testlib components with sanitizers enabled. '
         'If you want to run the solutions with sanitizers enabled, use the "-s" flag in the corresponding run command.',
     ),
-    debug_logs: bool = typer.Option(
-        False,
-        '--debug-logs',
-        '--debug',
-        '-d',
-        help='Whether to save extra debug logs along with the evaluation results.',
+    capture: bool = typer.Option(
+        True,
+        '--nocapture',
+        flag_value=False,
+        help='Whether to save extra logs and outputs from interactive solutions.',
     ),
 ):
     if cd.is_problem_package() and not package.is_cache_valid():
@@ -125,7 +132,7 @@ def main(
             '[warning]Sanitizers are running just for testlib components.\n'
             'If you want to run the solutions with sanitizers enabled, use the [item]-s[/item] flag in the corresponding run command.[/warning]'
         )
-    state.STATE.debug_logs = debug_logs
+    state.STATE.debug_logs = capture
 
 
 @app.command('ui', hidden=True)
@@ -136,6 +143,15 @@ def ui():
     ui_pkg.start()
 
 
+@app.command(
+    'on',
+    help='Run a command in the context of a problem (or a set of problems) of a contest.',
+    context_settings={'allow_extra_args': True, 'ignore_unknown_options': True},
+)
+def on(ctx: typer.Context, problems: str) -> None:
+    contest.on(ctx, problems)
+
+
 @app.command('diff', hidden=True)
 def diff(path1: pathlib.Path, path2: pathlib.Path):
     from rbx.box.ui import main as ui_pkg

rbx/box/code.py

@@ -14,6 +14,7 @@ import typer
 from rbx import console
 from rbx.box import download, package, setter_config, state
 from rbx.box.environment import (
+    CompilationConfig,
     ExecutionConfig,
     FileMapping,
     get_compilation_config,
@@ -29,7 +30,7 @@ from rbx.box.formatting import get_formatted_memory
 from rbx.box.sanitizers import warning_stack
 from rbx.box.schema import CodeItem
 from rbx.grading import steps, steps_with_caching
-from rbx.grading.judge.sandbox import SandboxParams
+from rbx.grading.judge.sandbox import SandboxBase, SandboxParams
 from rbx.grading.steps import (
     DigestHolder,
     DigestOrDest,
@@ -39,7 +40,10 @@ from rbx.grading.steps import (
     GradingFileOutput,
     RunLog,
     RunLogMetadata,
+    get_exe_from_command,
+    is_cpp_command,
     is_cxx_command,
+    maybe_get_bits_stdcpp_for_commands,
 )
 
 
@@ -391,12 +395,109 @@ def _prepare_run(
     )
 
 
+def _should_precompile(commands: List[str]) -> bool:
+    return any(is_cpp_command(command) for command in commands)
+
+
+def _precompile_header(
+    compilation_options: CompilationConfig,
+    sanitized: SanitizationLevel,
+    sandbox: SandboxBase,
+    sandbox_params: SandboxParams,
+    artifacts: GradingArtifacts,
+    input_artifact: GradingFileInput,
+    force_warnings: bool = False,
+    verbose: bool = False,
+) -> GradingFileInput:
+    """
+    Precompile a header file (.h).
+
+    Assumes input artifact is a header file (.h) and compilation commands are C++.
+    """
+    assert compilation_options.commands is not None
+
+    dependency_cache = package.get_dependency_cache()
+
+    # TODO: deduplicate code with compile_item.
+    commands = get_mapped_commands(
+        compilation_options.commands,
+        FileMapping(
+            compilable='precompilable.h',
+            executable='precompilable.h.gch',
+        ),
+    )
+    commands = add_warning_flags(commands, force_warnings)
+    commands = substitute_commands(commands, sanitized=sanitized.should_sanitize())
+
+    if sanitized.should_sanitize():
+        commands = add_sanitizer_flags(commands)
+
+    precompilation_artifacts = GradingArtifacts()
+
+    # Keep only header files.
+    precompilation_artifacts.inputs = [
+        input
+        for input in artifacts.inputs
+        if input.src is not None and input.src.suffix == '.h'
+    ]
+    precompilation_artifacts.inputs.append(
+        GradingFileInput(
+            src=input_artifact.src,
+            dest=PosixPath('precompilable.h'),
+        )
+    )
+
+    # Pull only the precompiled header file.
+    precompiled_digest = DigestHolder()
+    precompilation_artifacts.outputs.append(
+        GradingFileOutput(
+            src=PosixPath('precompilable.h.gch'),
+            digest=precompiled_digest,
+            executable=True,
+        )
+    )
+
+    if not steps_with_caching.compile(
+        commands,
+        params=sandbox_params,
+        artifacts=precompilation_artifacts,
+        sandbox=sandbox,
+        dependency_cache=dependency_cache,
+    ):
+        console.console.print(
+            f'[error]Failed to precompile header file: [item]{input_artifact.src}[/item][/error]'
+        )
+        raise typer.Exit(1)
+
+    if verbose:
+        console.console.print(
+            f'[status]Precompiled header file: [item]{input_artifact.src}[/item]'
+        )
+
+        if (
+            precompilation_artifacts.logs is not None
+            and precompilation_artifacts.logs.preprocess is not None
+        ):
+            for log in precompilation_artifacts.logs.preprocess:
+                console.console.print(f'[status]Command:[/status] {log.get_command()}')
+                console.console.print(f'[status]Summary:[/status] {log.get_summary()}')
+
+    assert precompiled_digest.value is not None
+
+    return GradingFileInput(
+        digest=precompiled_digest,
+        dest=input_artifact.dest.with_suffix('.h.gch'),
+        executable=True,
+    )
+
+
 # Compile code item and return its digest in the storage.
 def compile_item(
     code: CodeItem,
     sanitized: SanitizationLevel = SanitizationLevel.PREFER,
     force_warnings: bool = False,
     verbose: bool = False,
+    precompile: bool = True,
 ) -> str:
     _check_stack_limit()
 
@@ -461,6 +562,41 @@ def compile_item(
     for input in artifacts.inputs:
         _ignore_warning_in_cxx_input(input)
 
+    # Add system bits/stdc++.h to the compilation.
+    bits_artifact = maybe_get_bits_stdcpp_for_commands(commands)
+    if bits_artifact is not None:
+        artifacts.inputs.append(bits_artifact)
+        commands = [
+            command + ' -I.'
+            for command in commands
+            if is_cxx_command(get_exe_from_command(command))
+        ]
+
+    # Precompile C++ header files.
+    if precompile and _should_precompile(commands):
+        precompilation_inputs = []
+        for input in artifacts.inputs:
+            if (
+                input.src is not None
+                and input.src.suffix == '.h'
+                and input.dest.suffix == '.h'
+            ):
+                precompilation_inputs.append(
+                    _precompile_header(
+                        compilation_options,
+                        sanitized,
+                        sandbox,
+                        sandbox_params,
+                        artifacts,
+                        input,
+                        force_warnings,
+                        verbose=False,
+                    )
+                )
+        if precompilation_inputs:
+            artifacts.inputs.extend(precompilation_inputs)
+
+    # Compile the code.
     if not steps_with_caching.compile(
         commands,
         params=sandbox_params,
@@ -473,6 +609,7 @@ def compile_item(
     assert compiled_digest.value is not None
 
     if verbose and artifacts.logs is not None and artifacts.logs.preprocess is not None:
+        console.console.print(f'[status]Compiled item: [item]{code.path}[/item]')
         for log in artifacts.logs.preprocess:
             console.console.print(f'[status]Command:[/status] {log.get_command()}')
             console.console.print(f'[status]Summary:[/status] {log.get_summary()}')
@@ -589,8 +726,8 @@ async def run_communication(
     interactor_prepared.metadata.retryIndex = retry_index
     solution_prepared.metadata.retryIndex = retry_index
 
-    interactor_prefix = 'INTERACTOR:'
-    solution_prefix = 'SOLUTION:'
+    interactor_prefix = '<'
+    solution_prefix = '>'
 
     if merged_capture is not None:
         package.get_merged_capture_path().write_text(

rbx/box/contest/build_contest_statements.py

@@ -2,7 +2,7 @@ import dataclasses
 import pathlib
 import tempfile
 import typing
-from typing import List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 import typer
 
@@ -85,36 +85,41 @@ def get_statement_builder_contest(
 
 def get_problems_for_statement(
     contest: Contest,
-    language: str,
+    contest_statement: ContestStatement,
     requires_matching_statement: bool = True,
 ) -> List[ExtractedProblem]:
     pkgs = get_problems(contest)
-    if not pkgs:
+    if not pkgs and not requires_matching_statement:
         console.console.print(
             '[error]No problems found in the contest, cannot infer statement type.[/error]'
         )
         raise typer.Exit(1)
 
+    def matches(statement: Statement) -> bool:
+        if not requires_matching_statement:
+            return True
+        if contest_statement.match is None:
+            return statement.language == contest_statement.language
+        return statement.name == contest_statement.match
+
     res = []
     for pkg, problem in zip(pkgs, contest.problems):
-        found = False
-        for statement in pkg.statements:
-            if statement.language == language or not requires_matching_statement:
-                found = True
-                res.append(
-                    ExtractedProblem(
-                        package=pkg,
-                        statement=statement,
-                        problem=problem,
-                        samples=_get_samples(problem),
-                    )
-                )
-                break
-        if not found:
+        matching_statements = [
+            statement for statement in pkg.expanded_statements if matches(statement)
+        ]
+        if not matching_statements:
             console.console.print(
-                f'[error]No statement found for language {language} in problem {problem.short_name}[/error]'
+                f'[error]No statement found for language {contest_statement.language} in problem {problem.short_name}[/error]'
             )
             raise typer.Exit(1)
+        res.append(
+            ExtractedProblem(
+                package=pkg,
+                statement=matching_statements[0],
+                problem=problem,
+                samples=_get_samples(problem),
+            )
+        )
 
     return res
 
@@ -146,14 +151,17 @@ def _build_problem_statements(
     root: pathlib.Path,
     output_type: StatementType,
     use_samples: bool = True,
-    is_editorial: bool = False,
+    custom_vars: Optional[Dict[str, Any]] = None,
 ) -> List[ExtractedProblem]:
     console.console.print('Building problem-level statements...')
-    extracted_problems = get_problems_for_statement(contest, statement.language)
+    extracted_problems = get_problems_for_statement(contest, statement)
     res = []
     contest_cwd_absolute = pathlib.Path().resolve()
     contest_assets = get_relative_assets(statement.path, statement.assets)
 
+    extra_vars = dict(statement.override.vars if statement.override is not None else {})
+    extra_vars.update(custom_vars or {})
+
     for extracted_problem in extracted_problems:
         console.console.print(
             f'Building statement for problem {extracted_problem.problem.short_name}...'
@@ -174,7 +182,8 @@ def _build_problem_statements(
                 overridden_assets=contest_assets,  # overridden assets
                 overridden_params_root=contest_cwd_absolute,
                 use_samples=use_samples,
-                is_editorial=is_editorial,
+                # Use custom var overriding and problem-level overriding.
+                custom_vars=extra_vars,
             )
         dest_dir = root / '.problems' / extracted_problem.problem.short_name
         dest_path = dest_dir / f'statement{output_type.get_file_suffix()}'
@@ -201,7 +210,7 @@ def build_contest_only(
     input: bytes,
     input_type: StatementType,
     output_type: Optional[StatementType] = None,
-    is_editorial: bool = False,
+    custom_vars: Optional[Dict[str, Any]] = None,
 ) -> Tuple[bytes, StatementType]:
     console.console.print('Building contest-level statement.')
     bdrs = get_builders(
@@ -224,10 +233,11 @@ def build_contest_only(
             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,
                     vars={**contest.expanded_vars, **statement.expanded_vars},
                 ),
                 item=get_statement_builder_contest(statement, extracted_problems),
@@ -245,7 +255,7 @@ def build_statement_rooted(
     root: pathlib.Path,
     output_type: Optional[StatementType] = None,
     use_samples: bool = True,
-    is_editorial: bool = False,
+    custom_vars: Optional[Dict[str, Any]] = None,
 ) -> Tuple[bytes, StatementType]:
     # Validate.
     if not statement.path.is_file():
@@ -257,7 +267,7 @@ def build_statement_rooted(
     if statement.joiner is None:
         joiner = None
         extracted_problems = get_problems_for_statement(
-            contest, statement.language, requires_matching_statement=False
+            contest, statement, requires_matching_statement=False
         )
     else:
         # Build problem-level statements.
@@ -268,7 +278,7 @@ def build_statement_rooted(
             root,
             output_type=joiner.joined_type(),
             use_samples=use_samples,
-            is_editorial=is_editorial,
+            custom_vars=custom_vars,
         )
 
     # Build contest-level statement into joiner input type.
@@ -279,7 +289,7 @@ def build_statement_rooted(
         statement.path.read_bytes(),
         statement.type,
         output_type=joiner.joined_type() if joiner is not None else output_type,
-        is_editorial=is_editorial,
+        custom_vars=custom_vars,
     )
 
     if joiner is None:
@@ -313,7 +323,7 @@ def build_statement_rooted(
         last_content,
         last_output,
         output_type=output_type,
-        is_editorial=is_editorial,
+        custom_vars=custom_vars,
     )
 
     return last_content, last_output
@@ -324,7 +334,7 @@ def build_statement(
     contest: Contest,
     output_type: Optional[StatementType] = None,
     use_samples: bool = True,
-    is_editorial: bool = False,
+    custom_vars: Optional[Dict[str, Any]] = None,
 ) -> pathlib.Path:
     with tempfile.TemporaryDirectory() as td:
         root = pathlib.Path(td)
@@ -334,17 +344,17 @@ def build_statement(
             root,
             output_type=output_type,
             use_samples=use_samples,
-            is_editorial=is_editorial,
+            custom_vars=custom_vars,
         )
 
-    statement_path = pathlib.Path(
-        f'build/{statement.path.stem}{last_output.get_file_suffix()}'
+    statement_path = (pathlib.Path('build') / statement.name).with_suffix(
+        last_output.get_file_suffix()
     )
     statement_path.parent.mkdir(parents=True, exist_ok=True)
     statement_path.write_bytes(typing.cast(bytes, last_content))
     console.console.print(
-        f'Statement built successfully for language '
+        f'[success]Statement [item]{statement.name}[/item] built successfully for language '
         f'[item]{statement.language}[/item] at '
-        f'{href(statement_path)}'
+        f'{href(statement_path)}[/success]'
     )
     return statement_path

rbx/box/contest/contest_utils.py

@@ -1,5 +1,30 @@
+from typing import List
+
 from rbx.box import environment, package
 from rbx.box.contest import contest_package
+from rbx.box.contest.schema import ContestProblem
+
+
+def match_problem(problems: str, contest_problem: ContestProblem) -> bool:
+    short_name = contest_problem.short_name.lower()
+    problems = problems.lower()
+    if problems == '*':
+        return True
+    if '-' in problems:
+        start, end = problems.split('-')
+        return start <= short_name <= end
+    problem_set = set(p.strip().lower() for p in problems.split(','))
+    return short_name in problem_set
+
+
+def get_problems_of_interest(problems: str) -> List[ContestProblem]:
+    contest = contest_package.find_contest_package_or_die()
+    problems_of_interest = []
+
+    for p in contest.problems:
+        if match_problem(problems, p):
+            problems_of_interest.append(p)
+    return problems_of_interest
 
 
 def clear_all_caches():

rbx/box/contest/main.py

@@ -232,3 +232,27 @@ def each(ctx: typer.Context) -> None:
         console.console.print(
             '[error]One of the commands above failed. Check the output![/error]'
         )
+
+
+@app.command(
+    'on',
+    help='Run a command in the problem (or in a set of problems) of a context.',
+    context_settings={'allow_extra_args': True, 'ignore_unknown_options': True},
+)
+@within_contest
+def on(ctx: typer.Context, problems: str) -> None:
+    command = ' '.join(['rbx'] + ctx.args)
+    problems_of_interest = contest_utils.get_problems_of_interest(problems)
+
+    if not problems_of_interest:
+        console.console.print(
+            f'[error]No problems found in contest matching [item]{problems}[/item].[/error]'
+        )
+        raise typer.Exit(1)
+
+    for p in problems_of_interest:
+        console.console.print(
+            f'[status]Running [item]{command}[/item] for [item]{p.short_name}[/item]...[/status]'
+        )
+        subprocess.call(command, cwd=p.get_path(), shell=True)
+        console.console.print()

rbx/box/contest/schema.py

@@ -1,12 +1,15 @@
 import pathlib
-from typing import Dict, List, Optional
+from typing import Annotated, Dict, List, Optional
 
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import AfterValidator, BaseModel, ConfigDict, Field, model_validator
 
-from rbx.box.schema import NameField, Primitive, expand_var
+from rbx.box.fields import FNameField, NameField
+from rbx.box.schema import Primitive, expand_var
+from rbx.box.statements.expander import expand_statements
 from rbx.box.statements.schema import (
     ConversionStep,
     Joiner,
+    StatementLanguage,
     StatementType,
 )
 
@@ -15,6 +18,13 @@ def ShortNameField(**kwargs):
     return Field(pattern=r'^[A-Z]+[0-9]*$', min_length=1, max_length=4, **kwargs)
 
 
+def is_unique_by_name(statements: List['ContestStatement']) -> List['ContestStatement']:
+    names = {st.name for st in statements}
+    if len(names) != len(statements):
+        raise ValueError('Statement names must be unique.')
+    return statements
+
+
 class ProblemStatementOverride(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
@@ -29,13 +39,26 @@ configure them in case they are applied.
 """,
     )
 
+    vars: Dict[str, Primitive] = Field(
+        default={},
+        description='Variables to be merged into the problem statement vars.',
+    )
+
 
 class ContestStatement(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
-    language: str = Field(default='en', description='Language code for this statement.')
+    name: str = FNameField(description='Name of this statement.')
+
+    extends: Optional[str] = FNameField(
+        default=None, description='Name of the statement to inherit from.'
+    )
+
+    language: StatementLanguage = Field(
+        default='en', description='Language code for this statement (ISO 639-1).'
+    )
 
-    title: str = Field(description='Title of the contest in this language.')
+    title: str = Field(default='', description='Title of the contest in this language.')
 
     location: Optional[str] = Field(
         default=None, description='Location of the contest in this language.'
@@ -45,9 +68,14 @@ class ContestStatement(BaseModel):
         default=None, description='Date of the contest in this language.'
     )
 
-    path: pathlib.Path = Field(description='Path to the input statement file.')
+    path: pathlib.Path = Field(
+        default_factory=pathlib.Path,
+        description='Path to the input statement file.',
+    )
 
-    type: StatementType = Field(description='Type of the input statement file.')
+    type: StatementType = Field(
+        default=StatementType.rbxTeX, description='Type of the input statement file.'
+    )
 
     joiner: Optional[Joiner] = Field(
         default=None,
@@ -95,6 +123,15 @@ Can be glob pattern as well, such as `imgs/*.png`.
         default=None, description='Override configuration for problem statements.'
     )
 
+    match: Optional[str] = FNameField(
+        default=None,
+        description="""
+        Name of the problem-level statement to match this statement against.
+
+        If not specified, will match against the first statement of the same language.
+        """,
+    )
+
     # Vars to be re-used in the statement.
     #   - It will be available as \VAR{vars} variable in the contest-level box statement.
     vars: Dict[str, Primitive] = Field(
@@ -188,7 +225,10 @@ class Contest(BaseModel):
         default=[], description='List of problems in this contest.'
     )
 
-    statements: List[ContestStatement] = Field(
+    statements: Annotated[
+        List[ContestStatement],
+        AfterValidator(is_unique_by_name),
+    ] = Field(
         default=None,
         description='Configure statements in this contest, per language.',
     )
@@ -199,6 +239,10 @@ class Contest(BaseModel):
         default={}, description='Variables to be re-used across the package.'
     )
 
+    @property
+    def expanded_statements(self) -> List[ContestStatement]:
+        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()}