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

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:

rbx/box/packaging/polygon/upload.py

@@ -10,8 +10,8 @@ import typer
 from rbx import console
 from rbx.box import header, package
 from rbx.box.generators import get_all_built_testcases
+from rbx.box.lang import code_to_langs, is_valid_lang_code
 from rbx.box.packaging.polygon import polygon_api as api
-from rbx.box.packaging.polygon.packager import code_to_langs, is_valid_lang_code
 from rbx.box.schema import CodeItem, ExpectedOutcome, Solution, TaskType, Testcase
 from rbx.box.statements.build_statements import get_relative_assets
 from rbx.box.statements.builders import (
@@ -20,7 +20,11 @@ from rbx.box.statements.builders import (
     render_jinja_blocks,
 )
 from rbx.box.statements.schema import Statement, StatementType
-from rbx.box.testcase_utils import get_alternate_interaction_texts, parse_interaction
+from rbx.box.testcase_utils import (
+    TestcaseInteractionParsingError,
+    get_alternate_interaction_texts,
+    parse_interaction,
+)
 
 _API_URL = 'https://polygon.codeforces.com/api'
 
@@ -163,17 +167,23 @@ def _get_test_params_for_statement(
 
     pio_path = testcase.outputPath.with_suffix('.pio')
     if pio_path.is_file():
-        interaction = parse_interaction(pio_path)
-        res['test_input_for_statements'], res['test_output_for_statements'] = (
-            get_alternate_interaction_texts(interaction)
-        )
-    else:
-        pin_path = testcase.outputPath.with_suffix('.pin')
-        if pin_path.is_file():
-            res['test_input_for_statements'] = pin_path.read_text()
-        pout_path = testcase.outputPath.with_suffix('.pout')
-        if pout_path.is_file():
-            res['test_output_for_statements'] = pout_path.read_text()
+        try:
+            interaction = parse_interaction(pio_path)
+        except TestcaseInteractionParsingError:
+            pass
+        else:
+            res['test_input_for_statements'], res['test_output_for_statements'] = (
+                get_alternate_interaction_texts(interaction)
+            )
+            return res
+
+    # .pio does not exist or is not parseable, fallback to .pin and .pout.
+    pin_path = testcase.outputPath.with_suffix('.pin')
+    if pin_path.is_file():
+        res['test_input_for_statements'] = pin_path.read_text()
+    pout_path = testcase.outputPath.with_suffix('.pout')
+    if pout_path.is_file():
+        res['test_output_for_statements'] = pout_path.read_text()
     return res
 
 
@@ -229,7 +239,7 @@ def _upload_solutions(problem: api.Problem):
 
 def _get_statement_for_language(language: str) -> Optional[Statement]:
     pkg = package.find_problem_package_or_die()
-    for statement in pkg.statements:
+    for statement in pkg.expanded_statements:
         if statement.language == language:
             return statement
     return None
@@ -290,11 +300,15 @@ def _upload_statement(problem: api.Problem, preserve_language: bool = False):
     pkg = package.find_problem_package_or_die()
 
     languages = set()
-    for statement in pkg.statements:
+    for statement in pkg.expanded_statements:
         if not is_valid_lang_code(statement.language):
             continue
         languages.add(statement.language)
-    for language in languages:
+
+    uploaded_languages = set()
+
+    # Prioritize English statements.
+    for language in ['en'] + list(languages):
         statement = _get_statement_for_language(language)
         if statement is None:
             continue
@@ -304,6 +318,10 @@ def _upload_statement(problem: api.Problem, preserve_language: bool = False):
         console.console.print(
             f'Uploading statement for language [item]{language}[/item] (polygon language: [item]{statement_lang}[/item])...'
         )
+        uploaded_language = statement_lang if preserve_language else 'english'
+        if uploaded_language in uploaded_languages:
+            continue
+        uploaded_languages.add(uploaded_language)
         if not preserve_language and statement_lang != 'english':
             console.console.print(
                 '[warning]By default, Polygon statements are uploaded in English.\n'
@@ -322,7 +340,7 @@ def _upload_statement(problem: api.Problem, preserve_language: bool = False):
             notes=_get_notes_with_explanations(blocks) or '',
         )
         problem.save_statement(
-            lang=statement_lang if preserve_language else 'english',
+            lang=uploaded_language,
             problem_statement=polygon_statement,
         )