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

rbx/box/contest/contest_package.py

@@ -9,7 +9,7 @@ from pydantic import ValidationError
 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, warn_preset_deactivated
+from rbx.box.package import find_problem_package_or_die
 from rbx.box.schema import Package
 
 YAML_NAME = 'contest.rbx.yml'
@@ -24,7 +24,6 @@ def find_contest_yaml(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.P
         contest_yaml_path = root / YAML_NAME
     if not contest_yaml_path.is_file():
         return None
-    warn_preset_deactivated(root)
     return contest_yaml_path
 
 
@@ -84,12 +83,10 @@ def get_problems(contest: Contest) -> List[Package]:
     return problems
 
 
-def get_ruyaml() -> Tuple[ruyaml.YAML, ruyaml.Any]:
-    contest_yaml_path = find_contest_yaml()
+def get_ruyaml(root: pathlib.Path = pathlib.Path()) -> Tuple[ruyaml.YAML, ruyaml.Any]:
+    contest_yaml_path = find_contest_yaml(root)
     if contest_yaml_path is None:
-        console.console.print(
-            f'Contest not found in {pathlib.Path().absolute()}', style='error'
-        )
+        console.console.print(f'[error]Contest not found in {root.absolute()}[/error]')
         raise typer.Exit(1)
     res = ruyaml.YAML()
     return res, res.load(contest_yaml_path.read_text())

rbx/box/contest/main.py

@@ -17,7 +17,6 @@ from rbx.box.contest.contest_package import (
 )
 from rbx.box.contest.schema import ContestProblem
 from rbx.box.packaging import contest_main as packaging
-from rbx.box.presets.fetch import get_preset_fetch_info
 from rbx.box.schema import Package
 from rbx.config import open_editor
 
@@ -40,53 +39,18 @@ app.add_typer(
 def create(
     path: str,
     preset: Annotated[
-        str,
+        Optional[str],
         typer.Option(
             '--preset',
             '-p',
-            help='Which preset to use to create this package. Can be a named of an already installed preset, or an URI, in which case the preset will be downloaded.',
+            help='Which preset to use to create this package. Can be a named of an already installed preset, or an URI, in which case the preset will be downloaded.\n'
+            'If not provided, the default preset will be used, or the active preset if any.',
         ),
-    ] = 'default',
-    local: bool = typer.Option(
-        False,
-        '--local',
-        '-l',
-        help='Whether to inline the installed preset within the contest folder.',
-    ),
+    ] = None,
 ):
     console.console.print(f'Creating new contest at [item]{path}[/item]...')
 
-    fetch_info = get_preset_fetch_info(preset)
-    if fetch_info is None:
-        console.console.print(
-            f'[error]Invalid preset name/URI [item]{preset}[/item][/error]'
-        )
-        raise typer.Exit(1)
-
-    if fetch_info.is_remote():
-        preset = presets.install_from_remote(fetch_info)
-    elif fetch_info.is_local_dir():
-        preset = presets.install_from_local_dir(fetch_info)
-
-    preset_cfg = presets.get_installed_preset(preset)
-    preset_path = (
-        presets.get_preset_installation_path(preset)
-        if preset_cfg.contest is not None
-        else presets.get_preset_installation_path('default')
-    )
-
-    contest_path = (
-        presets.get_preset_installation_path(preset) / preset_cfg.contest
-        if preset_cfg.contest is not None
-        else presets.get_preset_installation_path('default') / 'contest'
-    )
-
-    if not contest_path.is_dir():
-        console.console.print(
-            f'[error]Contest template [item]{contest_path}[/item] does not exist.[/error]'
-        )
-        raise typer.Exit(1)
-
+    fetch_info = presets.get_preset_fetch_info_with_fallback(preset)
     dest_path = pathlib.Path(path)
 
     if dest_path.exists():
@@ -100,23 +64,11 @@ def create(
             )
             raise typer.Exit(1)
 
-    dest_path.mkdir(parents=True, exist_ok=True)
-    shutil.copytree(str(contest_path), str(dest_path), dirs_exist_ok=True)
-    shutil.rmtree(str(dest_path / 'build'), ignore_errors=True)
-    shutil.rmtree(str(dest_path / '.box'), ignore_errors=True)
-    shutil.rmtree(str(dest_path / '.local.rbx'), ignore_errors=True)
-    # TODO: consider clearing build and .box recursively for nested problem directories
-    for lock in dest_path.rglob('.preset-lock.yml'):
-        lock.unlink(missing_ok=True)
-
-    if local:
-        presets.copy_local_preset(
-            preset_path, dest_path, remote_uri=fetch_info.uri or preset_cfg.uri
-        )
+    presets.install_contest(dest_path, fetch_info)
 
     with cd.new_package_cd(dest_path):
         contest_utils.clear_all_caches()
-        presets.generate_lock(preset if not local else presets.LOCAL)
+        presets.generate_lock()
 
 
 @app.command('edit, e', help='Open contest.rbx.yml in your default editor.')
@@ -143,9 +95,6 @@ def add(path: str, short_name: str, preset: Optional[str] = None):
         )
         raise typer.Exit(1)
 
