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

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

@@ -295,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
@@ -317,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',
@@ -350,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)
@@ -369,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...')

rbx/box/packaging/polygon/xml_schema.py

@@ -10,7 +10,7 @@ class Name(BaseXmlModel):
 
 
 class Statement(BaseXmlModel):
-    charset: Optional[Literal['UTF-8']] = attr(default=None)
+    charset: Optional[str] = attr(default=None)
 
     language: str = attr()
 
@@ -43,9 +43,12 @@ class Testset(BaseXmlModel):
     size: int = element('test-count', default=None)
 
     inputPattern: str = element('input-path-pattern')
-    answerPattern: str = element('answer-path-pattern')
+    outputPattern: Optional[str] = element('output-path-pattern', default=None)
+    answerPattern: Optional[str] = element('answer-path-pattern', default=None)
 
-    tests: List[Test] = wrapped('tests', element(tag='test'), default_factory=list)
+    tests: List[Test] = wrapped(
+        'tests', element(tag='test', default=None), default_factory=list
+    )
 
 
 class Judging(BaseXmlModel):
@@ -56,7 +59,7 @@ class Judging(BaseXmlModel):
 
 
 class Checker(BaseXmlModel):
-    name: str = attr()
+    name: Optional[str] = attr(default=None)
     type: Literal['testlib'] = attr()
     source: File = element()
     binary: Optional[File] = element(default=None)
@@ -70,6 +73,8 @@ class Interactor(BaseXmlModel):
 
 
 class Problem(BaseXmlModel, tag='problem'):
+    short_name: str = attr('short-name')
+
     names: List[Name] = wrapped('names', element(tag='name'), default_factory=list)
 
     statements: List[Statement] = wrapped(
@@ -86,9 +91,13 @@ class Problem(BaseXmlModel, tag='problem'):
         default=[],
     )
 
-    checker: Checker = wrapped('assets', element(tag='checker'))
+    checker: Optional[Checker] = wrapped(
+        'assets', element(tag='checker', default=None), default=None
+    )
 
-    interactor: Optional[Interactor] = wrapped('assets', element(tag='interactor'))
+    interactor: Optional[Interactor] = wrapped(
+        'assets', element(tag='interactor', default=None), default=None
+    )
 
 
 class ContestProblem(BaseXmlModel):

rbx/box/stresses.py

@@ -67,7 +67,7 @@ async def run_stress(
             raise typer.Exit(1)
         generator = generators.get_call_from_string(generator_call)
         stress = Stress(
-            name=f'{generator.name}',
+            name=f'{pathlib.Path(generator.name).stem}',
             generator=generator,
             finder=finder,
         )

rbx/box/tooling/converter.py

@@ -0,0 +1,76 @@
+import pathlib
+import tempfile
+from typing import Optional
+
+import typer
+
+from rbx import console
+from rbx.box import builder, cd, package
+from rbx.box.environment import VerificationLevel
+from rbx.box.packaging.boca.packager import BocaPackager
+from rbx.box.packaging.importer import BaseImporter
+from rbx.box.packaging.moj.packager import MojPackager
+from rbx.box.packaging.packager import BasePackager, BuiltStatement
+from rbx.box.packaging.polygon.importer import PolygonImporter
+from rbx.box.packaging.polygon.packager import PolygonPackager
+from rbx.box.statements.build_statements import build_statement
+
+PACKAGER_REGISTRY = {
+    'polygon': PolygonPackager,
+    'boca': BocaPackager,
+    'moj': MojPackager,
+}
+
+IMPORTER_REGISTRY = {
+    'polygon': PolygonImporter,
+}
+
+
+def get_packager(source: str, **kwargs) -> BasePackager:
+    if source not in PACKAGER_REGISTRY:
+        console.console.print(f'Unknown packager: {source}')
+        raise typer.Exit(1)
+    return PACKAGER_REGISTRY[source](**kwargs)
+
+
+def get_importer(source: str, **kwargs) -> BaseImporter:
+    if source not in IMPORTER_REGISTRY:
+        console.console.print(f'Unknown importer: {source}')
+        raise typer.Exit(1)
+    return IMPORTER_REGISTRY[source](**kwargs)
+
+
+async def convert(
+    pkg_dir: pathlib.Path,
+    into_dir: pathlib.Path,
+    source: str,
+    destination: str,
+    main_language: Optional[str] = None,
+) -> pathlib.Path:
+    importer = get_importer(source, main_language=main_language)
+    packager = get_packager(destination)
+    await importer.import_package(pkg_dir, into_dir)
+
+    with cd.new_package_cd(into_dir):
+        package.clear_package_cache()
+
+        pkg = package.find_problem_package_or_die()
+
+        if not await builder.build(VerificationLevel.NONE.value):
+            console.console.print('[error]Failed to build the problem.[/error]')
+            raise typer.Exit(1)
+
+        built_statements = []
+        for statement_type in packager.statement_types():
+            for language in packager.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)
+                )
+
+        with tempfile.TemporaryDirectory() as td:
+            result_path = packager.package(
+                package.get_build_path(), pathlib.Path(td), built_statements
+            )
+            return result_path

