rbx.cp 0.12.0__py3-none-any.whl → 0.13.3__py3-none-any.whl

rbx/box/cli.py

@@ -186,6 +186,15 @@ def on(ctx: typer.Context, problems: str) -> None:
     contest.on(ctx, problems)
 
 
+@app.command(
+    'each',
+    help='Run a command for each problem in the contest.',
+    context_settings={'allow_extra_args': True, 'ignore_unknown_options': True},
+)
+def each(ctx: typer.Context) -> None:
+    contest.each(ctx)
+
+
 @app.command('diff', hidden=True)
 def diff(path1: pathlib.Path, path2: pathlib.Path):
     from rbx.box.ui import main as ui_pkg

rbx/box/generators.py

@@ -97,7 +97,10 @@ def _copy_testcase_over(
 
 
 def _copy_testcase_output_over(
-    src_output_path: pathlib.Path, dest_output_path: pathlib.Path, suffix: str
+    src_output_path: pathlib.Path,
+    dest_output_path: pathlib.Path,
+    suffix: str,
+    dry_run: bool = False,
 ) -> bool:
     dest_output_path.parent.mkdir(parents=True, exist_ok=True)
 
@@ -105,41 +108,64 @@ def _copy_testcase_output_over(
     if not src_path.is_file():
         return False
 
-    _check_crlf(src_path)
+    if dry_run:
+        return True
 
+    _check_crlf(src_path)
     shutil.copy(str(src_path), str(dest_output_path.with_suffix(suffix)))
     return True
 
 
 def _copy_testcase_outputs_over(
-    testcase: Testcase, dest: Testcase, pipes: bool = False
+    testcase: Testcase, dest: Testcase, pipes: bool = False, dry_run: bool = False
 ):
     assert dest.outputPath is not None
-    dest.outputPath.parent.mkdir(parents=True, exist_ok=True)
+    if not dry_run:
+        dest.outputPath.parent.mkdir(parents=True, exist_ok=True)
 
     has_copied = False
 
     if testcase.outputPath is not None and testcase.outputPath.is_file():
-        _check_crlf(testcase.outputPath)
-        shutil.copy(str(testcase.outputPath), str(dest.outputPath))
+        if not dry_run:
+            _check_crlf(testcase.outputPath)
+            shutil.copy(str(testcase.outputPath), str(dest.outputPath))
         has_copied = True
 
     if not pipes:
         return has_copied
 
     reference_path = testcase.outputPath or testcase.inputPath
-    if _copy_testcase_output_over(reference_path, dest.outputPath, '.pin'):
+    if _copy_testcase_output_over(
+        reference_path, dest.outputPath, '.pin', dry_run=dry_run
+    ):
         has_copied = True
 
-    if _copy_testcase_output_over(reference_path, dest.outputPath, '.pout'):
+    if _copy_testcase_output_over(
+        reference_path, dest.outputPath, '.pout', dry_run=dry_run
+    ):
         has_copied = True
 
-    if _copy_testcase_output_over(reference_path, dest.outputPath, '.pio'):
+    if _copy_testcase_output_over(
+        reference_path, dest.outputPath, '.pio', dry_run=dry_run
+    ):
         has_copied = True
 
     return has_copied
 
 
+def _needs_output(generation_entries: List[GenerationTestcaseEntry]) -> bool:
+    for entry in generation_entries:
+        tc = entry.metadata.copied_to
+        if not tc.inputPath.is_file():
+            continue
+        if entry.metadata.copied_from is not None and _copy_testcase_outputs_over(
+            entry.metadata.copied_from, tc, dry_run=True
+        ):
+            continue
+        return True
+    return False
+
+
 def get_all_built_testcases() -> Dict[str, List[Testcase]]:
     pkg = package.find_problem_package_or_die()
     res = {group.name: find_built_testcases(group) for group in pkg.testcases}
@@ -395,17 +421,20 @@ async def generate_outputs_for_testcases(
         if progress is not None:
             progress.step()
 
+    generation_entries = await extract_generation_testcases(entries)
+    needs_output = _needs_output(generation_entries)
+
     main_solution = package.get_main_solution()
     solution_digest: Optional[str] = None
 
     pkg = package.find_problem_package_or_die()
 
-    if pkg.type == TaskType.COMMUNICATION:
+    if pkg.type == TaskType.COMMUNICATION and needs_output:
         interactor_digest = checkers.compile_interactor(progress)
     else:
         interactor_digest = None
 
-    if main_solution is not None:
+    if main_solution is not None and needs_output:
         if progress:
             progress.update('Compiling main solution...')
         try:
@@ -418,8 +447,6 @@ async def generate_outputs_for_testcases(
     shutil.rmtree(str(gen_runs_dir), ignore_errors=True)
     gen_runs_dir.mkdir(parents=True, exist_ok=True)
 
-    generation_entries = await extract_generation_testcases(entries)
-
     for entry in generation_entries:
         tc = entry.metadata.copied_to
         if not tc.inputPath.is_file():
@@ -434,6 +461,7 @@ async def generate_outputs_for_testcases(
             step()
             continue
 
+        assert needs_output
         if (
             main_solution is None or solution_digest is None
         ) and not tc.outputPath.is_file():

rbx/box/header.py

@@ -16,6 +16,11 @@ def get_header() -> pathlib.Path:
 
 
 def generate_header():
+    override_header = pathlib.Path('rbx.override.h')
+    if override_header.is_file():
+        pathlib.Path('rbx.h').write_bytes(override_header.read_bytes())
+        return
+
     with importlib.resources.as_file(
         importlib.resources.files('rbx') / 'resources' / 'templates' / 'rbx.h'
     ) as file:

rbx/box/lang.py

@@ -1,27 +1,40 @@
 import functools
-from typing import List
+from typing import Dict, List
 
 import iso639
 
-from rbx import console
+
+@functools.cache
+def _get_lowercase_name_mapping() -> Dict[str, iso639.Lang]:
+    res = {}
+    for lang in iso639.iter_langs():
+        res[lang.name.lower()] = lang
+    return res
+
+
+def _get_lang_name(lang: str) -> str:
+    mapping = _get_lowercase_name_mapping()
+    if lang.lower() in mapping:
+        return mapping[lang.lower()].name
+    return lang
+
+
+def code_to_lang(lang: str) -> str:
+    return iso639.Lang(lang).name.lower()
 
 
 def code_to_langs(langs: List[str]) -> List[str]:
-    return [iso639.Language.from_part1(lang).name.lower() for lang in langs]
+    return [code_to_lang(lang) 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 iso639.is_language(lang)
+
 
-    return True
+def lang_to_code(lang: str) -> str:
+    return iso639.Lang(_get_lang_name(lang)).pt1
 
 
 def langs_to_code(langs: List[str]) -> List[str]:
-    return [iso639.Language.from_name(lang).part1 for lang in langs]
+    return [lang_to_code(lang) for lang in langs]

rbx/box/packaging/contest_main.py

@@ -1,6 +1,6 @@
 import pathlib
 import tempfile
-from typing import Type
+from typing import Optional, Type
 
 import syncer
 import typer
@@ -8,12 +8,13 @@ import typer
 from rbx import annotations, console
 from rbx.box import cd, environment, package
 from rbx.box.contest import build_contest_statements, contest_package
-from rbx.box.packaging.main import run_packager
 from rbx.box.packaging.packager import (
     BaseContestPackager,
     BasePackager,
     BuiltContestStatement,
     BuiltProblemPackage,
+    ContestZipper,
+    run_packager,
 )
 
 app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
@@ -23,6 +24,7 @@ async def run_contest_packager(
     contest_packager_cls: Type[BaseContestPackager],
     packager_cls: Type[BasePackager],
     verification: environment.VerificationParam,
+    **kwargs,
 ):
     contest = contest_package.find_contest_package_or_die()
 
@@ -34,7 +36,9 @@ async def run_contest_packager(
         )
         with cd.new_package_cd(problem.get_path()):
             package.clear_package_cache()
-            package_path = await run_packager(packager_cls, verification=verification)
+            package_path = await run_packager(
+                packager_cls, verification=verification, **kwargs
+            )
             built_packages.append(
                 BuiltProblemPackage(
                     path=problem.get_path() / package_path,
@@ -44,7 +48,7 @@ async def run_contest_packager(
             )
 
     # Build statements.
-    packager = contest_packager_cls()
+    packager = contest_packager_cls(**kwargs)
     statement_types = packager.statement_types()
     built_statements = []
 
@@ -63,12 +67,12 @@ async def run_contest_packager(
 
     # Build contest-level package.
     with tempfile.TemporaryDirectory() as td:
-        packager.package(
+        result_path = 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]'
+        f'[success]Created contest package for [item]{packager.name()}[/item] at [item]{result_path}[/item]![/success]'
     )
 
 
@@ -77,6 +81,12 @@ async def run_contest_packager(
 @syncer.sync
 async def polygon(
     verification: environment.VerificationParam,
+    language: Optional[str] = typer.Option(
+        None,
+        '--language',
+        '-l',
+        help='If set, will use the given language as the main language.',
+    ),
 ):
     from rbx.box.packaging.polygon.packager import (
         PolygonContestPackager,
@@ -84,7 +94,30 @@ async def polygon(
     )
 
     await run_contest_packager(
-        PolygonContestPackager, PolygonPackager, verification=verification
+        PolygonContestPackager,
+        PolygonPackager,
+        verification=verification,
+        main_language=language,
+    )
+
+
+@app.command('boca', help='Build a contest package for BOCA.')
+@contest_package.within_contest
+@syncer.sync
+async def boca(
+    verification: environment.VerificationParam,
+):
+    from rbx.box.packaging.boca.packager import BocaPackager
+
+    class BocaContestPackager(ContestZipper):
+        def __init__(self, **kwargs):
+            super().__init__('boca-contest', zip_inner=True, **kwargs)
+
+        def name(self) -> str:
+            return 'boca'
+
+    await run_contest_packager(
+        BocaContestPackager, BocaPackager, verification=verification
     )
 
 

rbx/box/packaging/importer.py

@@ -0,0 +1,37 @@
+import pathlib
+from abc import ABC, abstractmethod
+from typing import Type
+
+from rbx import console
+
+
+class BaseImporter(ABC):
+    @classmethod
+    @abstractmethod
+    def name(cls) -> str:
+        pass
+
+    @abstractmethod
+    async def import_package(self, pkg_path: pathlib.Path, into_path: pathlib.Path):
+        pass
+
+
+class BaseContestImporter(ABC):
+    @classmethod
+    @abstractmethod
+    def name(cls) -> str:
+        pass
+
+    @abstractmethod
+    async def import_package(self, pkg_path: pathlib.Path, into_path: pathlib.Path):
+        pass
+
+
+async def run_importer(
+    importer_cls: Type[BaseImporter], pkg_path: pathlib.Path, into_path: pathlib.Path
+):
+    importer = importer_cls()
+    console.console.print(
+        f'Importing package from [item]{pkg_path}[/item] to [item]{into_path}[/item] with [item]{importer.name()}[/item]...'
+    )
+    await importer.import_package(pkg_path, into_path)

rbx/box/packaging/main.py

@@ -1,72 +1,16 @@
-import pathlib
-import tempfile
-from typing import Type
+from typing import Optional
 
 import syncer
 import typer
 
-from rbx import annotations, console
-from rbx.box import environment, header, package
-from rbx.box.formatting import href
+from rbx import annotations
+from rbx.box import environment, package
 from rbx.box.naming import get_problem_name_with_contest_info
-from rbx.box.package import get_build_path
-from rbx.box.packaging.packager import BasePackager, BuiltStatement
-from rbx.box.statements.build_statements import build_statement
+from rbx.box.packaging.packager import run_packager
 
 app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
 
 
-async def run_packager(
-    packager_cls: Type[BasePackager],
-    verification: environment.VerificationParam,
-    **kwargs,
-) -> pathlib.Path:
-    from rbx.box import builder
-
-    header.generate_header()
-
-    if not await builder.verify(verification=verification):
-        console.console.print(
-            '[error]Build or verification failed, check the report.[/error]'
-        )
-        raise typer.Exit(1)
-
-    pkg = package.find_problem_package_or_die()
-
-    if pkg.type not in packager_cls.task_types():
-        console.console.print(
-            f'[error]Packager [item]{packager_cls.name()}[/item] does not support task type [item]{pkg.type}[/item].[/error]'
-        )
-        raise typer.Exit(1)
-
-    packager = packager_cls(**kwargs)
-
-    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_statement(statement, pkg, statement_type)
-            built_statements.append(
-                BuiltStatement(statement, statement_path, statement_type)
-            )
-
-    console.console.print(f'Packaging problem for [item]{packager.name()}[/item]...')
-
-    with tempfile.TemporaryDirectory() as td:
-        result_path = packager.package(
-            get_build_path(), pathlib.Path(td), built_statements
-        )
-
-    console.console.print(
-        f'[success]Problem packaged for [item]{packager.name()}[/item]![/success]'
-    )
-    console.console.print(f'Package was saved at {href(result_path)}')
-    return result_path
-
-
 @app.command('polygon', help='Build a package for Polygon.')
 @package.within_problem
 @syncer.sync
@@ -78,22 +22,31 @@ async def polygon(
         '-u',
         help='If set, will upload the package to Polygon.',
     ),
-    preserve_language: bool = typer.Option(
+    language: Optional[str] = typer.Option(
+        None,
+        '--language',
+        '-l',
+        help='If set, will use the given language as the main language.',
+    ),
+    upload_as_english: bool = typer.Option(
         False,
-        '--preserve-language',
-        help='If set, will preserve the original language of the statement.',
+        '--upload-as-english',
+        help='If set, will force the main statement to be uploaded in English.',
     ),
 ):
     from rbx.box.packaging.polygon.packager import PolygonPackager
 
-    await run_packager(PolygonPackager, verification=verification)
+    await run_packager(
+        PolygonPackager, verification=verification, main_language=language
+    )
 
     if upload:
         from rbx.box.packaging.polygon.upload import upload_problem
 
         await upload_problem(
             name=get_problem_name_with_contest_info(),
-            preserve_language=preserve_language,
+            main_language=language,
+            upload_as_english=upload_as_english,
         )
 
 

rbx/box/packaging/packager.py

@@ -1,13 +1,20 @@
 import dataclasses
 import pathlib
+import shutil
+import tempfile
 from abc import ABC, abstractmethod
-from typing import List, Tuple
+from typing import List, Tuple, Type
 
-from rbx.box import naming, package
+import typer
+
+from rbx import console
+from rbx.box import environment, header, naming, package
 from rbx.box.contest import contest_package
 from rbx.box.contest.schema import ContestProblem, ContestStatement
+from rbx.box.formatting import href
 from rbx.box.generators import get_all_built_testcases
 from rbx.box.schema import Package, TaskType, Testcase, TestcaseGroup
+from rbx.box.statements.build_statements import build_statement
 from rbx.box.statements.schema import Statement, StatementType
 
 
@@ -127,3 +134,89 @@ class BaseContestPackager(ABC):
             if statement.language == lang:
                 return statement
         raise
+
+
+class ContestZipper(BaseContestPackager):
+    def __init__(
+        self, filename: str, zip_inner: bool = False, prefer_shortname: bool = True
+    ):
+        super().__init__()
+        self.zip_inner = zip_inner
+        self.filename = filename
+        self.prefer_shortname = prefer_shortname
+
+    def package(
+        self,
+        built_packages: List[BuiltProblemPackage],
+        build_path: pathlib.Path,
+        into_path: pathlib.Path,
+        built_statements: List[BuiltContestStatement],
+    ) -> pathlib.Path:
+        for built_package in built_packages:
+            if self.prefer_shortname:
+                pkg_path = into_path / 'problems' / built_package.problem.short_name
+            else:
+                pkg_path = into_path / 'problems' / built_package.package.name
+
+            if self.zip_inner:
+                pkg_path.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy(built_package.path, pkg_path.with_suffix('.zip'))
+            else:
+                pkg_path.mkdir(parents=True, exist_ok=True)
+                shutil.unpack_archive(built_package.path, pkg_path, format='zip')
+
+        # Zip all.
+        shutil.make_archive(str(build_path / self.filename), 'zip', into_path)
+
+        return build_path / pathlib.Path(self.filename).with_suffix('.zip')
+
+
+async def run_packager(
+    packager_cls: Type[BasePackager],
+    verification: environment.VerificationParam,
+    **kwargs,
+) -> pathlib.Path:
+    from rbx.box import builder
+
+    header.generate_header()
+
+    if not await builder.verify(verification=verification):
+        console.console.print(
+            '[error]Build or verification failed, check the report.[/error]'
+        )
+        raise typer.Exit(1)
+
+    pkg = package.find_problem_package_or_die()
+
+    if pkg.type not in packager_cls.task_types():
+        console.console.print(
+            f'[error]Packager [item]{packager_cls.name()}[/item] does not support task type [item]{pkg.type}[/item].[/error]'
+        )
+        raise typer.Exit(1)
+
+    packager = packager_cls(**kwargs)
+
+    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_statement(statement, pkg, statement_type)
+            built_statements.append(
+                BuiltStatement(statement, statement_path, statement_type)
+            )
+
+    console.console.print(f'Packaging problem for [item]{packager.name()}[/item]...')
+
+    with tempfile.TemporaryDirectory() as td:
+        result_path = packager.package(
+            package.get_build_path(), pathlib.Path(td), built_statements
+        )
+
+    console.console.print(
+        f'[success]Problem packaged for [item]{packager.name()}[/item]![/success]'
+    )
+    console.console.print(f'Package was saved at {href(result_path)}')
+    return result_path