rbx.cp 0.12.0__tar.gz → 0.13.2__tar.gz

{rbx_cp-0.12.0 → rbx_cp-0.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rbx.cp
-Version: 0.12.0
+Version: 0.13.2
 Summary: 
 Author: Roberto Sales
 Requires-Python: >=3.9.1,<4.0.0
@@ -20,6 +20,7 @@ Requires-Dist: fastapi (>=0.115.8,<0.116.0)
 Requires-Dist: filelock (>=3.14.0,<4.0.0)
 Requires-Dist: gitignore-parser (>=0.1.12,<0.2.0)
 Requires-Dist: gitpython (>=3.1.43,<4.0.0)
+Requires-Dist: iso639-lang (>=2.6.1,<3.0.0)
 Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
 Requires-Dist: lark (>=1.2.2,<2.0.0)
 Requires-Dist: latexbuild (>=0.2.2,<0.3.0)
@@ -33,7 +34,6 @@ Requires-Dist: pydantic (==2.8.2)
 Requires-Dist: pydantic-xml[lxml] (>=2.11.0,<3.0.0)
 Requires-Dist: pypandoc (>=1.15,<2.0)
 Requires-Dist: pyte (>=0.8.2,<0.9.0)
-Requires-Dist: python-iso639 (>=2024.4.27,<2025.0.0)
 Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
 Requires-Dist: questionary (>=2.1.0,<3.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)

{rbx_cp-0.12.0 → rbx_cp-0.13.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rbx.cp"
-version = "0.12.0"
+version = "0.13.2"
 description = ""
 packages = [
   {include = "rbx"}
@@ -24,7 +24,6 @@ pyyaml = "^6.0.1"
 requests = "^2.32.3"
 latexbuild = "^0.2.2"
 pydantic-xml = {extras = ["lxml"], version = "^2.11.0"}
-python-iso639 = "^2024.4.27"
 more-itertools = "^10.5.0"
 gitpython = "^3.1.43"
 textual = "^3.1.1"
@@ -49,6 +48,7 @@ lz4 = "^4.4.4"
 ordered-set = "^4.1.0"
 gitignore-parser = "^0.1.12"
 pypandoc = "^1.15"
+iso639-lang = "^2.6.1"
 
 [tool.poetry.scripts]
 rbc = "rbx.main:app"

{rbx_cp-0.12.0 → rbx_cp-0.13.2}/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_cp-0.12.0 → rbx_cp-0.13.2}/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_cp-0.12.0 → rbx_cp-0.13.2}/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_cp-0.13.2/rbx/box/lang.py

@@ -0,0 +1,40 @@
+import functools
+from typing import Dict, List
+
+import iso639
+
+
+@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 [code_to_lang(lang) for lang in langs]
+
+
+@functools.cache
+def is_valid_lang_code(lang: str) -> bool:
+    return iso639.is_language(lang)
+
+
+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 [lang_to_code(lang) for lang in langs]

{rbx_cp-0.12.0 → rbx_cp-0.13.2}/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_cp-0.13.2/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_cp-0.13.2/rbx/box/packaging/main.py

@@ -0,0 +1,98 @@
+from typing import Optional
+
+import syncer
+import typer
+
+from rbx import annotations
+from rbx.box import environment, package
+from rbx.box.naming import get_problem_name_with_contest_info
+from rbx.box.packaging.packager import run_packager
+
+app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
+
+
+@app.command('polygon', help='Build a package for Polygon.')
+@package.within_problem
+@syncer.sync
+async def polygon(
+    verification: environment.VerificationParam,
+    upload: bool = typer.Option(
+        False,
+        '--upload',
+        '-u',
+        help='If set, will upload the package to Polygon.',
+    ),
+    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,
+        '--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, main_language=language
+    )
+
+    if upload:
+        from rbx.box.packaging.polygon.upload import upload_problem
+
+        await upload_problem(
+            name=get_problem_name_with_contest_info(),
+            main_language=language,
+            upload_as_english=upload_as_english,
+        )
+
+
+@app.command('boca', help='Build a package for BOCA.')
+@package.within_problem
+@syncer.sync
+async def boca(
+    verification: environment.VerificationParam,
+    upload: bool = typer.Option(
+        False,
+        '--upload',
+        '-u',
+        help='If set, will upload the package to BOCA.',
+    ),
+):
+    from rbx.box.packaging.boca.packager import BocaPackager
+
+    result_path = await run_packager(BocaPackager, verification=verification)
+
+    if upload:
+        from rbx.box.tooling.boca.scraper import get_boca_scraper
+
+        uploader = get_boca_scraper()
+        uploader.login_and_upload(result_path)
+
+
+@app.command('moj', help='Build a package for MOJ.')
+@package.within_problem
+@syncer.sync
+async def moj(
+    verification: environment.VerificationParam,
+    for_boca: bool = typer.Option(
+        False, help='Build a package for BOCA instead of 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_cp-0.12.0 → rbx_cp-0.13.2}/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