rbx.cp 0.13.8__py3-none-any.whl → 0.14.0__py3-none-any.whl

rbx/box/cli.py

@@ -25,6 +25,7 @@ from rbx.box import (
     presets,
     setter_config,
     state,
+    timing,
     validators,
 )
 from rbx.box.contest import main as contest
@@ -34,7 +35,6 @@ from rbx.box.header import generate_header
 from rbx.box.packaging import main as packaging
 from rbx.box.schema import CodeItem, ExpectedOutcome, TestcaseGroup
 from rbx.box.solutions import (
-    estimate_time_limit,
     get_exact_matching_solutions,
     get_matching_solutions,
     pick_solutions,
@@ -107,6 +107,16 @@ app.add_typer(
 )
 
 
+def version_callback(value: bool) -> None:
+    if value:
+        import importlib.metadata
+
+        version = importlib.metadata.version('rbx.cp')
+
+        console.console.print(f'rbx version {version}')
+        raise typer.Exit()
+
+
 @app.callback()
 def main(
     cache: Annotated[
@@ -136,6 +146,9 @@ def main(
         '-p',
         help='Whether to profile the execution.',
     ),
+    version: Annotated[
+        bool, typer.Option('--version', '-v', callback=version_callback, is_eager=True)
+    ] = False,
 ):
     if cd.is_problem_package() and not package.is_cache_valid():
         console.console.print(
@@ -266,12 +279,6 @@ async def run(
         '-d',
         help='Whether to print a detailed view of the tests using tables.',
     ),
-    timeit: bool = typer.Option(
-        False,
-        '--time',
-        '-t',
-        help='Whether to use estimate a time limit based on accepted solutions.',
-    ),
     sanitized: bool = typer.Option(
         False,
         '--sanitized',
@@ -324,20 +331,6 @@ async def run(
         )
         return
 
-    override_tl = None
-    if timeit:
-        if sanitized:
-            console.console.print(
-                '[error]Sanitizers are known to be time-hungry, so they cannot be used for time estimation.\n'
-                'Remove either the [item]-s[/item] flag or the [item]-t[/item] flag to run solutions without sanitizers.[/error]'
-            )
-            raise typer.Exit(1)
-
-        # Never use sanitizers for time estimation.
-        override_tl = await _time_impl(check=check, detailed=False)
-        if override_tl is None:
-            raise typer.Exit(1)
-
     if sanitized:
         console.console.print(
             '[warning]Sanitizers are running, so the time limit for the problem will be dropped, '
@@ -359,7 +352,6 @@ async def run(
             tracked_solutions=tracked_solutions,
             check=check,
             verification=VerificationLevel(verification),
-            timelimit_override=override_tl,
             sanitized=sanitized,
         )
 
@@ -374,51 +366,6 @@ async def run(
     )
 
 
-async def _time_impl(check: bool, detailed: bool, runs: int = 0) -> Optional[int]:
-    if package.get_main_solution() is None:
-        console.console.print(
-            '[warning]No main solution found, so cannot estimate a time limit.[/warning]'
-        )
-        return None
-
-    verification = VerificationLevel.ALL_SOLUTIONS.value
-
-    with utils.StatusProgress('Running ACCEPTED solutions...') as s:
-        tracked_solutions = OrderedSet(
-            str(solution.path)
-            for solution in get_exact_matching_solutions(ExpectedOutcome.ACCEPTED)
-        )
-        solution_result = run_solutions(
-            progress=s,
-            tracked_solutions=tracked_solutions,
-            check=check,
-            verification=VerificationLevel(verification),
-            timelimit_override=-1,  # Unlimited for time limit estimation
-            nruns=runs,
-        )
-
-    console.console.print()
-    console.console.rule(
-        '[status]Run report (for time estimation)[/status]', style='status'
-    )
-    ok = await print_run_report(
-        solution_result,
-        console.console,
-        VerificationLevel(verification),
-        detailed=detailed,
-        skip_printing_limits=True,
-    )
-
-    if not ok:
-        console.console.print(
-            '[error]Failed to run ACCEPTED solutions, so cannot estimate a reliable time limit.[/error]'
-        )
-        return None
-
-    console.console.print()
-    return await estimate_time_limit(console.console, solution_result)
-
-
 @app.command(
     'time, t',
     rich_help_panel='Testing',
@@ -444,7 +391,61 @@ async def time(
         '-r',
         help='Number of runs to perform for each solution. Zero means the config default.',
     ),
+    profile: str = typer.Option(
+        'local',
+        '--profile',
+        '-p',
+        help='Profile to use for time limit estimation.',
+    ),
+    integrate: bool = typer.Option(
+        False,
+        '--integrate',
+        '-i',
+        help='Integrate the given limits profile into the package.',
+    ),
 ):
+    if integrate:
+        timing.integrate(profile)
+        return
+
+    import questionary
+
+    formula = environment.get_environment().timing.formula
+    timing_choices = [
+        questionary.Choice(
+            f'Estimate time limits based on the formula {formula} (recommended)',
+            value='estimate',
+        ),
+        questionary.Choice('Inherit from the package.', value='inherit'),
+        questionary.Choice(
+            'Estimate time limits based on a custom formula.', value='estimate_custom'
+        ),
+        questionary.Choice('Provide a custom time limit.', value='custom'),
+    ]
+
+    choice = await questionary.select(
+        'Select how you want to define the time limits for the problem.',
+        choices=timing_choices,
+    ).ask_async()
+
+    formula = environment.get_environment().timing.formula
+
+    if choice == 'inherit':
+        timing.inherit_time_limits(profile=profile)
+        return
+    elif choice == 'custom':
+        timelimit = await questionary.text(
+            'Enter a custom time limit for the problem (ms).',
+            validate=lambda x: x.isdigit() and int(x) > 0,
+        ).ask_async()
+        timing.set_time_limit(int(timelimit), profile=profile)
+        return
+
+    if choice == 'estimate_custom':
+        formula = await questionary.text(
+            'Enter a custom formula for time limit estimation.'
+        ).ask_async()
+
     main_solution = package.get_main_solution()
     if check and main_solution is None:
         console.console.print(
@@ -458,7 +459,9 @@ async def time(
     if not await builder.build(verification=verification, output=check):
         return None
 
-    await _time_impl(check, detailed, runs)
+    await timing.compute_time_limits(
+        check, detailed, runs, formula=formula, profile=profile
+    )
 
 
 @app.command(
@@ -850,11 +853,12 @@ async def validate(
     help='Run unit tests for the validator and checker.',
 )
 @package.within_problem
-def unit_tests():
+@syncer.sync
+async def unit_tests():
     from rbx.box import unit
 
     with utils.StatusProgress('Running unit tests...') as s:
-        unit.run_unit_tests(s)
+        await unit.run_unit_tests(s)
 
 
 @app.command(

rbx/box/code.py

@@ -3,6 +3,7 @@ import pathlib
 import re
 import resource
 import shlex
+import sys
 from enum import Enum
 from pathlib import PosixPath
 from typing import List, Optional
@@ -214,6 +215,8 @@ def _check_stack_limit():
         return
     if not state.STATE.run_through_cli:
         return
+    if sys.platform != 'darwin':
+        return
     soft, hard = resource.RLIM_INFINITY, resource.RLIM_INFINITY
 
     TARGET = 256 * 1024 * 1024  # 256 MiB

rbx/box/contest/build_contest_statements.py

@@ -7,12 +7,14 @@ from typing import Any, Dict, List, Optional, Tuple
 import typer
 
 from rbx import console, testing_utils, utils
-from rbx.box import cd, package
+from rbx.box import cd, limits_info, package
 from rbx.box.contest.contest_package import get_problems
 from rbx.box.contest.schema import Contest, ContestProblem, ContestStatement
 from rbx.box.fields import Primitive
 from rbx.box.formatting import href
-from rbx.box.schema import Package, Testcase
+from rbx.box.sanitizers import issue_stack
+from rbx.box.sanitizers.issue_stack import Issue
+from rbx.box.schema import LimitsProfile, Package, Testcase
 from rbx.box.statements import build_statements, latex
 from rbx.box.statements.build_statements import (
     get_builders,
@@ -41,6 +43,7 @@ class ExtractedProblem:
     package: Package
     statement: Statement
     problem: ContestProblem
+    limits: LimitsProfile
     samples: List[Testcase]
     built_statement: Optional[pathlib.Path] = None
 
@@ -52,6 +55,7 @@ class ExtractedProblem:
 
     def get_statement_builder_problem(self) -> StatementBuilderProblem:
         return StatementBuilderProblem(
+            limits=self.limits,
             package=self.package,
             statement=self.statement,
             samples=StatementSample.from_testcases(self.samples),
@@ -60,10 +64,28 @@ class ExtractedProblem:
         )
 
 
+class StatementBuildIssue(Issue):
+    def __init__(self, problem: ContestProblem):
+        self.problem = problem
+
+    def get_overview_section(self) -> Optional[Tuple[str, ...]]:
+        return ('statement',)
+
+    def get_overview_message(self) -> str:
+        return f'Error building statement for problem [item]{self.problem.short_name}[/item].'
+
+
 def _get_samples(problem: ContestProblem) -> List[Testcase]:
     with cd.new_package_cd(problem.get_path()):
         package.clear_package_cache()
-        return get_samples()
+        try:
+            return get_samples()
+        except Exception as e:
+            console.console.print(
+                f'[error]Error getting samples for problem {problem.short_name}: {e}[/error]'
+            )
+            issue_stack.add_issue(StatementBuildIssue(problem))
+            return []
 
 
 def get_statement_builder_problems(
@@ -94,12 +116,12 @@ def get_statement_builder_contest(
 def get_problems_for_statement(
     contest: Contest,
     contest_statement: ContestStatement,
-    requires_matching_statement: bool = True,
+    requires_matching_statement: bool = False,
 ) -> List[ExtractedProblem]:
     pkgs = get_problems(contest)
-    if not pkgs and not requires_matching_statement:
+    if not pkgs and requires_matching_statement:
         console.console.print(
-            '[error]No problems found in the contest, cannot infer statement type.[/error]'
+            f'[error]No problems found in the contest, cannot infer statement type for statement [item]{contest_statement.name}[/item].[/error]'
         )
         raise typer.Exit(1)
 
@@ -122,6 +144,9 @@ def get_problems_for_statement(
             raise typer.Exit(1)
         res.append(
             ExtractedProblem(
+                limits=limits_info.get_limits_profile(
+                    profile=limits_info.get_active_profile(), root=problem.get_path()
+                ),
                 package=pkg,
                 statement=matching_statements[0],
                 problem=problem,
@@ -137,6 +162,7 @@ def get_builder_problems(
 ) -> List[StatementBuilderProblem]:
     return [
         StatementBuilderProblem(
+            limits=ex.limits,
             package=ex.package,
             statement=ex.statement,
             samples=StatementSample.from_testcases(ex.samples),
@@ -177,22 +203,29 @@ def _build_problem_statements(
         with cd.new_package_cd(extracted_problem.problem.get_path()):
             package.clear_package_cache()
             # TODO: respect steps override
-            content, _ = build_statements.build_statement_bytes(
-                extracted_problem.statement,
-                extracted_problem.package,
-                output_type=output_type,
-                short_name=extracted_problem.problem.short_name,
-                overridden_params={
-                    cfg.type: cfg for cfg in statement.override.configure
-                }
-                if statement.override is not None
-                else {},  # overridden configure params
-                overridden_assets=contest_assets,  # overridden assets
-                overridden_params_root=contest_cwd_absolute,
-                use_samples=use_samples,
-                # Use custom var overriding and problem-level overriding.
-                custom_vars=extra_vars,
-            )
+            try:
+                content, _ = build_statements.build_statement_bytes(
+                    extracted_problem.statement,
+                    extracted_problem.package,
+                    output_type=output_type,
+                    short_name=extracted_problem.problem.short_name,
+                    overridden_params={
+                        cfg.type: cfg for cfg in statement.override.configure
+                    }
+                    if statement.override is not None
+                    else {},  # overridden configure params
+                    overridden_assets=contest_assets,  # overridden assets
+                    overridden_params_root=contest_cwd_absolute,
+                    use_samples=use_samples,
+                    # Use custom var overriding and problem-level overriding.
+                    custom_vars=extra_vars,
+                )
+            except Exception as e:
+                console.console.print(
+                    f'[error]Error building statement for problem {extracted_problem.problem.short_name}: {e}[/error]'
+                )
+                issue_stack.add_issue(StatementBuildIssue(extracted_problem.problem))
+                continue
         dest_dir = root / '.problems' / extracted_problem.problem.short_name
         dest_path = dest_dir / f'statement{output_type.get_file_suffix()}'
         dest_dir.mkdir(parents=True, exist_ok=True)
@@ -292,7 +325,8 @@ def build_statement_rooted(
     if statement.joiner is None:
         joiner = None
         extracted_problems = get_problems_for_statement(
-            contest, statement, requires_matching_statement=False
+            contest,
+            statement,
         )
     else:
         # Build problem-level statements.
@@ -380,6 +414,14 @@ def build_statement(
     statement_path = (pathlib.Path('build') / statement.name).with_suffix(
         last_output.get_file_suffix()
     )
+    active_profile = limits_info.get_active_profile()
+    if (
+        active_profile is not None
+        and limits_info.get_saved_limits_profile(active_profile) is not None
+    ):
+        statement_path = statement_path.with_stem(
+            f'{statement_path.stem}-{active_profile}'
+        )
     statement_path.parent.mkdir(parents=True, exist_ok=True)
     statement_path.write_bytes(typing.cast(bytes, last_content))
     console.console.print(

rbx/box/contest/contest_package.py

@@ -10,6 +10,7 @@ from rbx import console, utils
 from rbx.box import cd
 from rbx.box.contest.schema import Contest
 from rbx.box.package import find_problem_package_or_die
+from rbx.box.sanitizers import issue_stack
 from rbx.box.schema import Package
 
 YAML_NAME = 'contest.rbx.yml'
@@ -60,7 +61,13 @@ def within_contest(func):
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
         with cd.new_package_cd(find_contest()):
-            return func(*args, **kwargs)
+            issue_level_token = issue_stack.issue_level_var.set(
+                issue_stack.IssueLevel.OVERVIEW
+            )
+            ret = func(*args, **kwargs)
+            issue_stack.print_current_report()
+            issue_stack.issue_level_var.reset(issue_level_token)
+            return ret
 
     return wrapper
 

rbx/box/contest/main.py

@@ -148,7 +148,7 @@ def add(
 
     creation.create(name, preset=preset, path=pathlib.Path(path))
 
-    contest = find_contest_package_or_die()
+    contest_pkg = find_contest_package_or_die()
 
     ru, contest = contest_package.get_ruyaml()
 
@@ -156,10 +156,16 @@ def add(
         'short_name': short_name,
         'path': path,
     }
-    if 'problems' not in contest:
+    if 'problems' not in contest or not contest_pkg.problems:
         contest['problems'] = [item]
     else:
-        contest['problems'].append(item)
+        idx = 0
+        while (
+            idx < len(contest_pkg.problems)
+            and contest_pkg.problems[idx].short_name <= short_name
+        ):
+            idx += 1
+        contest['problems'].insert(idx, item)
 
     dest = find_contest_yaml()
     assert dest is not None

rbx/box/contest/schema.py

@@ -3,7 +3,14 @@ from typing import Annotated, Dict, List, Optional
 
 from pydantic import AfterValidator, BaseModel, ConfigDict, Field, model_validator
 
-from rbx.box.fields import FNameField, NameField, Primitive, expand_var
+from rbx.box.fields import (
+    FNameField,
+    NameField,
+    Primitive,
+    RecVars,
+    Vars,
+    expand_vars,
+)
 from rbx.box.statements.expander import expand_statements
 from rbx.box.statements.schema import (
     ConversionStep,
@@ -27,9 +34,8 @@ def is_unique_by_name(statements: List['ContestStatement']) -> List['ContestStat
 class ProblemStatementOverride(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
-    configure: List[ConversionStep] = Field(
+    configure: List[Annotated[ConversionStep, Field(discriminator='type')]] = Field(
         default=[],
-        discriminator='type',
         description="""
 Configure how certain conversion steps should happen when applied to the statement file.
 
@@ -84,9 +90,8 @@ Joiner to be used to build the statement.
 This determines how problem statements will be joined into a single contest statement.""",
     )
 
-    steps: List[ConversionStep] = Field(
+    steps: List[Annotated[ConversionStep, Field(discriminator='type')]] = Field(
         default=[],
-        discriminator='type',
         description="""
 Describes a sequence of conversion steps that should be applied to the statement file
 of this contest.
@@ -97,9 +102,8 @@ certain conversion steps to happen.
 """,
     )
 
-    configure: List[ConversionStep] = Field(
+    configure: List[Annotated[ConversionStep, Field(discriminator='type')]] = Field(
         default=[],
-        discriminator='type',
         description="""
 Configure how certain conversion steps should happen when applied to the statement file of
 this contest.
@@ -133,13 +137,13 @@ Can be glob pattern as well, such as `imgs/*.png`.
 
     # 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(
+    vars: RecVars = Field(
         default={}, description='Variables to be re-used across the package.'
     )
 
     @property
-    def expanded_vars(self) -> Dict[str, Primitive]:
-        return {key: expand_var(value) for key, value in self.vars.items()}
+    def expanded_vars(self) -> Vars:
+        return expand_vars(self.vars)
 
 
 class ContestProblem(BaseModel):
@@ -234,7 +238,7 @@ class Contest(BaseModel):
 
     # Vars to be re-used in the statements.
     #   - It will be available as \VAR{vars} variable in the contest-level box statement.
-    vars: Dict[str, Primitive] = Field(
+    vars: RecVars = Field(
         default={}, description='Variables to be re-used across the package.'
     )
 
@@ -243,5 +247,5 @@ class Contest(BaseModel):
         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()}
+    def expanded_vars(self) -> Vars:
+        return expand_vars(self.vars)

rbx/box/contest/statements.py

@@ -5,13 +5,17 @@ import typer
 
 from rbx import annotations, console
 from rbx.box import cd, environment, package
-from rbx.box.contest.build_contest_statements import build_statement
+from rbx.box.contest.build_contest_statements import (
+    StatementBuildIssue,
+    build_statement,
+)
 from rbx.box.contest.contest_package import (
     find_contest_package_or_die,
     within_contest,
 )
 from rbx.box.contest.schema import ContestStatement
 from rbx.box.formatting import href
+from rbx.box.sanitizers import issue_stack
 from rbx.box.schema import expand_any_vars
 from rbx.box.statements.schema import StatementType
 
@@ -70,13 +74,13 @@ async def build(
             with cd.new_package_cd(problem.get_path()):
                 package.clear_package_cache()
 
-                if not await 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)
+                try:
+                    if not await builder.build(
+                        verification=verification, groups=set(['samples']), output=None
+                    ):
+                        issue_stack.add_issue(StatementBuildIssue(problem))
+                except Exception:
+                    issue_stack.add_issue(StatementBuildIssue(problem))
 
     contest = find_contest_package_or_die()
 

rbx/box/dump_schemas.py

@@ -7,10 +7,11 @@ from rbx.box.environment import Environment
 from rbx.box.package import Package
 from rbx.box.presets.lock_schema import PresetLock
 from rbx.box.presets.schema import Preset
+from rbx.box.schema import LimitsProfile
 from rbx.box.statements.schema import Statement
 from rbx.utils import dump_schema_str
 
-models = [Package, Environment, Contest, Preset, PresetLock, Statement]
+models = [Package, Environment, Contest, Preset, PresetLock, Statement, LimitsProfile]
 
 for model in models:
     path = pathlib.Path('schemas') / f'{model.__name__}.json'

rbx/box/environment.py

@@ -192,7 +192,7 @@ for the environment will be used.""",
     def get_extension(self, name: str, _: Type[T]) -> Optional[T]:
         if self.extensions is None:
             return None
-        if hasattr(self.extensions, name):
+        if not hasattr(self.extensions, name):
             return None
         return getattr(self.extensions, name)
 

rbx/box/fields.py

@@ -1,7 +1,8 @@
-from typing import Dict, TypeVar, Union
+from typing import TYPE_CHECKING, Dict, TypeVar, Union
 
 from deepmerge import always_merger
 from pydantic import BaseModel, Field
+from typing_extensions import TypeAliasType
 
 
 def NameField(**kwargs):
@@ -35,7 +36,12 @@ def merge_pydantic_models(base: T, nxt: T) -> T:
     return base.model_validate(merged_dict)
 
 
-Primitive = Union[str, int, float, bool]
+Primitive = Union[int, float, bool, str]
+Vars = Dict[str, Primitive]
+if TYPE_CHECKING:
+    RecVars = Dict[str, Union[Primitive, 'RecVars']]
+else:
+    RecVars = TypeAliasType('RecVars', "Dict[str, Union[Primitive, 'RecVars']]")
 
 
 def expand_var(value: Primitive) -> Primitive:
@@ -55,5 +61,17 @@ 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 expand_vars(recvars: RecVars) -> Vars:
+    vars = {}
+
+    def solve(rec: RecVars, prefix: str) -> None:
+        nonlocal vars
+        for k, v in rec.items():
+            if isinstance(v, dict):
+                solve(v, f'{prefix}.{k}')
+            else:
+                key = f'{prefix}.{k}'.strip('.')
+                vars[key] = expand_var(v)
+
+    solve(recvars, '')
+    return vars