rbx.cp 0.5.72__py3-none-any.whl → 0.6.0__py3-none-any.whl

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/download.py

@@ -5,7 +5,7 @@ from typing import Optional
 import typer
 
 from rbx import annotations, console
-from rbx.box import header, package
+from rbx.box import header, package, remote
 from rbx.box.schema import CodeItem
 from rbx.config import get_builtin_checker, get_jngen, get_testlib
 from rbx.grading import steps
@@ -72,3 +72,21 @@ def checker(name: str):
     console.console.print(
         f'[success]Downloaded [item]{name}[/item] into current package.[/success]'
     )
+
+
+@app.command('remote, r', help='Download a remote code.')
+@package.within_problem
+def remote_cmd(
+    name: str,
+    output: Optional[str] = typer.Option(
+        None,
+        '-o',
+        '--output',
+        help='Whether to not build outputs for tests and run checker.',
+    ),
+):
+    path = remote.expand_file(name)
+
+    if output is not None:
+        pathlib.Path(output).parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy(str(path), output)

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/package.py

@@ -459,7 +459,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():

rbx/box/packaging/boca/packager.py

@@ -32,11 +32,11 @@ class BocaPackager(BasePackager):
     def _get_main_statement(self) -> Statement:
         pkg = package.find_problem_package_or_die()
 
-        if not pkg.statements:
+        if not pkg.expanded_statements:
             console.console.print('[error]No statements found.[/error]')
             raise typer.Exit(1)
 
