rbx.cp 0.5.0__py3-none-any.whl

rbx/box/contest/schema.py

@@ -0,0 +1,155 @@
+import pathlib
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from rbx.box.schema import NameField, Primitive, expand_var
+from rbx.box.statements.schema import (
+    ConversionStep,
+    Joiner,
+    StatementType,
+)
+
+
+def ShortNameField(**kwargs):
+    return Field(pattern=r'^[A-Z]+[0-9]*$', min_length=1, max_length=4, **kwargs)
+
+
+class ProblemStatementOverride(BaseModel):
+    model_config = ConfigDict(extra='forbid')
+
+    configure: List[ConversionStep] = Field(
+        [],
+        discriminator='type',
+        description="""
+Configure how certain conversion steps should happen when applied to the statement file.
+
+Different from the `steps` field, this does not force the steps to happen, but rather only
+configure them in case they are applied.
+""",
+    )
+
+
+class ContestStatement(BaseModel):
+    model_config = ConfigDict(extra='forbid')
+
+    language: str = Field('en', description='Language code for this statement.')
+
+    title: str = Field(description='Title of the contest in this language.')
+
+    location: Optional[str] = Field(
+        default=None, description='Location of the contest in this language.'
+    )
+
+    date: Optional[str] = Field(
+        default=None, description='Date of the contest in this language.'
+    )
+
+    path: pathlib.Path = Field(description='Path to the input statement file.')
+
+    type: StatementType = Field(description='Type of the input statement file.')
+
+    joiner: Optional[Joiner] = Field(
+        None,
+        description="""
+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(
+        default=[],
+        discriminator='type',
+        description="""
+Describes a sequence of conversion steps that should be applied to the statement file
+of this contest.
+
+Usually, it is not necessary to specify these, as they can be inferred from the
+input statement type and the output statement type, but you can use this to force
+certain conversion steps to happen.
+""",
+    )
+
+    configure: List[ConversionStep] = Field(
+        default=[],
+        discriminator='type',
+        description="""
+Configure how certain conversion steps should happen when applied to the statement file of
+this contest.
+
+Different from the `steps` field, this does not force the steps to happen, but rather only
+configure them in case they are applied.
+""",
+    )
+
+    assets: List[str] = Field(
+        default=[],
+        description="""
+Assets relative to the contest directory that should be included while building
+the statement. Files will be included in the same folder as the statement file.
+Can be glob pattern as well, such as `imgs/*.png`.
+""",
+    )
+
+    override: Optional[ProblemStatementOverride] = Field(
+        default=None, description='Override configuration for problem statements.'
+    )
+
+    # 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(
+        {}, 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()}
+
+
+class ContestProblem(BaseModel):
+    short_name: str = ShortNameField(
+        description="""
+Short name of the problem. Usually, just an uppercase letter,
+but can be a sequence of uppercase letters followed by a number."""
+    )
+    path: Optional[pathlib.Path] = Field(
+        default=None,
+        description="""
+Path to the problem relative to the contest package directory.
+If not specified, will expect the problem to be in ./{short_name}/ folder.""",
+    )
+
+    color: Optional[str] = Field(
+        default=None,
+        description="""Hex-based color that represents this problem in the contest.""",
+        pattern=r'^[A-Za-z0-9]+$',
+        max_length=6,
+    )
+
+    def get_path(self) -> pathlib.Path:
+        return self.path or pathlib.Path(self.short_name)
+
+
+class Contest(BaseModel):
+    model_config = ConfigDict(extra='forbid')
+
+    name: str = NameField(description='Name of this contest.')
+
+    problems: List[ContestProblem] = Field(
+        default=[], description='List of problems in this contest.'
+    )
+
+    statements: List[ContestStatement] = Field(
+        default=None,
+        description='Configure statements in this contest, per language.',
+    )
+
+    # 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(
+        {}, 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()}

rbx/box/contest/statements.py

@@ -0,0 +1,82 @@
+from typing import Annotated, List, Optional
+
+import typer
+
+from rbx import annotations, console, utils
+from rbx.box import builder, environment
+from rbx.box.contest import contest_utils
+from rbx.box.contest.build_contest_statements import build_statement
+from rbx.box.contest.contest_package import (
+    find_contest_package_or_die,
+    within_contest,
+)
+from rbx.box.statements.schema import StatementType
+
+app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
+
+
+@app.command('build, b', help='Build statements.')
+@within_contest
+def build(
+    verification: environment.VerificationParam,
+    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.',
+        ),
+    ],
+    output: Annotated[
+        Optional[StatementType],
+        typer.Option(
+            case_sensitive=False,
+            help='Output type to be generated. If not specified, will infer from the conversion steps specified in the package.',
+        ),
+    ] = StatementType.PDF,
+    samples: Annotated[
+        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,
+):
+    contest = find_contest_package_or_die()
+    # At most run the validators, only in samples.
+    if samples:
+        for problem in contest.problems:
+            console.console.print(
+                f'Processing problem [item]{problem.short_name}[/item]...'
+            )
+            with utils.new_cd(problem.get_path()):
+                contest_utils.clear_package_cache()
+                builder.build(verification=verification, groups=set(['samples']))
+
+    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]',
+            )
+            raise typer.Exit(1)
+
+        build_statement(
+            candidates_for_lang[0],
+            contest,
+            output_type=output,
+            use_samples=samples,
+            is_editorial=editorial,
+        )
+
+
+@app.callback()
+def callback():
+    pass

rbx/box/creation.py

@@ -0,0 +1,72 @@
+import pathlib
+import shutil
+from typing import Annotated, Optional
+
+import typer
+
+from rbx import console
+from rbx.box import presets
+from rbx.box.presets.fetch import get_preset_fetch_info
+
+
+def create(
+    name: Annotated[
+        str,
+        typer.Argument(
+            help='The name of the problem package to create. This will also be the name of the folder.'
+        ),
+    ],
+    preset: Annotated[
+        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.',
+        ),
+    ] = 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)
+
+    dest_path = path or 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(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.generate_lock(preset, root=dest_path)

rbx/box/download.py

@@ -0,0 +1,64 @@
+import pathlib
+import shutil
+from typing import Optional
+
+import typer
+
+from rbx import annotations, console
+from rbx.box import package
+from rbx.box.schema import CodeItem
+from rbx.config import get_builtin_checker, get_jngen, get_testlib
+from rbx.grading import steps
+
+app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
+
+
+def get_local_artifact(name: str) -> Optional[steps.GradingFileInput]:
+    path = pathlib.Path(name)
+    if path.is_file():
+        return steps.GradingFileInput(src=path, dest=path)
+    return None
+
+
+def maybe_add_testlib(code: CodeItem, artifacts: steps.GradingArtifacts):
+    # Try to get from compilation files, then from package folder, then from tool.
+    artifact = get_local_artifact('testlib.h') or steps.testlib_grading_input()
+    compilation_files = package.get_compilation_files(code)
+    if any(dest == artifact.dest for _, dest in compilation_files):
+        return
+    artifacts.inputs.append(artifact)
+
+
+def maybe_add_jngen(code: CodeItem, artifacts: steps.GradingArtifacts):
+    # Try to get from compilation files, then from package folder, then from tool.
+    artifact = get_local_artifact('jngen.h') or steps.jngen_grading_input()
+    compilation_files = package.get_compilation_files(code)
+    if any(dest == artifact.dest for _, dest in compilation_files):
+        return
+    artifacts.inputs.append(artifact)
+
+
+@app.command('testlib', help='Download testlib.h')
+@package.within_problem
+def testlib():
+    shutil.copyfile(get_testlib(), pathlib.Path('testlib.h'))
+    console.console.print('Downloaded [item]testlib.h[/item] into current package.')
+
+
+@app.command('jngen', help='Download jngen.h')
+@package.within_problem
+def jngen():
+    shutil.copyfile(get_jngen(), pathlib.Path('jngen.h'))
+    console.console.print('Downloaded [item]jngen.h[/item] into current package.')
+
+
+@app.command('checker', help='Download a built-in checker from testlib GH repo.')
+@package.within_problem
+def checker(name: str):
+    if not name.endswith('.cpp'):
+        name = f'{name}.cpp'
+    path = get_builtin_checker(name)
+    shutil.copyfile(path, pathlib.Path(name))
+    console.console.print(
+        f'[success]Downloaded [item]{name}[/item] into current package.[/success]'
+    )