rbx.cp 0.11.2__py3-none-any.whl → 0.13.2__py3-none-any.whl

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

rbx/box/packaging/polygon/importer.py

@@ -0,0 +1,232 @@
+import pathlib
+import shutil
+from typing import List, Optional
+
+import typer
+
+from rbx import console, utils
+from rbx.box import lang
+from rbx.box.packaging.importer import BaseImporter
+from rbx.box.packaging.polygon.xml_schema import File, Problem, Statement, Testset
+from rbx.box.schema import CodeItem, Interactor, Package, TaskType, TestcaseGroup
+from rbx.box.statements.schema import Statement as BoxStatement
+from rbx.box.statements.schema import StatementType
+
+
+def _get_main_testset(problem: Problem) -> Testset:
+    for testset in problem.judging.testsets:
+        if testset.name == 'tests':
+            return testset
+    console.console.print(
+        '[error][item]tests[/item] testset not found[/error]',
+    )
+    raise typer.Exit(1)
+
+
+def _get_pdf_statements(problem: Problem) -> List[Statement]:
+    statements = []
+    for statement in problem.statements:
+        if statement.type == 'application/pdf':
+            statements.append(statement)
+    return statements
+
+
+def _get_statement_path(statement: Statement) -> pathlib.Path:
+    return pathlib.Path('statements') / f'{statement.language}.pdf'
+
+
+def _populate_tests(
+    testset: Testset, pkg: Package, pkg_path: pathlib.Path, into_path: pathlib.Path
+):
+    if not testset.answerPattern:
+        console.console.print(
+            '[error][item]answer pattern[/item] not found for testset[/error]',
+        )
+        raise typer.Exit(1)
+
+    for d, test in enumerate(testset.tests):
+        folder_name = 'tests/samples' if test.sample else 'tests/tests'
+        i = d + 1
+
+        input_path = pathlib.Path(testset.inputPattern % i)
+        dest_input_path = into_path / folder_name / f'{i:03d}.in'
+        dest_input_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy(pkg_path / input_path, dest_input_path)
+
+        answer_path = pathlib.Path(testset.answerPattern % i)
+        dest_answer_path = into_path / folder_name / f'{i:03d}.ans'
+        dest_answer_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy(pkg_path / answer_path, dest_answer_path)
+
+    pkg.testcases = [
+        TestcaseGroup(
+            name='samples',
+            testcaseGlob='tests/samples/*.in',
+        ),
+        TestcaseGroup(
+            name='tests',
+            testcaseGlob='tests/tests/*.in',
+        ),
+    ]
+
+
+def _populate_statements(
+    problem: Problem,
+    pkg: Package,
+    pkg_path: pathlib.Path,
+    into_path: pathlib.Path,
+    main_language: Optional[str] = None,
+):
+    name_per_language = {name.language: name for name in problem.names}
+    pdf_statements = _get_pdf_statements(problem)
+    pkg_statements = []
+    found_main = False
+
+    for statement in pdf_statements:
+        if statement.language not in name_per_language:
+            continue
+        name = name_per_language[statement.language]
+        statement_path = into_path / _get_statement_path(statement)
+        statement_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy(pkg_path / statement.path, statement_path)
+
+        iso639_code = lang.lang_to_code(statement.language)
+
+        pkg_statement = BoxStatement(
+            name=f'statement-{name.language}',
+            title=name.value,
+            language=iso639_code,
+            path=_get_statement_path(statement),
+            type=StatementType.PDF,
+        )
+
+        if (
+            main_language is not None
+            and main_language == iso639_code
+            and not found_main
+        ):
+            # If main statement, add it to the front of the list
+            pkg_statements = [pkg_statement] + pkg_statements
+            found_main = True
+            continue
+
+        if name.main and not found_main:
+            # If main statement, add it to the front of the list
+            pkg_statements = [pkg_statement] + pkg_statements
+            found_main = True
+            continue
+
+        pkg_statements.append(pkg_statement)
+
+    pkg.statements = pkg_statements
+
+    if main_language is not None and not found_main:
+        console.console.print(
+            f'[error]Main statement of language [item]{main_language}[/item] not found.[/error]',
+        )
+        raise typer.Exit(1)
+
+
+def _is_cpp_source(source: File) -> bool:
+    if source.type is None:
+        return False
+    return 'cpp' in source.type
+
+
+def _copy_checker(
+    problem: Problem, pkg: Package, pkg_path: pathlib.Path, into_path: pathlib.Path
+):
+    if problem.checker is None:
+        return
+    if problem.checker.type != 'testlib' or not _is_cpp_source(problem.checker.source):
+        console.console.print(
+            f'[error][item]checker type[/item] not supported: [item]{problem.checker.type}[/item][/error]',
+        )
+        raise typer.Exit(1)
+    shutil.copy(pkg_path / problem.checker.source.path, into_path / 'checker.cpp')
+
+    pkg.checker = CodeItem(
+        path=pathlib.Path('checker.cpp'),
+    )
+
+
+def _copy_interactor(
+    problem: Problem, pkg: Package, pkg_path: pathlib.Path, into_path: pathlib.Path
+):
+    if problem.interactor is None:
+        return
+    shutil.copy(pkg_path / problem.interactor.source.path, into_path / 'interactor.cpp')
+
+    if not _is_cpp_source(problem.interactor.source):
+        console.console.print(
+            f'[error]Only C++ interactor is supported, got [item]{problem.interactor.source.type}[/item][/error]',
+        )
+        raise typer.Exit(1)
+
+    pkg.type = TaskType.COMMUNICATION
+    pkg.interactor = Interactor(
+        path=pathlib.Path('interactor.cpp'),
+        legacy=True,
+    )
+
+
+def _copy_headers(
+    problem: Problem, pkg: Package, pkg_path: pathlib.Path, into_path: pathlib.Path
+):
+    headers = []
+    for file in problem.files:
+        if file.type is None or not file.type.startswith('h.'):
+            continue
+        header_path = pkg_path / file.path
+        dest_path = into_path / header_path.name
+        if header_path.name == 'rbx.h':
+            dest_path = into_path / 'rbx.override.h'
+        shutil.copy(header_path, dest_path)
+        headers.append(dest_path.name)
+
+    if pkg.checker is not None:
+        pkg.checker.compilationFiles = headers
+
+    if pkg.interactor is not None:
+        pkg.interactor.compilationFiles = headers
+
+
+class PolygonImporter(BaseImporter):
+    def __init__(self, main_language: Optional[str]):
+        self.main_language = main_language
+
+    @classmethod
+    def name(cls) -> str:
+        return 'polygon'
+
+    async def import_package(self, pkg_path: pathlib.Path, into_path: pathlib.Path):
+        problem_xml = pkg_path / 'problem.xml'
+        if not problem_xml.exists():
+            console.console.print(
+                '[error][item]problem.xml[/item] not found[/error]',
+            )
+            raise typer.Exit(1)
+
+        problem = Problem.from_xml(problem_xml.read_bytes())
+        testset = _get_main_testset(problem)
+
+        if testset.timelimit is None:
+            testset.timelimit = 1000
+
+        if testset.memorylimit is None:
+            testset.memorylimit = 256 * 1024 * 1024
+
+        pkg = Package(
+            name=problem.short_name,
+            timeLimit=testset.timelimit,
+            memoryLimit=testset.memorylimit // (1024 * 1024),
+            outputLimit=64 * 1024,
+        )
+
+        _populate_tests(testset, pkg, pkg_path, into_path)
+        _populate_statements(problem, pkg, pkg_path, into_path, self.main_language)
+        _copy_checker(problem, pkg, pkg_path, into_path)
+        _copy_interactor(problem, pkg, pkg_path, into_path)
+        _copy_headers(problem, pkg, pkg_path, into_path)
+
+        (into_path / 'problem.rbx.yml').write_text(utils.model_to_yaml(pkg))