-    preset_lock = presets.get_preset_lock()
-    if preset is None and preset_lock is not None:
-        preset = preset_lock.preset_name
     creation.create(name, preset=preset, path=pathlib.Path(path))
 
     contest = find_contest_package_or_die()

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()}

rbx/box/contest/statements.py

@@ -10,6 +10,9 @@ 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.schema import expand_any_vars
 from rbx.box.statements.schema import StatementType
 
 app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
@@ -20,13 +23,18 @@ app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
 @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(
@@ -38,10 +46,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 or not.'),
-    ] = False,
+    vars: Annotated[
+        Optional[List[str]],
+        typer.Option(
+            '-v',
+            '--vars',
+            help='Variables to be used in the statements.',
+        ),
+    ] = None,
 ):
     contest = find_contest_package_or_die()
     # At most run the validators, only in samples.
@@ -64,26 +76,42 @@ async def build(
                     raise typer.Exit(1)
 
     contest = find_contest_package_or_die()
-    candidate_languages = languages
-    if not candidate_languages:
-        candidate_languages = sorted(set([st.language for st in contest.statements]))
-
-    for language in candidate_languages:
-        candidates_for_lang = [
-            st for st in contest.statements if st.language == language
-        ]
-        if not candidates_for_lang:
-            console.console.print(
-                f'[error]No contest-level statement found for language [item]{language}[/item].[/error]',
+
+    candidate_languages = set(languages or [])
+    candidate_names = set(names or [])
+
+    def should_process(st: ContestStatement) -> 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 contest.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)
+
+    built_statements = []
+
+    for statement in valid_statements:
+        built_statements.append(
+            build_statement(
+                statement,
+                contest,
+                output_type=output,
+                use_samples=samples,
+                custom_vars=expand_any_vars(annotations.parse_dictionary_items(vars)),
             )
-            raise typer.Exit(1)
-
-        build_statement(
-            candidates_for_lang[0],
-            contest,
-            output_type=output,
-            use_samples=samples,
-            is_editorial=editorial,
+        )
+
+    console.console.rule(title='Built statements')
+    for statement, built_path in zip(valid_statements, built_statements):
+        console.console.print(
+            f'[item]{statement.name} {statement.language}[/item] -> {href(built_path)}'
         )
 
 

rbx/box/creation.py

@@ -1,12 +1,10 @@
 import pathlib
-import shutil
 from typing import Annotated, Optional
 
 import typer
 
 from rbx import console, utils
 from rbx.box import package, presets
-from rbx.box.presets.fetch import get_preset_fetch_info
 
 
 def create(
@@ -26,33 +24,9 @@ def create(
     ] = None,
     path: Optional[pathlib.Path] = None,
 ):
-    preset = preset or 'default'
     console.console.print(f'Creating new problem [item]{name}[/item]...')
 
-    fetch_info = get_preset_fetch_info(preset)
-    if fetch_info is None:
-        console.console.print(
-            f'[error]Invalid preset name/URI [item]{preset}[/item].[/error]'
-        )
-        raise typer.Exit(1)
-
-    if fetch_info.fetch_uri is not None:
-        preset = presets.install_from_remote(fetch_info)
-
-    preset_cfg = presets.get_installed_preset(preset)
-
-    problem_path = (
-        presets.get_preset_installation_path(preset) / preset_cfg.problem
-        if preset_cfg.problem is not None
-        else presets.get_preset_installation_path('default') / 'problem'
-    )
-
-    if not problem_path.is_dir():
-        console.console.print(
-            f'[error]Problem template [item]{problem_path}[/item] does not exist.[/error]'
-        )
-        raise typer.Exit(1)
-
+    fetch_info = presets.get_preset_fetch_info_with_fallback(preset)
     dest_path = path or pathlib.Path(name)
 
     if dest_path.exists():
@@ -61,18 +35,11 @@ def create(
         )
         raise typer.Exit(1)
 
-    dest_path.parent.mkdir(parents=True, exist_ok=True)
-    shutil.copytree(str(problem_path), str(dest_path))
-
-    # Remove a few left overs.
-    shutil.rmtree(str(dest_path / 'build'), ignore_errors=True)
-    shutil.rmtree(str(dest_path / '.box'), ignore_errors=True)
-    for lock in dest_path.rglob('.preset-lock.yml'):
-        lock.unlink(missing_ok=True)
+    presets.install_problem(dest_path, fetch_info)
 
     # Change problem name.
     ru, problem = package.get_ruyaml(dest_path)
     problem['name'] = name
     utils.save_ruyaml(dest_path / 'problem.rbx.yml', ru, problem)
 
-    presets.generate_lock(preset, root=dest_path)
+    presets.generate_lock(dest_path)

rbx/box/environment.py

@@ -7,6 +7,7 @@ import typer
 from pydantic import BaseModel, ConfigDict, Field, ValidationError
 
 from rbx import config, console, utils
+from rbx.box import presets
 from rbx.box.extensions import Extensions, LanguageExtensions
 from rbx.grading.judge.sandbox import SandboxBase, SandboxParams
 from rbx.grading.judge.sandboxes.isolate import IsolateSandbox
@@ -185,22 +186,33 @@ class Environment(BaseModel):
     extensions: Optional[Extensions] = None
 
 
-def get_environment_path(env: str) -> pathlib.Path:
+def get_app_environment_path(env: str) -> pathlib.Path:
     return config.get_app_file(pathlib.PosixPath('envs') / f'{env}.rbx.yml')
 
 
-def get_local_environment_path() -> Optional[pathlib.Path]:
-    # TODO: implement logic to get env from local preset
-    return None
+def get_active_environment_path() -> pathlib.Path:
+    env_path = presets.get_preset_environment_path()
+    if env_path is None:
+        env_path = get_app_environment_path(config.get_config().boxEnvironment)
+    return env_path
+
+
+@functools.cache
+def get_active_environment_description() -> str:
+    env_path = presets.get_preset_environment_path()
+    if env_path is None:
+        return config.get_config().boxEnvironment
+    preset = presets.get_active_preset()
+    return f'preset - {preset.name}'
 
 
 @functools.cache
 def get_environment(env: Optional[str] = None) -> Environment:
     env_path = (
-        get_environment_path(env) if env is not None else get_local_environment_path()
+        get_app_environment_path(env)
+        if env is not None
+        else get_active_environment_path()
     )
-    if env_path is None:
-        env_path = get_environment_path(config.get_config().boxEnvironment)
     if not env_path.is_file():
         console.console.print(
             f'Environment file [item]{env_path}[/item] not found.', style='error'
@@ -232,8 +244,8 @@ def install_environment(name: str, file: pathlib.Path):
         )
         raise typer.Exit(1)
 
-    get_environment_path(name).parent.mkdir(parents=True, exist_ok=True)
-    get_environment_path(name).write_bytes(file.read_bytes())
+    get_app_environment_path(name).parent.mkdir(parents=True, exist_ok=True)
+    get_app_environment_path(name).write_bytes(file.read_bytes())
     console.console.print(
         f'[success]Environment [item]{name}[/item] was installed from [item]{file}[/item]'
     )

rbx/box/fields.py

@@ -0,0 +1,35 @@
+from typing import TypeVar
+
+from deepmerge import always_merger
+from pydantic import BaseModel, Field
+
+
+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
+    )
+
+
+T = TypeVar('T', bound=BaseModel)
+
+
+def merge_pydantic_models(base: T, nxt: T) -> T:
+    """Merge two Pydantic model instances.
+
+    The attributes of 'base' and 'nxt' that weren't explicitly set are dumped into dicts
+    using '.model_dump(exclude_unset=True)', which are then merged using 'deepmerge',
+    and the merged result is turned into a model instance using '.model_validate'.
+
+    For attributes set on both 'base' and 'nxt', the value from 'nxt' will be used in
+    the output result.
+    """
+    base_dict = base.model_dump(exclude_unset=True)
+    nxt_dict = nxt.model_dump(exclude_unset=True)
+    merged_dict = always_merger.merge(base_dict, nxt_dict)
+    return base.model_validate(merged_dict)

rbx/box/lang.py

@@ -0,0 +1,27 @@
+import functools
+from typing import List
+
+import iso639
+
+from rbx import console
+
+
+def code_to_langs(langs: List[str]) -> List[str]:
+    return [iso639.Language.from_part1(lang).name.lower() for lang in langs]
+
+
+@functools.cache
+def is_valid_lang_code(lang: str) -> bool:
+    try:
+        code_to_langs([lang])
+    except iso639.LanguageNotFoundError:
+        console.console.print(
+            f'[warning]Language [item]{lang}[/item] is being skipped because it is not a iso639 language.[/warning]'
+        )
+        return False
+
+    return True
+
+
+def langs_to_code(langs: List[str]) -> List[str]:
+    return [iso639.Language.from_name(lang).part1 for lang in langs]

rbx/box/linting.py

@@ -0,0 +1,26 @@
+import pathlib
+
+import yamlfix
+import yamlfix.model
+
+from rbx import console
+from rbx.box.cd import is_contest_package, is_problem_package
+from rbx.box.stats import find_problem_packages_from_contest
+
+
+def fix_yaml(path: pathlib.Path, verbose: bool = True):
+    config = yamlfix.model.YamlfixConfig(quote_basic_values=True)
+    _, changed = yamlfix.fix_files([str(path)], dry_run=False, config=config)
+    if changed and verbose:
+        console.console.print(
+            f'Formatting [item]{path}[/item].',
+        )
+
+
+def fix_package(root: pathlib.Path = pathlib.Path()):
+    if is_problem_package(root):
+        fix_yaml(root / 'problem.rbx.yml')
+    if is_contest_package(root):
+        fix_yaml(root / 'contest.rbx.yml')
+        for problem in find_problem_packages_from_contest(root):
+            fix_yaml(problem / 'problem.rbx.yml')

rbx/box/package.py

@@ -10,10 +10,9 @@ import ruyaml
 import typer
 from pydantic import ValidationError
 
-from rbx import config, console, utils
-from rbx.box import cd, environment
+from rbx import console, utils
+from rbx.box import cd
 from rbx.box.environment import get_sandbox_type
-from rbx.box.presets import get_installed_preset_or_null, get_preset_lock
 from rbx.box.schema import (
     CodeItem,
     ExpectedOutcome,
@@ -38,33 +37,6 @@ TEMP_DIR = None
 CACHE_STEP_VERSION = 1
 
 
-def warn_preset_deactivated(root: pathlib.Path = pathlib.Path()):
-    preset_lock = get_preset_lock(root)
-    if preset_lock is None:
-        return
-
-    preset = get_installed_preset_or_null(preset_lock.preset_name)
-    if preset is None:
-        console.console.print(
-            f'[warning]WARNING: [item]{preset_lock.preset_name}[/item] is not installed. '
-            'Run [item]rbx presets sync && rbx activate[/item] to install and activate this preset.'
-        )
-        console.console.print()
-        return
-
-    if preset.env is not None and (
-        not environment.get_environment_path(preset.name).is_file()
-        or config.get_config().boxEnvironment != preset.name
-    ):
-        console.console.print(
-            '[warning]WARNING: This package uses a preset that configures a custom environment, '
-            f' but instead you are using the environment [item]{config.get_config().boxEnvironment}[/item]. '
-            'Run [item]rbx activate[/item] to use the environment configured by your preset.'
-        )
-        console.console.print()
-        return
-
-
 @functools.cache
 def find_problem_yaml(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Path]:
     root = root.resolve()
@@ -74,7 +46,6 @@ def find_problem_yaml(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.P
         problem_yaml_path = root / YAML_NAME
     if not problem_yaml_path.is_file():
         return None
-    warn_preset_deactivated(root)
     return problem_yaml_path
 
 
@@ -130,9 +101,7 @@ def save_package(
 def get_ruyaml(root: pathlib.Path = pathlib.Path()) -> Tuple[ruyaml.YAML, ruyaml.Any]:
     problem_yaml_path = find_problem_yaml(root)
     if problem_yaml_path is None:
-        console.console.print(
-            f'Problem not found in {pathlib.Path().absolute()}', style='error'
-        )
+        console.console.print(f'[error]Problem not found in {root.absolute()}[/error]')
         raise typer.Exit(1)
     res = ruyaml.YAML()
     return res, res.load(problem_yaml_path.read_text())
@@ -459,7 +428,7 @@ def get_merged_capture_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path
 def is_cache_valid(root: pathlib.Path = pathlib.Path()):
     cache_dir = find_problem(root) / '.box'
     if not cache_dir.is_dir():
-        return
+        return True
 
     fingerprint_file = cache_dir / 'fingerprint'
     if not fingerprint_file.is_file():