rbx.cp 0.5.0__py3-none-any.whl

rbx/box/contest/build_contest_statements.py

@@ -0,0 +1,347 @@
+import dataclasses
+import pathlib
+import tempfile
+import typing
+from typing import List, Optional, Tuple
+
+import typer
+
+from rbx import console, testing_utils, utils
+from rbx.box.contest import contest_utils
+from rbx.box.contest.contest_package import get_problems
+from rbx.box.contest.schema import Contest, ContestProblem, ContestStatement
+from rbx.box.schema import Package, Testcase
+from rbx.box.statements import build_statements
+from rbx.box.statements.build_statements import (
+    get_builders,
+    get_environment_languages_for_statement,
+    get_relative_assets,
+)
+from rbx.box.statements.builders import (
+    CONTEST_BUILDER_LIST,
+    StatementBuilderContest,
+    StatementBuilderContext,
+    StatementBuilderProblem,
+    prepare_assets,
+)
+from rbx.box.statements.joiners import (
+    JOINER_LIST,
+    StatementJoiner,
+    StatementJoinerContext,
+)
+from rbx.box.statements.schema import Statement, StatementType
+from rbx.box.testcases import get_samples
+
+
+@dataclasses.dataclass
+class ExtractedProblem:
+    package: Package
+    statement: Statement
+    problem: ContestProblem
+    samples: List[Testcase]
+    built_statement: Optional[pathlib.Path] = None
+
+    def get_statement_path(self) -> pathlib.Path:
+        return self.problem.get_path() / self.statement.path
+
+    def get_statement_assets(self) -> List[str]:
+        return [str(self.problem.get_path() / asset) for asset in self.statement.assets]
+
+    def get_statement_builder_problem(self) -> StatementBuilderProblem:
+        return StatementBuilderProblem(
+            package=self.package,
+            statement=self.statement,
+            samples=self.samples,
+            io_path=self.built_statement,
+            short_name=self.problem.short_name,
+        )
+
+
+def _get_samples(problem: ContestProblem) -> List[Testcase]:
+    with utils.new_cd(problem.get_path()):
+        contest_utils.clear_package_cache()
+        return get_samples()
+
+
+def get_statement_builder_problems(
+    extracted_problems: List[ExtractedProblem],
+) -> List[StatementBuilderProblem]:
+    return [ex.get_statement_builder_problem() for ex in extracted_problems]
+
+
+def get_statement_builder_contest(
+    statement: ContestStatement,
+    extracted_problems: List[ExtractedProblem],
+) -> StatementBuilderContest:
+    return StatementBuilderContest(
+        title=statement.title,
+        location=statement.location,
+        date=statement.date,
+        problems=get_statement_builder_problems(extracted_problems),
+    )
+
+
+def get_problems_for_statement(
+    contest: Contest,
+    language: str,
+    requires_matching_statement: bool = True,
+) -> List[ExtractedProblem]:
+    pkgs = get_problems(contest)
+    if not pkgs:
+        console.console.print(
+            '[error]No problems found in the contest, cannot infer statement type.[/error]'
+        )
+        raise typer.Exit(1)
+
+    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:
+            console.console.print(
+                f'[error]No statement found for language {language} in problem {problem.short_name}[/error]'
+            )
+            raise typer.Exit(1)
+
+    return res
+
+
+def get_builder_problems(
+    extracted_problems: List[ExtractedProblem],
+) -> List[StatementBuilderProblem]:
+    return [
+        StatementBuilderProblem(
+            package=ex.package,
+            statement=ex.statement,
+            samples=ex.samples,
+        )
+        for ex in extracted_problems
+    ]
+
+
+def get_joiner(name: str) -> StatementJoiner:
+    for joiner in JOINER_LIST:
+        if joiner.name() == name:
+            return joiner
+    console.console.print(f'[error]Joiner [item]{name}[/item] not found.[/error]')
+    raise typer.Exit(1)
+
+
+def _build_problem_statements(
+    statement: ContestStatement,
+    contest: Contest,
+    root: pathlib.Path,
+    output_type: StatementType,
+    use_samples: bool = True,
+    is_editorial: bool = False,
+) -> List[ExtractedProblem]:
+    console.console.print('Building problem-level statements...')
+    extracted_problems = get_problems_for_statement(contest, statement.language)
+    res = []
+    contest_cwd_absolute = pathlib.Path().resolve()
+    contest_assets = get_relative_assets(statement.path, statement.assets)
+
+    for extracted_problem in extracted_problems:
+        console.console.print(
+            f'Building statement for problem {extracted_problem.problem.short_name}...'
+        )
+        with utils.new_cd(extracted_problem.problem.get_path()):
+            contest_utils.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,
+                is_editorial=is_editorial,
+            )
+        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)
+        dest_path.write_bytes(content)
+
+        problem_assets = (
+            get_relative_assets(
+                extracted_problem.get_statement_path(),
+                extracted_problem.get_statement_assets(),
+            )
+            + contest_assets
+        )
+        prepare_assets(problem_assets, dest_dir)
+
+        res.append(dataclasses.replace(extracted_problem, built_statement=dest_path))
+    return res
+
+
+def build_contest_only(
+    statement: ContestStatement,
+    contest: Contest,
+    extracted_problems: List[ExtractedProblem],
+    input: bytes,
+    input_type: StatementType,
+    output_type: Optional[StatementType] = None,
+    is_editorial: bool = False,
+) -> Tuple[bytes, StatementType]:
+    console.console.print('Building contest-level statement.')
+    bdrs = get_builders(
+        contest.name,
+        statement.steps,
+        statement.configure,
+        input_type,
+        output_type=output_type,
+        builder_list=CONTEST_BUILDER_LIST,
+    )
+
+    last_content = input
+    last_output = input_type
+    for bdr, params in bdrs:
+        with tempfile.TemporaryDirectory() as td:
+            assets = get_relative_assets(
+                statement.path, statement.assets
+            ) + bdr.inject_assets(pathlib.Path(), params)
+            prepare_assets(assets, pathlib.Path(td))
+            output = bdr.build(
+                input=last_content,
+                context=StatementBuilderContext(
+                    languages=get_environment_languages_for_statement(),
+                    params=params,
+                    root=pathlib.Path(td),
+                    editorial=is_editorial,
+                    vars={**contest.expanded_vars, **statement.expanded_vars},
+                ),
+                item=get_statement_builder_contest(statement, extracted_problems),
+                verbose=False,
+            )
+        last_content = output
+        last_output = bdr.output_type()
+
+    return last_content, last_output
+
+
+def build_statement_rooted(
+    statement: ContestStatement,
+    contest: Contest,
+    root: pathlib.Path,
+    output_type: Optional[StatementType] = None,
+    use_samples: bool = True,
+    is_editorial: bool = False,
+) -> Tuple[bytes, StatementType]:
+    # Validate.
+    if not statement.path.is_file():
+        console.console.print(
+            f'[error]Statement file [item]{statement.path}[/item] does not exist for contest.[/error]'
+        )
+        raise typer.Exit(1)
+
+    if statement.joiner is None:
+        joiner = None
+        extracted_problems = get_problems_for_statement(
+            contest, statement.language, requires_matching_statement=False
+        )
+    else:
+        # Build problem-level statements.
+        joiner = get_joiner(statement.joiner.type)
+        extracted_problems = _build_problem_statements(
+            statement,
+            contest,
+            root,
+            output_type=joiner.joined_type(),
+            use_samples=use_samples,
+            is_editorial=is_editorial,
+        )
+
+    # Build contest-level statement into joiner input type.
+    last_content, last_output = build_contest_only(
+        statement,
+        contest,
+        extracted_problems,
+        statement.path.read_bytes(),
+        statement.type,
+        output_type=joiner.joined_type() if joiner is not None else output_type,
+        is_editorial=is_editorial,
+    )
+
+    if joiner is None:
+        return last_content, last_output
+
+    # Join statements.
+    console.console.print('Joining statements...')
+    joiner_assets = get_relative_assets(statement.path, statement.assets)
+    prepare_assets(joiner_assets, root)
+
+    testing_utils.print_directory_tree(root, show_hidden=True)
+
+    joiner_context = StatementJoinerContext(
+        languages=get_environment_languages_for_statement(),
+        params=statement.joiner,
+        root=root,
+    )
+    last_content = joiner.build(
+        last_content,
+        context=joiner_context,
+        contest=get_statement_builder_contest(statement, extracted_problems),
+    )
+    last_output = joiner.output_type()
+
+    # Finish statement.
+    last_content, last_output = build_contest_only(
+        statement,
+        contest,
+        extracted_problems,
+        last_content,
+        last_output,
+        output_type=output_type,
+        is_editorial=is_editorial,
+    )
+
+    return last_content, last_output
+
+
+def build_statement(
+    statement: ContestStatement,
+    contest: Contest,
+    output_type: Optional[StatementType] = None,
+    use_samples: bool = True,
+    is_editorial: bool = False,
+) -> pathlib.Path:
+    with tempfile.TemporaryDirectory() as td:
+        root = pathlib.Path(td)
+        last_content, last_output = build_statement_rooted(
+            statement,
+            contest,
+            root,
+            output_type=output_type,
+            use_samples=use_samples,
+            is_editorial=is_editorial,
+        )
+
+    statement_path = pathlib.Path(
+        f'build/{statement.path.stem}{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'[item]{statement.language}[/item] at '
+        f'[item]{statement_path}[/item].'
+    )
+    return statement_path