rbx/box/packaging/polygon/packager.py

@@ -6,7 +6,7 @@ import typer
 
 from rbx import console, utils
 from rbx.box import header, package
-from rbx.box.lang import code_to_langs, is_valid_lang_code
+from rbx.box.lang import code_to_lang, code_to_langs, is_valid_lang_code
 from rbx.box.packaging.packager import (
     BaseContestPackager,
     BasePackager,
@@ -27,7 +27,31 @@ DAT_TEMPLATE = """
 """
 
 
+def _select_main_language(
+    names: List[polygon_schema.Name], main_language: Optional[str]
+):
+    if names:
+        if main_language is not None:
+            lang_name = code_to_lang(main_language)
+            found = False
+            for name in names:
+                if name.language == lang_name:
+                    name.main = True
+                    found = True
+                    break
+            if not found:
+                console.console.print(
+                    f'[error]Main language [item]{main_language}[/item] not found.[/error]'
+                )
+                raise typer.Exit(1)
+        else:
+            names[0].main = True
+
+
 class PolygonPackager(BasePackager):
+    def __init__(self, main_language: Optional[str] = None):
+        self.main_language = main_language
+
     @classmethod
     def task_types(cls) -> List[TaskType]:
         return [TaskType.BATCH, TaskType.COMMUNICATION]
@@ -49,7 +73,7 @@ class PolygonPackager(BasePackager):
                 raise typer.Exit(1)
 
     def _get_names(self) -> List[polygon_schema.Name]:
-        return [
+        names = [
             polygon_schema.Name(
                 language=code_to_langs([lang])[0],
                 value=self.get_statement_for_language(lang).title,
@@ -57,6 +81,10 @@ class PolygonPackager(BasePackager):
             for lang in self.languages()
         ]
 
+        _select_main_language(names, self.main_language)
+
+        return names
+
     def _get_checker(self) -> polygon_schema.Checker:
         # TODO: support other checker languages
         return polygon_schema.Checker(
@@ -155,6 +183,7 @@ class PolygonPackager(BasePackager):
         pkg = package.find_problem_package_or_die()
 
         problem = polygon_schema.Problem(
+            short_name=pkg.name,
             names=self._get_names(),
             checker=self._get_checker(),
             judging=self._get_judging(),
@@ -209,6 +238,9 @@ class PolygonPackager(BasePackager):
 
 
 class PolygonContestPackager(BaseContestPackager):
+    def __init__(self, main_language: Optional[str] = None):
+        self.main_language = main_language
+
     @classmethod
     def name(cls) -> str:
         return 'polygon'
@@ -222,8 +254,7 @@ class PolygonContestPackager(BaseContestPackager):
             for lang in self.languages()
             if is_valid_lang_code(lang)
         ]
-        if names:
-            names[0].main = True
+        _select_main_language(names, self.main_language)
         return names
 
     def _process_statement(
@@ -319,4 +350,4 @@ class PolygonContestPackager(BaseContestPackager):
         # Zip all.
         shutil.make_archive(str(build_path / 'contest'), 'zip', into_path)
 
-        return pathlib.Path('contest.zip')
+        return build_path / 'contest.zip'

rbx/box/packaging/polygon/upload.py

@@ -214,8 +214,7 @@ def _upload_testcases(problem: api.Problem):
 
 def _upload_solutions(problem: api.Problem):
     console.console.print('Uploading main solution...')
-    pkg = package.find_problem_package_or_die()
-    main_solution = pkg.solutions[0]
+    main_solution = package.get_main_solution()
     if main_solution is None or main_solution.outcome != ExpectedOutcome.ACCEPTED:
         return
     problem.save_solution(
@@ -225,7 +224,7 @@ def _upload_solutions(problem: api.Problem):
         tag=api.SolutionTag.MA,
     )
 
-    for i, solution in enumerate(pkg.solutions):
+    for i, solution in enumerate(package.get_solutions()):
         console.console.print(
             f'Uploading solution [item]{solution.path.name}[/item] (tag: [item]{_get_solution_tag(solution, is_first=i == 0)}[/item])...'
         )
@@ -296,19 +295,32 @@ def _upload_statement_resources(problem: api.Problem, statement: Statement):
         )
 
 
-def _upload_statement(problem: api.Problem, preserve_language: bool = False):
+def _upload_statement(
+    problem: api.Problem, main_language: Optional[str], upload_as_english: bool = False
+):
     pkg = package.find_problem_package_or_die()
 
+    lang_list = []
     languages = set()
     for statement in pkg.expanded_statements:
         if not is_valid_lang_code(statement.language):
             continue
         languages.add(statement.language)
-
+        lang_list.append(statement.language)
     uploaded_languages = set()
 
+    if main_language is None:
+        main_language = lang_list[0]
+
+    # Put the main language first.
+    lang_list = list(languages)
+    for i in range(len(lang_list)):
+        if lang_list[i] == main_language:
+            lang_list[i], lang_list[0] = lang_list[0], lang_list[i]
+            break
+
     # Prioritize English statements.
-    for language in ['en'] + list(languages):
+    for language in lang_list:
         statement = _get_statement_for_language(language)
         if statement is None:
             continue
@@ -318,15 +330,19 @@ 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'
+        uploaded_language = statement_lang
+        if main_language == language:
+            if not upload_as_english:
+                console.console.print(
+                    '[warning]By default, Polygon statements are uploaded respecting their original language.\n'
+                    'Codeforces does not work well with statements in other languages. If you want a better experience, '
+                    'use the [item]--upload-as-english[/item] option to force the main statement to be uploaded in English.[/warning]'
+                )
+            else:
+                uploaded_language = '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'
-                'If you want to preserve the original language of your statement, use [item]--preserve-language[/item].'
-            )
         blocks = _get_statement_blocks(statement)
         polygon_statement = api.Statement(
             encoding='utf-8',
@@ -351,7 +367,9 @@ def _normalize_problem_name(name: str) -> str:
     return name.replace(' ', '-').replace('_', '-').lower()
 
 
-async def upload_problem(name: str, preserve_language: bool = False):
+async def upload_problem(
+    name: str, main_language: Optional[str], upload_as_english: bool = False
+):
     pkg = package.find_problem_package_or_die()
     name = _normalize_problem_name(name)
     problem = _find_or_create_problem(name)
@@ -370,7 +388,9 @@ async def upload_problem(name: str, preserve_language: bool = False):
 
     _upload_solutions(problem)
     _upload_testcases(problem)
-    _upload_statement(problem, preserve_language=preserve_language)
+    _upload_statement(
+        problem, main_language=main_language, upload_as_english=upload_as_english
+    )
 
     # Commit.
     console.console.print('Committing changes...')