rbx.cp 0.5.0__py3-none-any.whl

rbx/box/package.py

@@ -0,0 +1,316 @@
+import functools
+import pathlib
+from typing import Dict, List, Optional, Tuple
+
+import typer
+
+from rbx import config, console, utils
+from rbx.box import environment
+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,
+    Generator,
+    Package,
+    Solution,
+    Stress,
+    TestcaseGroup,
+    TestcaseSubgroup,
+)
+from rbx.config import get_builtin_checker
+from rbx.grading.caching import DependencyCache
+from rbx.grading.judge.cacher import FileCacher
+from rbx.grading.judge.sandbox import SandboxBase
+from rbx.grading.judge.storage import FilesystemStorage, Storage
+
+YAML_NAME = 'problem.rbx.yml'
+_DEFAULT_CHECKER = 'wcmp.cpp'
+TEMP_DIR = None
+
+
+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()
+    problem_yaml_path = root / YAML_NAME
+    while root != pathlib.PosixPath('/') and not problem_yaml_path.is_file():
+        root = root.parent
+        problem_yaml_path = root / YAML_NAME
+    if not problem_yaml_path.is_file():
+        return None
+    warn_preset_deactivated(root)
+    return problem_yaml_path
+
+
+@functools.cache
+def find_problem_package(root: pathlib.Path = pathlib.Path()) -> Optional[Package]:
+    problem_yaml_path = find_problem_yaml(root)
+    if not problem_yaml_path:
+        return None
+    return utils.model_from_yaml(Package, problem_yaml_path.read_text())
+
+
+def find_problem_package_or_die(root: pathlib.Path = pathlib.Path()) -> Package:
+    package = find_problem_package(root)
+    if package is None:
+        console.console.print(f'[error]Problem not found in {root.absolute()}[/error]')
+        raise typer.Exit(1)
+    return package
+
+
+def find_problem(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
+    found = find_problem_yaml(root)
+    if found is None:
+        console.console.print(f'[error]Problem not found in {root.absolute()}[/error]')
+        raise typer.Exit(1)
+    return found.parent
+
+
+def within_problem(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        with utils.new_cd(find_problem()):
+            return func(*args, **kwargs)
+
+    return wrapper
+
+
+def save_package(
+    package: Optional[Package] = None, root: pathlib.Path = pathlib.Path()
+) -> None:
+    package = package or find_problem_package_or_die(root)
+    problem_yaml_path = find_problem_yaml(root)
+    if not problem_yaml_path:
+        console.console.print(f'[error]Problem not found in {root.absolute()}[/error]')
+        raise typer.Exit(1)
+    problem_yaml_path.write_text(utils.model_to_yaml(package))
+
+
+@functools.cache
+def get_problem_cache_dir(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
+    cache_dir = find_problem(root) / '.box'
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    return cache_dir
+
+
+@functools.cache
+def get_problem_storage_dir(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
+    storage_dir = get_problem_cache_dir(root) / '.storage'
+    storage_dir.mkdir(parents=True, exist_ok=True)
+    return storage_dir
+
+
+def get_problem_runs_dir(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
+    runs_dir = get_problem_cache_dir(root) / 'runs'
+    runs_dir.mkdir(parents=True, exist_ok=True)
+    return runs_dir
+
+
+@functools.cache
+def get_cache_storage(root: pathlib.Path = pathlib.Path()) -> Storage:
+    return FilesystemStorage(get_problem_storage_dir(root))
+
+
+@functools.cache
+def get_dependency_cache(root: pathlib.Path = pathlib.Path()) -> DependencyCache:
+    return DependencyCache(get_problem_cache_dir(root), get_cache_storage(root))
+
+
+@functools.cache
+def get_file_cacher(root: pathlib.Path = pathlib.Path()) -> FileCacher:
+    return FileCacher(get_cache_storage(root))
+
+
+@functools.cache
+def get_digest_as_string(
+    digest: str, root: pathlib.Path = pathlib.Path()
+) -> Optional[str]:
+    cacher = get_file_cacher(root)
+    try:
+        content = cacher.get_file_content(digest)
+        return content.decode()
+    except KeyError:
+        return None
+
+
+def get_new_sandbox(root: pathlib.Path = pathlib.Path()) -> SandboxBase:
+    return get_sandbox_type()(file_cacher=get_file_cacher(root), temp_dir=TEMP_DIR)
+
+
+@functools.cache
+def get_singleton_sandbox(root: pathlib.Path = pathlib.Path()) -> SandboxBase:
+    return get_new_sandbox(root)
+
+
+@functools.cache
+def get_build_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
+    return find_problem(root) / 'build'
+
+
+@functools.cache
+def get_build_tests_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
+    return get_build_path(root) / 'tests'
+
+
+@functools.cache
+def get_build_testgroup_path(
+    group: str, root: pathlib.Path = pathlib.Path()
+) -> pathlib.Path:
+    res = get_build_tests_path(root) / group
+    res.mkdir(exist_ok=True, parents=True)
+    return res
+
+
+@functools.cache
+def get_generator(name: str, root: pathlib.Path = pathlib.Path()) -> Generator:
+    package = find_problem_package_or_die(root)
+    for generator in package.generators:
+        if generator.name == name:
+            return generator
+    console.console.print(f'[error]Generator [item]{name}[/item] not found[/error]')
+    raise typer.Exit(1)
+
+
+@functools.cache
+def get_validator(root: pathlib.Path = pathlib.Path()) -> CodeItem:
+    package = find_problem_package_or_die(root)
+    if package.validator is None:
+        console.console.print(
+            '[error]Problem does not have a validator configured.[/error]'
+        )
+        raise typer.Exit(1)
+    return package.validator
+
+
+@functools.cache
+def get_checker(root: pathlib.Path = pathlib.Path()) -> CodeItem:
+    package = find_problem_package_or_die(root)
+
+    return package.checker or CodeItem(
+        path=get_builtin_checker(_DEFAULT_CHECKER).absolute()
+    )
+
+
+@functools.cache
+def get_solutions(root: pathlib.Path = pathlib.Path()) -> List[Solution]:
+    package = find_problem_package_or_die(root)
+    return package.solutions
+
+
+@functools.cache
+def get_main_solution(root: pathlib.Path = pathlib.Path()) -> Optional[Solution]:
+    for solution in get_solutions(root):
+        if solution.outcome == ExpectedOutcome.ACCEPTED:
+            return solution
+    return None
+
+
+@functools.cache
+def get_solution(name: str, root: pathlib.Path = pathlib.Path()) -> Solution:
+    for solution in get_solutions(root):
+        if str(solution.path) == name:
+            return solution
+    console.console.print(f'[error]Solution [item]{name}[/item] not found[/error]')
+    raise typer.Exit(1)
+
+
+@functools.cache
+def get_solution_or_nil(
+    name: str, root: pathlib.Path = pathlib.Path()
+) -> Optional[Solution]:
+    for solution in get_solutions(root):
+        if str(solution.path) == name:
+            return solution
+    return None
+
+
+@functools.cache
+def get_stress(name: str, root: pathlib.Path = pathlib.Path()) -> Stress:
+    pkg = find_problem_package_or_die(root)
+    for stress in pkg.stresses:
+        if stress.name == name:
+            return stress
+    console.console.print(f'[error]Stress [item]{name}[/item] not found[/error]')
+    raise typer.Exit(1)
+
+
+@functools.cache
+def get_testgroup(name: str, root: pathlib.Path = pathlib.Path()) -> TestcaseGroup:
+    pkg = find_problem_package_or_die(root)
+    for testgroup in pkg.testcases:
+        if testgroup.name == name:
+            return testgroup
+    console.console.print(f'[error]Test group [item]{name}[/item] not found[/error]')
+    raise typer.Exit(1)
+
+
+@functools.cache
+def get_test_groups_by_name(
+    root: pathlib.Path = pathlib.Path(),
+) -> Dict[str, TestcaseSubgroup]:
+    pkg = find_problem_package_or_die(root)
+    res = {}
+
+    for testgroup in pkg.testcases:
+        res[testgroup.name] = testgroup
+        for subgroup in testgroup.subgroups:
+            res[f'{testgroup.name}.{subgroup.name}'] = subgroup
+
+    return res
+
+
+# Return each compilation file and to where it should be moved inside
+# the sandbox.
+def get_compilation_files(code: CodeItem) -> List[Tuple[pathlib.Path, pathlib.Path]]:
+    code_dir = code.path.parent.resolve()
+
+    res = []
+    for compilation_file in code.compilationFiles or []:
+        compilation_file_path = pathlib.Path(compilation_file).resolve()
+        if not compilation_file_path.is_file():
+            console.console.print(
+                f'[error]Compilation file [item]{compilation_file}[/item] for '
+                f'code [item]{code.path}[/item] does not exist.[/error]',
+            )
+            raise typer.Exit(1)
+        if not compilation_file_path.is_relative_to(code_dir):
+            console.console.print(
+                f'[error]Compilation file [item]{compilation_file}[/item] for '
+                f"code [item]{code.path}[/item] is not under the code's folder.[/error]",
+            )
+            raise typer.Exit(1)
+
+        res.append(
+            (
+                pathlib.Path(compilation_file),
+                compilation_file_path.relative_to(code_dir),
+            )
+        )
+    return res

rbx/box/packaging/boca/extension.py

@@ -0,0 +1,27 @@
+import typing
+
+from pydantic import BaseModel
+
+BocaLanguage = typing.Literal['c', 'cpp', 'cc', 'kt', 'java', 'py2', 'py3']
+
+_MAX_REP_ERROR = 0.2  # 20% error allowed in time limit when adding reps
+
+
+class BocaExtension(BaseModel):
+    languages: typing.List[BocaLanguage] = list(typing.get_args(BocaLanguage))
+    flags: typing.Dict[BocaLanguage, str] = {}
+    maximumTimeError: float = _MAX_REP_ERROR
+
+    def flags_with_defaults(self) -> typing.Dict[BocaLanguage, str]:
+        res: typing.Dict[BocaLanguage, str] = {
+            'c': '-std=gnu11 -O2 -static -lm',
+            'cpp': '-O2 -static -lm',
+            'cc': '-std=c++20 -O2 -static -lm',
+        }
+        res.update(self.flags)
+        return res
+
+
+class BocaLanguageExtension(BaseModel):
+    # BocaLanguage this rbx language matches with.
+    bocaLanguage: typing.Optional[str] = None

rbx/box/packaging/boca/packager.py

@@ -0,0 +1,245 @@
+import pathlib
+import shutil
+from math import fabs
+from typing import List
+
+import typer
+
+from rbx import console
+from rbx.box import package
+from rbx.box.environment import get_extension_or_default
+from rbx.box.packaging.boca.extension import BocaExtension, BocaLanguage
+from rbx.box.packaging.packager import BasePackager, BuiltStatement
+from rbx.box.statements.schema import Statement
+from rbx.config import get_default_app_path, get_testlib
+
+_MAX_REP_TIME = (
+    7  # TL to allow for additional rounding reps should be < _MAX_REP_TIME in seconds
+)
+_MAX_REPS = 10  # Maximum number of reps to add
+
+
+def test_time(time):
+    return max(1, round(time))
+
+
+class BocaPackager(BasePackager):
+    def _get_main_statement(self) -> Statement:
+        pkg = package.find_problem_package_or_die()
+
+        if not pkg.statements:
+            console.console.print('[error]No statements found.[/error]')
+            raise typer.Exit(1)
+
+        return pkg.statements[0]
+
+    def _get_main_built_statement(
+        self, built_statements: List[BuiltStatement]
+    ) -> BuiltStatement:
+        statement = self._get_main_statement()
+        for built_statement in built_statements:
+            if built_statement.statement == statement:
+                return built_statement
+
+        console.console.print(
+            '[error]Main statement not found among built statements.[/error]'
+        )
+        raise typer.Exit(1)
+
+    def _get_problem_name(self) -> str:
+        pkg = package.find_problem_package_or_die()
+        return pkg.name
+
+    def _get_problem_info(self) -> str:
+        pkg = package.find_problem_package_or_die()
+        statement = self._get_main_statement()
+        return (
+            f'basename={pkg.name}\n'
+            f'fullname={statement.title}\n'
+            f'descfile={self._get_problem_name()}.pdf\n'
+        )
+
+    def _get_pkg_timelimit(self, language: BocaLanguage) -> int:
+        pkg = package.find_problem_package_or_die()
+        return pkg.timelimit_for_language(language)
+
+    def _get_pkg_memorylimit(self, language: BocaLanguage) -> int:
+        pkg = package.find_problem_package_or_die()
+        return pkg.memorylimit_for_language(language)
+
+    def _get_number_of_runs(self, language: BocaLanguage) -> int:
+        pkg = package.find_problem_package_or_die()
+        extension = get_extension_or_default('boca', BocaExtension)
+        pkg_timelimit = self._get_pkg_timelimit(language)
+        time = pkg_timelimit / 1000  # convert to seconds
+
+        if time >= _MAX_REP_TIME:
+            return 1
+
+        def rounding_error(time):
+            return fabs(time - test_time(time))
+
+        def error_percentage(time, runs):
+            return rounding_error(time * runs) / (time * runs)
+
+        if error_percentage(time, 1) < 1e-6:
+            return 1
+
+        for i in range(1, _MAX_REPS + 1):
+            if error_percentage(time, i) <= extension.maximumTimeError:
+                console.console.print(
+                    f'[warning]Using {i} run(s) to define integer TL for BOCA when using language [item]{language}[/item] '
+                    f'(original TL is {pkg_timelimit}ms, new TL is {test_time(time * i) * 1000}ms).[/warning]'
+                )
+                return i
+
+        percent_str = f'{round(extension.maximumTimeError * 100)}%'
+        console.console.print(
+            f'[error]Error while defining limits for problem [item]{pkg.name}[/item], language [item]{language}[/item].[/error]'
+        )
+        console.console.print(
+            f'[error]Introducing an error of less than {percent_str} in the TL in less than '
+            f'{_MAX_REPS} runs is not possible.[/error]'
+        )
+        console.console.print(
+            f'[error]Original TL for [item]{language}[/item] is {pkg_timelimit}ms, please review it.[/error]'
+        )
+        raise typer.Exit(1)
+
+    def _get_limits(self, language: BocaLanguage) -> str:
+        pkg = package.find_problem_package_or_die()
+        no_of_runs = self._get_number_of_runs(language)
+        return (
+            '#!/bin/bash\n'
+            f'echo {test_time(self._get_pkg_timelimit(language) / 1000 * no_of_runs)}\n'
+            f'echo {no_of_runs}\n'
+            f'echo {self._get_pkg_memorylimit(language)}\n'
+            f'echo {pkg.outputLimit}\n'
+            f'exit 0\n'
+        )
+
+    def _get_compare(self) -> str:
+        compare_path = get_default_app_path() / 'packagers' / 'boca' / 'compare'
+        if not compare_path.exists():
+            console.console.print(
+                '[error]BOCA template compare script not found.[/error]'
+            )
+            raise typer.Exit(1)
+        return compare_path.read_text()
+
+    def _get_checker(self) -> str:
+        checker_path = get_default_app_path() / 'packagers' / 'boca' / 'checker.sh'
+        if not checker_path.exists():
+            console.console.print(
+                '[error]BOCA template checker script not found.[/error]'
+            )
+            raise typer.Exit(1)
+        checker_text = checker_path.read_text()
+        testlib = get_testlib().read_text()
+        checker = package.get_checker().path.read_text()
+        return checker_text.replace('{{testlib_content}}', testlib).replace(
+            '{{checker_content}}', checker
+        )
+
+    def _get_compile(self, language: BocaLanguage) -> str:
+        extension = get_extension_or_default('boca', BocaExtension)
+
+        compile_path = (
+            get_default_app_path() / 'packagers' / 'boca' / 'compile' / language
+        )
+        if not compile_path.is_file():
+            console.console.print(
+                f'[error]Compile script for language [item]{language}[/item] not found.[/error]'
+            )
+            raise typer.Exit(1)
+
+        compile_text = compile_path.read_text()
+
+        assert 'umask 0022' in compile_text
+        compile_text = compile_text.replace(
+            'umask 0022', 'umask 0022\n\n' + self._get_checker()
+        )
+
+        flags = extension.flags_with_defaults()
+        if language in flags:
+            compile_text = compile_text.replace('{{rbxFlags}}', flags[language])
+        return compile_text
+
+    def name(self) -> str:
+        return 'boca'
+
+    def package(
+        self,
+        build_path: pathlib.Path,
+        into_path: pathlib.Path,
+        built_statements: List[BuiltStatement],
+    ) -> pathlib.Path:
+        extension = get_extension_or_default('boca', BocaExtension)
+
+        # Prepare limits
+        limits_path = into_path / 'limits'
+        limits_path.mkdir(parents=True, exist_ok=True)
+        for language in extension.languages:
+            (limits_path / language).write_text(self._get_limits(language))
+
+        # Prepare compare
+        compare_path = into_path / 'compare'
+        compare_path.mkdir(parents=True, exist_ok=True)
+        for language in extension.languages:
+            (compare_path / language).write_text(self._get_compare())
+
+        # Prepare run
+        run_path = into_path / 'run'
+        run_path.mkdir(parents=True, exist_ok=True)
+        for language in extension.languages:
+            run_orig_path = (
+                get_default_app_path() / 'packagers' / 'boca' / 'run' / language
+            )
+            if not run_orig_path.is_file():
+                console.console.print(
+                    f'[error]Run script for language [item]{language}[/item] not found.[/error]'
+                )
+                raise typer.Exit(1)
+            shutil.copyfile(run_orig_path, run_path / language)
+
+        # Prepare compile.
+        compile_path = into_path / 'compile'
+        compile_path.mkdir(parents=True, exist_ok=True)
+        for language in extension.languages:
+            (compile_path / language).write_text(self._get_compile(language))
+
+        # Prepare tests
+        tests_path = into_path / 'tests'
+        tests_path.mkdir(parents=True, exist_ok=True)
+        for language in extension.languages:
+            (tests_path / language).write_text('exit 0\n')
+
+        # Problem statement
+        description_path = into_path / 'description'
+        description_path.mkdir(parents=True, exist_ok=True)
+        (description_path / 'problem.info').write_text(self._get_problem_info())
+        shutil.copyfile(
+            self._get_main_built_statement(built_statements).path,
+            (description_path / self._get_problem_name()).with_suffix('.pdf'),
+        )
+
+        # Prepare IO
+        inputs_path = into_path / 'input'
+        inputs_path.mkdir(parents=True, exist_ok=True)
+        outputs_path = into_path / 'output'
+        outputs_path.mkdir(parents=True, exist_ok=True)
+
+        testcases = self.get_flattened_built_testcases()
+        for i, testcase in enumerate(testcases):
+            shutil.copyfile(testcase.inputPath, inputs_path / f'{i+1:03d}')
+            if testcase.outputPath is not None:
+                shutil.copyfile(testcase.outputPath, outputs_path / f'{i+1:03d}')
+            else:
+                (outputs_path / f'{i+1:03d}').touch()
+
+        # Zip all.
+        shutil.make_archive(
+            str(build_path / self._get_problem_name()), 'zip', into_path
+        )
+
+        return (build_path / self._get_problem_name()).with_suffix('.zip')

rbx/box/packaging/contest_main.py

@@ -0,0 +1,82 @@
+import pathlib
+import tempfile
+from typing import Type
+
+import typer
+
+from rbx import annotations, console, utils
+from rbx.box import environment, package
+from rbx.box.contest import build_contest_statements, contest_package, contest_utils
+from rbx.box.packaging.main import run_packager
+from rbx.box.packaging.packager import (
+    BaseContestPackager,
+    BasePackager,
+    BuiltContestStatement,
+    BuiltProblemPackage,
+)
+from rbx.box.packaging.polygon.packager import PolygonContestPackager, PolygonPackager
+
+app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
+
+
+def run_contest_packager(
+    contest_packager_cls: Type[BaseContestPackager],
+    packager_cls: Type[BasePackager],
+    verification: environment.VerificationParam,
+):
+    contest = contest_package.find_contest_package_or_die()
+
+    # Build problem-level packages.
+    built_packages = []
+    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()
+            package_path = run_packager(packager_cls, verification=verification)
+            built_packages.append(
+                BuiltProblemPackage(
+                    path=problem.get_path() / package_path,
+                    package=package.find_problem_package_or_die(),
+                    problem=problem,
+                )
+            )
+
+    # Build statements.
+    packager = contest_packager_cls()
+    statement_types = packager.statement_types()
+    built_statements = []
+
+    for statement_type in statement_types:
+        languages = packager.languages()
+        for language in languages:
+            statement = packager.get_statement_for_language(language)
+            statement_path = build_contest_statements.build_statement(
+                statement, contest, statement_type
+            )
+            built_statements.append(
+                BuiltContestStatement(statement, statement_path, statement_type)
+            )
+
+    console.console.print(f'Packaging contest for [item]{packager.name()}[/item]...')
+
+    # Build contest-level package.
+    with tempfile.TemporaryDirectory() as td:
+        packager.package(
+            built_packages, pathlib.Path('build'), pathlib.Path(td), built_statements
+        )
+
+    console.console.print(
+        f'[success]Contest packaged for [item]{packager.name()}[/item]![/success]'
+    )
+
+
+@app.command('polygon', help='Build a contest package for Polygon.')
+@contest_package.within_contest
+def polygon(
+    verification: environment.VerificationParam,
+):
+    run_contest_packager(
+        PolygonContestPackager, PolygonPackager, verification=verification
+    )