rbx/box/tooling/main.py

@@ -1,8 +1,61 @@
+import atexit
+import pathlib
+import shutil
+import tempfile
+import zipfile
+from typing import Annotated, Optional
+
+import syncer
 import typer
 
-from rbx import annotations
+from rbx import annotations, console
+from rbx.box.tooling import converter
 from rbx.box.tooling.boca import main as boca_main
 
 app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
 
 app.add_typer(boca_main.app, name='boca')
+
+
+@app.command('convert')
+@syncer.sync
+async def convert(
+    pkg: Annotated[pathlib.Path, typer.Argument(help='The package to convert.')],
+    source: Annotated[
+        str, typer.Option('-s', '--source', help='The format to convert from.')
+    ],
+    dest: Annotated[
+        str, typer.Option('-d', '--dest', help='The format to convert to.')
+    ],
+    output: Annotated[str, typer.Option('-o', '--output', help='The output path.')],
+    language: Annotated[
+        Optional[str],
+        typer.Option('--language', '-l', help='The main language of the problem.'),
+    ] = None,
+):
+    if pkg.suffix == '.zip':
+        temp_dir = tempfile.TemporaryDirectory()
+        with zipfile.ZipFile(pkg, 'r') as zip_ref:
+            zip_ref.extractall(temp_dir.name)
+        pkg = pathlib.Path(temp_dir.name)
+
+        atexit.register(temp_dir.cleanup)
+
+    if not pkg.is_dir():
+        console.console.print(f'[error]Package {pkg} is not a directory.[/error]')
+        raise typer.Exit(1)
+
+    with tempfile.TemporaryDirectory() as td:
+        result_path = await converter.convert(
+            pkg, pathlib.Path(td), source, dest, main_language=language
+        )
+        output_path = pathlib.Path(output)
+        if output_path.suffix == '.zip':
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(result_path, output_path)
+        else:
+            output_path.mkdir(parents=True, exist_ok=True)
+            shutil.unpack_archive(result_path, output_path)
+        console.console.print(
+            f'[success]Converted package to [item]{output_path}[/item].[/success]'
+        )

rbx/resources/presets/default/problem/problem.rbx.yml

@@ -5,9 +5,6 @@ timeLimit: 1000 # ms
 memoryLimit: 256 # MiB
 checker: {path: "wcmp.cpp"} # Download others from testlib with `rbx download checker`
 validator: {path: "validator.cpp"}
-generators:
-  - path: "gens/gen.cpp"
-    name: "gen"
 testcases:
   - name: "samples"
     testcaseGlob: "manual_tests/samples/*.in" # Pattern for the sample inputs.
@@ -39,7 +36,7 @@ statements:
 stresses:
   - name: "stress"
     generator:
-      name: "gen"
+      name: "gens/gen"
       args: "[1..<MAX_N>] @" # `@` generates a random string
     finder: "[sols/wa.cpp] ~ INCORRECT"
 unitTests:

rbx/resources/presets/default/problem/testplan/random.py

@@ -1,3 +1,3 @@
 # Generate 10 random testcases with n <= 1e9
 for i in range(10):
-    print(f'gen 1000000000 {i}')
+    print(f'gens/gen 1000000000 {i}')

rbx/resources/presets/default/problem/testplan/random.txt

@@ -1,4 +1,2 @@
-gen 123456
-gen 12345678
-# Obtained by running `rbx stress -g 'gen [1..<MAX_N>] @' -f '[sols/wa.cpp] ~ INCORRECT'`
-gen 149403982 b139a2bd
+gens/gen 123456
+gens/gen 12345678

{rbx_cp-0.12.0.dist-info → rbx_cp-0.13.2.dist-info}/METADATA

@@ -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)