rbx/box/contest/contest_package.py

@@ -0,0 +1,76 @@
+import functools
+import pathlib
+from typing import List, Optional
+
+import typer
+
+from rbx import console, utils
+from rbx.box.contest.schema import Contest
+from rbx.box.package import find_problem_package_or_die, warn_preset_deactivated
+from rbx.box.schema import Package
+
+YAML_NAME = 'contest.rbx.yml'
+
+
+@functools.cache
+def find_contest_yaml(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Path]:
+    root = root.resolve()
+    contest_yaml_path = root / YAML_NAME
+    while root != pathlib.PosixPath('/') and not contest_yaml_path.is_file():
+        root = root.parent
+        contest_yaml_path = root / YAML_NAME
+    if not contest_yaml_path.is_file():
+        return None
+    warn_preset_deactivated(root)
+    return contest_yaml_path
+
+
+@functools.cache
+def find_contest_package(root: pathlib.Path = pathlib.Path()) -> Optional[Contest]:
+    contest_yaml_path = find_contest_yaml(root)
+    if not contest_yaml_path:
+        return None
+    return utils.model_from_yaml(Contest, contest_yaml_path.read_text())
+
+
+def find_contest_package_or_die(root: pathlib.Path = pathlib.Path()) -> Contest:
+    package = find_contest_package(root)
+    if package is None:
+        console.console.print(f'Contest not found in {root.absolute()}', style='error')
+        raise typer.Exit(1)
+    return package
+
+
+def find_contest(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
+    found = find_contest_yaml(root)
+    if found is None:
+        console.console.print(f'Contest not found in {root.absolute()}', style='error')
+        raise typer.Exit(1)
+    return found.parent
+
+
+def within_contest(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        with utils.new_cd(find_contest()):
+            return func(*args, **kwargs)
+
+    return wrapper
+
+
+def save_contest(
+    package: Optional[Contest] = None, root: pathlib.Path = pathlib.Path()
+) -> None:
+    package = package or find_contest_package_or_die(root)
+    contest_yaml_path = find_contest_yaml(root)
+    if not contest_yaml_path:
+        console.console.print(f'Contest not found in {root.absolute()}', style='error')
+        raise typer.Exit(1)
+    contest_yaml_path.write_text(utils.model_to_yaml(package))
+
+
+def get_problems(contest: Contest) -> List[Package]:
+    problems = []
+    for problem in contest.problems:
+        problems.append(find_problem_package_or_die(problem.get_path()))
+    return problems

rbx/box/contest/contest_utils.py

@@ -0,0 +1,20 @@
+from rbx.box import environment, package
+from rbx.box.contest import contest_package
+
+
+def clear_package_cache():
+    pkgs = [package]
+
+    for pkg in pkgs:
+        for fn in pkg.__dict__.values():
+            if hasattr(fn, 'cache_clear'):
+                fn.cache_clear()
+
+
+def clear_all_caches():
+    pkgs = [package, environment, contest_package]
+
+    for pkg in pkgs:
+        for fn in pkg.__dict__.values():
+            if hasattr(fn, 'cache_clear'):
+                fn.cache_clear()

rbx/box/contest/main.py

@@ -0,0 +1,179 @@
+import pathlib
+import shutil
+import subprocess
+from typing import Annotated, Optional
+
+import typer
+
+from rbx import annotations, console, utils
+from rbx.box import creation, presets
+from rbx.box.contest import contest_utils, statements
+from rbx.box.contest.contest_package import (
+    find_contest,
+    find_contest_package_or_die,
+    find_contest_yaml,
+    save_contest,
+    within_contest,
+)
+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
+
+app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
+app.add_typer(
+    statements.app,
+    name='statements, st',
+    cls=annotations.AliasGroup,
+    help='Manage contest-level statements.',
+)
+app.add_typer(
+    packaging.app,
+    name='package, pkg',
+    cls=annotations.AliasGroup,
+    help='Build contest-level packages.',
+)
+
+
+@app.command('create, c', help='Create a new contest package.')
+@within_contest
+def create(
+    name: str,
+    preset: Annotated[
+        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.',
+        ),
+    ] = 'default',
+    local: bool = typer.Option(
+        False,
+        '--local',
+        '-l',
+        help='Whether to inline the installed preset within the contest folder.',
+    ),
+):
+    console.console.print(f'Creating new contest [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)
+    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)
+
+    dest_path = pathlib.Path(name)
+
+    if dest_path.exists():
+        console.console.print(
+            f'[error]Directory [item]{dest_path}[/item] already exists.[/error]'
+        )
+        raise typer.Exit(1)
+
+    shutil.copytree(str(contest_path), str(dest_path))
+    shutil.rmtree(str(dest_path / 'build'), ignore_errors=True)
+    shutil.rmtree(str(dest_path / '.box'), 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:
+        shutil.copytree(str(preset_path), str(dest_path / '.local.rbx'))
+
+    with utils.new_cd(dest_path):
+        contest_utils.clear_all_caches()
+        presets.generate_lock(preset if not local else presets.LOCAL)
+
+
+@app.command('edit, e', help='Open contest.rbx.yml in your default editor.')
+@within_contest
+def edit():
+    console.console.print('Opening contest definition in editor...')
+    # Call this function just to raise exception in case we're no in
+    # a problem package.
+    find_contest()
+    open_editor(find_contest_yaml() or pathlib.Path())
+
+
+@app.command('add, a', help='Add new problem to contest.')
+@within_contest
+def add(name: str, short_name: str, preset: Optional[str] = None):
+    utils.validate_field(ContestProblem, 'short_name', short_name)
+    utils.validate_field(Package, 'name', name)
+
+    if short_name in [p.short_name for p in find_contest_package_or_die().problems]:
+        console.console.print(
+            f'[error]Problem [item]{short_name}[/item] already exists in contest.[/error]',
+        )
+        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(short_name))
+
+    contest = find_contest_package_or_die()
+    # Reassign mutable object before saving.
+    contest.problems = sorted(
+        [
+            *contest.problems,
+            ContestProblem(short_name=short_name, path=pathlib.Path(short_name)),
+        ],
+        key=lambda p: p.short_name,
+    )
+
+    save_contest(contest)
+    console.console.print(f'Problem [item]{short_name}[/item] added to contest.')
+
+
+@app.command(
+    'each',
+    help='Run a command for each problem in the contest.',
+    context_settings={'allow_extra_args': True, 'ignore_unknown_options': True},
+)
+@within_contest
+def each(ctx: typer.Context) -> None:
+    command = ' '.join(['rbx'] + ctx.args)
+    contest = find_contest_package_or_die()
+    ok = True
+    for problem in contest.problems:
+        console.console.print(
+            f'[status]Running [item]{command}[/item] for [item]{problem.short_name}[/item]...[/status]'
+        )
+
+        retcode = subprocess.call(
+            command,
+            cwd=problem.get_path(),
+            shell=True,
+        )
+        ok = ok and retcode == 0
+        console.console.print()
+
+    if not ok:
+        console.console.print(
+            '[error]One of the commands above failed. Check the output![/error]'
+        )