-        return pkg.statements[0]
+        return pkg.expanded_statements[0]
 
     def _get_main_built_statement(
         self, built_statements: List[BuiltStatement]
@@ -119,10 +119,18 @@ class BocaPackager(BasePackager):
 
     def _get_limits(self, language: BocaLanguage) -> str:
         pkg = package.find_problem_package_or_die()
-        no_of_runs = self._get_number_of_runs(language)
+        if pkg.type == TaskType.COMMUNICATION:
+            # Interactive tasks only support a single run.
+            no_of_runs = 1
+            time_limit = f'{self._get_pkg_timelimit(language) / 1000:.2f}'
+        else:
+            no_of_runs = self._get_number_of_runs(language)
+            time_limit = test_time(
+                self._get_pkg_timelimit(language) / 1000 * no_of_runs
+            )
         return (
             '#!/bin/bash\n'
-            f'echo {test_time(self._get_pkg_timelimit(language) / 1000 * no_of_runs)}\n'
+            f'echo {time_limit}\n'
             f'echo {no_of_runs}\n'
             f'echo {self._get_pkg_memorylimit(language)}\n'
             f'echo {pkg.outputLimit}\n'
@@ -176,6 +184,25 @@ class BocaPackager(BasePackager):
             '{{rbxFlags}}', extension.flags_with_defaults()['cc']
         ).replace('{{interactor_content}}', interactor)
 
+    def _get_safeexec(self) -> str:
+        safeexec_script_path = (
+            get_default_app_path() / 'packagers' / 'boca' / 'safeexec_compile.sh'
+        )
+        safeexec_path = get_default_app_path() / 'packagers' / 'boca' / 'safeexec.c'
+        if not safeexec_script_path.exists():
+            console.console.print(
+                '[error]BOCA template safeexec compile script not found.[/error]'
+            )
+            raise typer.Exit(1)
+        if not safeexec_path.exists():
+            console.console.print(
+                '[error]BOCA template safeexec source code not found.[/error]'
+            )
+            raise typer.Exit(1)
+        return safeexec_script_path.read_text().replace(
+            '{{safeexec_content}}', safeexec_path.read_text()
+        )
+
     def _get_compile(self, language: BocaLanguage) -> str:
         pkg = package.find_problem_package_or_die()
         extension = get_extension_or_default('boca', BocaExtension)
@@ -196,6 +223,9 @@ class BocaPackager(BasePackager):
             compile_text = compile_text.replace(
                 'umask 0022', 'umask 0022\n\n' + self._get_interactor()
             )
+            compile_text = compile_text.replace(
+                'umask 0022', 'umask 0022\n\n' + self._get_safeexec()
+            )
         compile_text = compile_text.replace(
             'umask 0022', 'umask 0022\n\n' + self._get_checker()
         )
@@ -206,7 +236,6 @@ class BocaPackager(BasePackager):
         return compile_text
 
     def _copy_solutions(self, into_path: pathlib.Path):
-        into_path = into_path / 'solutions'
         for solution in package.get_solutions():
             dest_path = (
                 into_path
@@ -218,6 +247,19 @@ class BocaPackager(BasePackager):
             dest_path.parent.mkdir(parents=True, exist_ok=True)
             shutil.copy(str(solution.path), dest_path)
 
+    def _expand_run_script(self, run_path: pathlib.Path):
+        pkg = package.find_problem_package_or_die()
+        if pkg.type == TaskType.COMMUNICATION:
+            runit_content = (
+                get_default_app_path() / 'packagers' / 'boca' / 'interactor_run.sh'
+            ).read_text()
+            run_path.write_text(
+                run_path.read_text().replace(
+                    '{{runit_content}}',
+                    runit_content,
+                )
+            )
+
     @classmethod
     def name(cls) -> str:
         return 'boca'
@@ -263,6 +305,7 @@ class BocaPackager(BasePackager):
                 )
                 raise typer.Exit(1)
             shutil.copyfile(run_orig_path, run_path / language)
+            self._expand_run_script(run_path / language)
 
         # Prepare compile.
         compile_path = into_path / 'compile'

rbx/box/packaging/contest_main.py

@@ -86,3 +86,16 @@ async def polygon(
     await run_contest_packager(
         PolygonContestPackager, PolygonPackager, verification=verification
     )
+
+
+@app.command('pkg', help='Build a contest package for PKG.')
+@contest_package.within_contest
+@syncer.sync
+async def pkg(
+    verification: environment.VerificationParam,
+):
+    from rbx.box.packaging.pkg.packager import PkgContestPackager, PkgPackager
+
+    await run_contest_packager(
+        PkgContestPackager, PkgPackager, verification=verification
+    )

rbx/box/packaging/main.py

@@ -114,9 +114,9 @@ async def boca(
     result_path = await run_packager(BocaPackager, verification=verification)
 
     if upload:
-        from rbx.box.packaging.boca.upload import get_boca_uploader
+        from rbx.box.tooling.boca.scraper import get_boca_scraper
 
-        uploader = get_boca_uploader()
+        uploader = get_boca_scraper()
         uploader.login_and_upload(result_path)
 
 
@@ -132,3 +132,14 @@ async def moj(
     from rbx.box.packaging.moj.packager import MojPackager
 
     await run_packager(MojPackager, verification=verification, for_boca=for_boca)
+
+
+@app.command('pkg', help='Build a package for PKG.')
+@package.within_problem
+@syncer.sync
+async def pkg(
+    verification: environment.VerificationParam,
+):
+    from rbx.box.packaging.pkg.packager import PkgPackager
+
+    await run_packager(PkgPackager, verification=verification)

rbx/box/packaging/packager.py

@@ -46,7 +46,7 @@ class BasePackager(ABC):
         pkg = package.find_problem_package_or_die()
 
         res = set()
-        for statement in pkg.statements:
+        for statement in pkg.expanded_statements:
             res.add(statement.language)
         return list(res)
 
@@ -89,7 +89,7 @@ class BasePackager(ABC):
 
     def get_statement_for_language(self, lang: str) -> Statement:
         pkg = package.find_problem_package_or_die()
-        for statement in pkg.statements:
+        for statement in pkg.expanded_statements:
             if statement.language == lang:
                 return statement
         raise
@@ -114,7 +114,7 @@ class BaseContestPackager(ABC):
         pkg = contest_package.find_contest_package_or_die()
 
         res = set()
-        for statement in pkg.statements:
+        for statement in pkg.expanded_statements:
             res.add(statement.language)
         return list(res)
 
@@ -123,7 +123,7 @@ class BaseContestPackager(ABC):
 
     def get_statement_for_language(self, lang: str) -> ContestStatement:
         contest = contest_package.find_contest_package_or_die()
-        for statement in contest.statements:
+        for statement in contest.expanded_statements:
             if statement.language == lang:
                 return statement
         raise

rbx/box/packaging/pkg/packager.py

@@ -0,0 +1,142 @@
+import pathlib
+import shutil
+from typing import List, Optional
+
+from rbx.box import naming, package
+from rbx.box.contest import contest_package
+from rbx.box.contest.schema import ContestStatement
+from rbx.box.packaging.packager import (
+    BaseContestPackager,
+    BasePackager,
+    BuiltContestStatement,
+    BuiltProblemPackage,
+    BuiltStatement,
+)
+from rbx.box.schema import ExpectedOutcome, TaskType
+from rbx.box.statements.schema import Statement
+
+
+class PkgPackager(BasePackager):
+    @classmethod
+    def task_types(cls) -> List[TaskType]:
+        return [TaskType.BATCH, TaskType.COMMUNICATION]
+
+    @classmethod
+    def name(cls) -> str:
+        return 'pkg'
+
+    def _get_problem_basename(self) -> str:
+        shortname = naming.get_problem_shortname()
+        if shortname is not None:
+            return shortname
+        return self.package_basename()
+
+    def _get_main_statement(self) -> Optional[Statement]:
+        pkg = package.find_problem_package_or_die()
+        if not pkg.expanded_statements:
+            return None
+        return pkg.expanded_statements[0]
+
+    def _get_main_built_statement(
+        self, built_statements: List[BuiltStatement]
+    ) -> Optional[BuiltStatement]:
+        statement = self._get_main_statement()
+        if statement is None:
+            return None
+        for built_statement in built_statements:
+            if built_statement.statement == statement:
+                return built_statement
+        return None
+
+    def _copy_accepted_solutions(self, into_path: pathlib.Path):
+        for solution in package.get_solutions():
+            if solution.outcome != ExpectedOutcome.ACCEPTED:
+                continue
+            dest_path = into_path / solution.path.name
+            dest_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(str(solution.path), dest_path)
+
+    def package(
+        self,
+        build_path: pathlib.Path,
+        into_path: pathlib.Path,
+        built_statements: List[BuiltStatement],
+    ) -> pathlib.Path:
+        into_path.mkdir(parents=True, exist_ok=True)
+
+        main_statement = self._get_main_built_statement(built_statements)
+        if main_statement is not None:
+            statement_path = into_path / 'statement.pdf'
+            shutil.copyfile(main_statement.path, statement_path)
+
+        # Prepare tests
+        tests_path = into_path / 'tests'
+        tests_path.mkdir(parents=True, exist_ok=True)
+
+        testcases = self.get_flattened_built_testcases()
+        for i, testcase in enumerate(testcases):
+            shutil.copyfile(testcase.inputPath, tests_path / f'{i + 1:03d}.in')
+            if testcase.outputPath is not None:
+                shutil.copyfile(testcase.outputPath, tests_path / f'{i + 1:03d}.ans')
+            else:
+                (tests_path / f'{i + 1:03d}.ans').touch()
+
+        # Copy solutions.
+        solutions_path = into_path / 'solutions'
+        solutions_path.mkdir(parents=True, exist_ok=True)
+        self._copy_accepted_solutions(solutions_path)
+
+        # Zip all.
+        shutil.make_archive(
+            str(build_path / self._get_problem_basename()), 'zip', into_path
+        )
+
+        return (build_path / self._get_problem_basename()).with_suffix('.zip')
+
+
+class PkgContestPackager(BaseContestPackager):
+    @classmethod
+    def name(cls) -> str:
+        return 'pkg'
+
+    def _get_main_statement(self) -> Optional[ContestStatement]:
+        pkg = contest_package.find_contest_package_or_die()
+        if not pkg.expanded_statements:
+            return None
+        return pkg.expanded_statements[0]
+
+    def _get_main_built_statement(
+        self, built_statements: List[BuiltContestStatement]
+    ) -> Optional[BuiltContestStatement]:
+        statement = self._get_main_statement()
+        if statement is None:
+            return None
+        for built_statement in built_statements:
+            if built_statement.statement == statement:
+                return built_statement
+        return None
+
+    def package(
+        self,
+        built_packages: List[BuiltProblemPackage],
+        build_path: pathlib.Path,
+        into_path: pathlib.Path,
+        built_statements: List[BuiltContestStatement],
+    ) -> pathlib.Path:
+        into_path.mkdir(parents=True, exist_ok=True)
+
+        # Add contest-level statement.
+        main_statement = self._get_main_built_statement(built_statements)
+        if main_statement is not None:
+            statement_path = into_path / 'statement.pdf'
+            shutil.copyfile(main_statement.path, statement_path)
+
+        # Add problems.
+        for built_package in built_packages:
+            pkg_path = into_path / built_package.problem.short_name
+            shutil.unpack_archive(built_package.path, pkg_path, format='zip')
+
+        # Zip all.
+        shutil.make_archive(str(build_path / 'contest'), 'zip', into_path)
+
+        return (build_path / 'contest').with_suffix('.zip')

rbx/box/packaging/polygon/packager.py

@@ -1,13 +1,12 @@
-import functools
 import pathlib
 import shutil
 from typing import List, Optional
 
-import iso639
 import typer
 
 from rbx import console
 from rbx.box import header, package
+from rbx.box.lang import code_to_langs, is_valid_lang_code
 from rbx.box.packaging.packager import (
     BaseContestPackager,
     BasePackager,
@@ -28,27 +27,6 @@ DAT_TEMPLATE = """
 """
 
 
-def langs_to_code(langs: List[str]) -> List[str]:
-    return [iso639.Language.from_name(lang).part1 for lang in langs]
-
-
-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
-
-
 class PolygonPackager(BasePackager):
     @classmethod
     def task_types(cls) -> List[TaskType]:
@@ -59,7 +37,7 @@ class PolygonPackager(BasePackager):
         pkg = package.find_problem_package_or_die()
 
         lang_codes = set()
-        for statement in pkg.statements:
+        for statement in pkg.expanded_statements:
             lang_codes.add(statement.title)
 
         for lang in langs: