rbx.cp 0.5.0__py3-none-any.whl

rbx/box/packaging/main.py

@@ -0,0 +1,68 @@
+import pathlib
+import tempfile
+from typing import Type
+
+import typer
+
+from rbx import annotations, console
+from rbx.box import builder, environment, package
+from rbx.box.package import get_build_path
+from rbx.box.packaging.boca.packager import BocaPackager
+from rbx.box.packaging.packager import BasePackager, BuiltStatement
+from rbx.box.packaging.polygon.packager import PolygonPackager
+from rbx.box.statements.build_statements import build_statement
+
+app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
+
+
+def run_packager(
+    packager_cls: Type[BasePackager],
+    verification: environment.VerificationParam,
+) -> pathlib.Path:
+    if not 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()
+    packager = packager_cls()
+
+    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 [item]{result_path}[/item].')
+    return result_path
+
+
+@app.command('polygon', help='Build a package for Polygon.')
+def polygon(
+    verification: environment.VerificationParam,
+):
+    run_packager(PolygonPackager, verification=verification)
+
+
+@app.command('boca', help='Build a package for BOCA.')
+def boca(
+    verification: environment.VerificationParam,
+):
+    run_packager(BocaPackager, verification=verification)

rbx/box/packaging/packager.py

@@ -0,0 +1,117 @@
+import dataclasses
+import pathlib
+from abc import ABC, abstractmethod
+from typing import List, Tuple
+
+from rbx.box import package
+from rbx.box.contest import contest_package
+from rbx.box.contest.schema import ContestProblem, ContestStatement
+from rbx.box.generators import get_all_built_testcases
+from rbx.box.schema import Package, Testcase, TestcaseGroup
+from rbx.box.statements.schema import Statement, StatementType
+
+
+@dataclasses.dataclass
+class BuiltStatement:
+    statement: Statement
+    path: pathlib.Path
+    output_type: StatementType
+
+
+@dataclasses.dataclass
+class BuiltContestStatement:
+    statement: ContestStatement
+    path: pathlib.Path
+    output_type: StatementType
+
+
+@dataclasses.dataclass
+class BuiltProblemPackage:
+    path: pathlib.Path
+    package: Package
+    problem: ContestProblem
+
+
+class BasePackager(ABC):
+    @abstractmethod
+    def name(self) -> str:
+        pass
+
+    def languages(self):
+        pkg = package.find_problem_package_or_die()
+
+        res = set()
+        for statement in pkg.statements:
+            res.add(statement.language)
+        return list(res)
+
+    def statement_types(self) -> List[StatementType]:
+        return [StatementType.PDF]
+
+    @abstractmethod
+    def package(
+        self,
+        build_path: pathlib.Path,
+        into_path: pathlib.Path,
+        built_statements: List[BuiltStatement],
+    ) -> pathlib.Path:
+        pass
+
+    # Helper methods.
+    def get_built_testcases_per_group(self):
+        return get_all_built_testcases()
+
+    def get_built_testcases(self) -> List[Tuple[TestcaseGroup, List[Testcase]]]:
+        pkg = package.find_problem_package_or_die()
+        tests_per_group = self.get_built_testcases_per_group()
+        return [(group, tests_per_group[group.name]) for group in pkg.testcases]
+
+    def get_flattened_built_testcases(self) -> List[Testcase]:
+        pkg = package.find_problem_package_or_die()
+        tests_per_group = self.get_built_testcases_per_group()
+
+        res = []
+        for group in pkg.testcases:
+            res.extend(tests_per_group[group.name])
+        return res
+
+    def get_statement_for_language(self, lang: str) -> Statement:
+        pkg = package.find_problem_package_or_die()
+        for statement in pkg.statements:
+            if statement.language == lang:
+                return statement
+        raise
+
+
+class BaseContestPackager(ABC):
+    @abstractmethod
+    def name(self) -> str:
+        pass
+
+    @abstractmethod
+    def package(
+        self,
+        built_packages: List[BuiltProblemPackage],
+        build_path: pathlib.Path,
+        into_path: pathlib.Path,
+        built_statements: List[BuiltContestStatement],
+    ) -> pathlib.Path:
+        pass
+
+    def languages(self):
+        pkg = contest_package.find_contest_package_or_die()
+
+        res = set()
+        for statement in pkg.statements:
+            res.add(statement.language)
+        return list(res)
+
+    def statement_types(self) -> List[StatementType]:
+        return [StatementType.PDF]
+
+    def get_statement_for_language(self, lang: str) -> ContestStatement:
+        contest = contest_package.find_contest_package_or_die()
+        for statement in contest.statements:
+            if statement.language == lang:
+                return statement
+        raise

rbx/box/packaging/polygon/packager.py

@@ -0,0 +1,320 @@
+import functools
+import pathlib
+import shutil
+from typing import List
+
+import iso639
+import typer
+
+from rbx import console
+from rbx.box import package
+from rbx.box.packaging.packager import (
+    BaseContestPackager,
+    BasePackager,
+    BuiltContestStatement,
+    BuiltProblemPackage,
+    BuiltStatement,
+)
+from rbx.box.packaging.polygon import xml_schema as polygon_schema
+from rbx.config import get_testlib
+
+DAT_TEMPLATE = """
+@contest "{name}"
+@contlen 300
+@problems {problems}
+@teams 0
+@submissions 0
+"""
+
+
+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):
+    def _validate(self):
+        langs = self.languages()
+        pkg = package.find_problem_package_or_die()
+
+        lang_codes = set()
+        for statement in pkg.statements:
+            lang_codes.add(statement.title)
+
+        for lang in langs:
+            if lang not in lang_codes:
+                console.console.print(
+                    f'[error]No statement from language [item]{lang}[/item] found. '
+                    'Polygon needs one statement for each language.[/error]'
+                )
+                raise typer.Exit(1)
+
+    def _get_names(self) -> List[polygon_schema.Name]:
+        return [
+            polygon_schema.Name(
+                language=code_to_langs([lang])[0],
+                value=self.get_statement_for_language(lang).title,
+            )
+            for lang in self.languages()
+        ]
+
+    def _get_checker(self) -> polygon_schema.Checker:
+        # TODO: support other checker languages
+        return polygon_schema.Checker(
+            name='rbx::checker',
+            type='testlib',
+            source=polygon_schema.File(path='files/check.cpp', type='cpp.g++17'),
+            cpy=polygon_schema.File(path='check.cpp'),
+        )
+
+    def _get_manual_test(self) -> polygon_schema.Test:
+        # TODO: return samples
+        return polygon_schema.Test(method='manual')
+
+    def _get_single_testset(self) -> polygon_schema.Testset:
+        pkg = package.find_problem_package_or_die()
+
+        if pkg.modifiers:
+            console.console.print(
+                f'[warning]Your package specify custom limit modifiers for languages {list(pkg.modifiers)}.[/warning]'
+            )
+            console.console.print(
+                '[warning]Polygon packages do not support language-based limit modifiers, so they will not be applied to the supplied limits.[/warning]'
+            )
+
+        console.console.print(
+            f'[warning]Polygon packages cannot honor the {pkg.outputLimit}kb output limit.'
+        )
+
+        testcases = self.get_flattened_built_testcases()
+
+        return polygon_schema.Testset(
+            name='tests',
+            timelimit=pkg.timeLimit,
+            memorylimit=pkg.memoryLimit * 1024 * 1024,
+            size=len(testcases),
+            inputPattern='tests/%03d',
+            answerPattern='tests/%03d.a',
+            tests=[self._get_manual_test() for _ in range(len(testcases))],
+        )
+
+    def _get_judging(self) -> polygon_schema.Judging:
+        return polygon_schema.Judging(testsets=[self._get_single_testset()])
+
+    def _get_files(self) -> List[polygon_schema.File]:
+        return [polygon_schema.File(path='files/testlib.h', type='h.g++')]
+
+    def _statement_application_type(self, statement: BuiltStatement) -> str:
+        return 'application/pdf'
+
+    def _process_statement(
+        self,
+        built_statement: BuiltStatement,
+        into_path: pathlib.Path,
+    ) -> polygon_schema.Statement:
+        language = code_to_langs([built_statement.statement.language])[0]
+        final_path = into_path / 'statements' / language / built_statement.path.name
+
+        final_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(built_statement.path, final_path)
+
+        return polygon_schema.Statement(
+            path=str(final_path.resolve().relative_to(into_path.resolve())),
+            language=language,
+            type=self._statement_application_type(built_statement),  # type: ignore
+        )
+
+    def _process_statements(
+        self, built_statements: List[BuiltStatement], into_path: pathlib.Path
+    ) -> List[polygon_schema.Statement]:
+        return [
+            self._process_statement(built_statement, into_path)
+            for built_statement in built_statements
+        ]
+
+    def name(self) -> str:
+        return 'polygon'
+
+    def package(
+        self,
+        build_path: pathlib.Path,
+        into_path: pathlib.Path,
+        built_statements: List[BuiltStatement],
+    ):
+        problem = polygon_schema.Problem(
+            names=self._get_names(),
+            checker=self._get_checker(),
+            judging=self._get_judging(),
+            files=self._get_files(),
+            # TODO: revisit polygon problem statements
+            # statements=self._process_statements(built_statements, into_path),
+        )
+
+        descriptor: str = problem.to_xml(
+            skip_empty=True,
+            encoding='utf-8',
+            pretty_print=True,
+            standalone=True,
+        )  # type: ignore
+        if isinstance(descriptor, bytes):
+            descriptor = descriptor.decode()
+
+        # Prepare files
+        files_path = into_path / 'files'
+        files_path.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(get_testlib(), files_path / 'testlib.h')
+        shutil.copyfile(package.get_checker().path, files_path / 'check.cpp')
+        shutil.copyfile(package.get_checker().path, into_path / 'check.cpp')
+
+        # Copy all testcases
+        (into_path / 'tests').mkdir(parents=True, exist_ok=True)
+        testcases = self.get_flattened_built_testcases()
+        for i, testcase in enumerate(testcases):
+            shutil.copyfile(
+                testcase.inputPath,
+                into_path / f'tests/{i+1:03d}',
+            )
+            if testcase.outputPath is not None:
+                shutil.copyfile(
+                    testcase.outputPath,
+                    into_path / f'tests/{i+1:03d}.a',
+                )
+            else:
+                (into_path / f'tests/{i+1:03d}.a').touch()
+
+        # Write problem.xml
+        (into_path / 'problem.xml').write_text(descriptor)
+
+        # Zip all.
+        shutil.make_archive(str(build_path / 'problem'), 'zip', into_path)
+
+        return build_path / 'problem.zip'
+
+
+class PolygonContestPackager(BaseContestPackager):
+    def name(self) -> str:
+        return 'polygon'
+
+    def _get_names(self) -> List[polygon_schema.Name]:
+        names = [
+            polygon_schema.Name(
+                language=code_to_langs([lang])[0],
+                value=self.get_statement_for_language(lang).title,
+            )
+            for lang in self.languages()
+            if _is_valid_lang_code(lang)
+        ]
+        if names:
+            names[0].main = True
+        return names
+
+    def _process_statement(
+        self,
+        built_statement: BuiltContestStatement,
+        into_path: pathlib.Path,
+    ) -> polygon_schema.Statement:
+        language = code_to_langs([built_statement.statement.language])[0]
+        final_path = into_path / 'statements' / language / built_statement.path.name
+
+        final_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(built_statement.path, final_path)
+
+        return polygon_schema.Statement(
+            path=str(final_path.resolve().relative_to(into_path.resolve())),
+            language=language,
+            type='application/pdf',  # type: ignore
+        )
+
+    def _process_statements(
+        self, built_statements: List[BuiltContestStatement], into_path: pathlib.Path
+    ) -> List[polygon_schema.Statement]:
+        return [
+            self._process_statement(built_statement, into_path)
+            for built_statement in built_statements
+        ]
+
+    def _get_problems(
+        self, built_packages: List[BuiltProblemPackage]
+    ) -> List[polygon_schema.ContestProblem]:
+        return [
+            polygon_schema.ContestProblem(
+                index=built_package.problem.short_name,
+                path=str(pathlib.Path('problems') / built_package.problem.short_name),
+            )
+            for built_package in built_packages
+        ]
+
+    def _get_dat(self, built_packages: List[BuiltProblemPackage]) -> str:
+        dat = DAT_TEMPLATE.format(
+            name=self.get_statement_for_language(self.languages()[0]).title,
+            problems=len(built_packages),
+        )
+        return (
+            dat
+            + '\n'.join(
+                f'@p {pkg.problem.short_name},{pkg.problem.short_name},20,0'
+                for pkg in built_packages
+            )
+            + '\n'
+        )
+
+    def package(
+        self,
+        built_packages: List[BuiltProblemPackage],
+        build_path: pathlib.Path,
+        into_path: pathlib.Path,
+        built_statements: List[BuiltContestStatement],
+    ) -> pathlib.Path:
+        filtered_statements = []
+        for built_statement in built_statements:
+            if not _is_valid_lang_code(built_statement.statement.language):
+                continue
+            filtered_statements.append(built_statement)
+
+        for built_package in built_packages:
+            pkg_path = into_path / 'problems' / built_package.problem.short_name
+            pkg_path.mkdir(parents=True, exist_ok=True)
+
+            shutil.unpack_archive(built_package.path, pkg_path, format='zip')
+
+        # Build contest descriptor.
+        contest = polygon_schema.Contest(
+            names=self._get_names(),
+            statements=self._process_statements(filtered_statements, into_path),
+            problems=self._get_problems(built_packages),
+        )
+        descriptor: str = contest.to_xml(
+            skip_empty=True,
+            encoding='utf-8',
+            pretty_print=True,
+            standalone=True,
+        )  # type: ignore
+        if isinstance(descriptor, bytes):
+            descriptor = descriptor.decode()
+
+        # Write contest.xml
+        (into_path / 'contest.xml').write_text(descriptor)
+
+        # Write contest.dat
+        (into_path / 'contest.dat').write_text(self._get_dat(built_packages))
+
+        # Zip all.
+        shutil.make_archive(str(build_path / 'contest'), 'zip', into_path)
+
+        return pathlib.Path('contest.zip')

rbx/box/packaging/polygon/test.py

@@ -0,0 +1,81 @@
+from rbx.box.packaging.polygon import xml_schema as polygon_schema
+
+if __name__ == '__main__':
+    print(
+        polygon_schema.Problem.from_xml("""
+<problem>
+  <names>
+    <name language="english" value="Poliedro"/>
+    <name language="portuguese" value="Poliedro"/>
+  </names>
+  <statements>
+    <statement charset="UTF-8" language="english" mathjax="true" path="statements/english/problem.tex" type="application/x-tex"/>
+    <statement charset="UTF-8" language="portuguese" mathjax="true" path="statements/portuguese/problem.tex" type="application/x-tex"/>
+    <statement charset="UTF-8" language="english" mathjax="true" path="statements/.html/english/problem.html" type="text/html"/>
+    <statement charset="UTF-8" language="portuguese" mathjax="true" path="statements/.html/portuguese/problem.html" type="text/html"/>
+    <statement language="english" path="statements/.pdf/english/problem.pdf" type="application/pdf"/>
+    <statement language="portuguese" path="statements/.pdf/portuguese/problem.pdf" type="application/pdf"/>
+  </statements>
+  <judging input-file="" output-file="">
+    <testset name="tests">
+      <time-limit>1000</time-limit>
+      <memory-limit>268435456</memory-limit>
+      <test-count>13</test-count>
+      <input-path-pattern>tests/%02d</input-path-pattern>
+      <answer-path-pattern>tests/%02d.a</answer-path-pattern>
+      <tests>
+        <test method="manual"/>
+        <test method="manual"/>
+        <test method="manual"/>
+        <test method="manual"/>
+        <test method="manual"/>
+        <test method="manual"/>
+        <test method="manual"/>
+        <test method="manual"/>
+        <test method="manual"/>
+        <test method="manual"/>
+        <test method="manual"/>
+        <test method="manual"/>
+        <test method="manual"/>
+      </tests>
+    </testset>
+  </judging>
+  <files>
+    <resources>
+      <file path="files/jngen.h" type="h.g++"/>
+      <file path="files/olymp.sty"/>
+      <file path="files/problem.tex"/>
+      <file path="files/statements.ftl"/>
+      <file path="files/testlib.h" type="h.g++"/>
+    </resources>
+  </files>
+  <assets>
+    <checker name="std::ncmp.cpp" type="testlib">
+      <source path="files/check.cpp" type="cpp.g++17"/>
+      <binary path="check.exe" type="exe.win32"/>
+      <copy path="check.cpp"/>
+    </checker>                              
+  </assets>                                       
+</problem>
+""")
+    )
+
+    print(
+        polygon_schema.Contest.from_xml("""
+<contest>
+<names>
+<name language="russian" main="true" value="2012-2013 Тренировка СПбГУ B #12 Бинарный поиск, тернарный поиск"/>
+</names>
+<statements>
+<statement language="russian" path="statements/russian/20122013-tryenirovka-spbgu-b-12-binarnyy-poisk-tyernarnyy-poisk-ru.pdf" type="application/pdf"/>
+</statements>
+<problems>
+<problem index="A" path="problems/A"/>
+<problem index="B" path="problems/B"/>
+<problem index="C" path="problems/C"/>
+<problem index="D" path="problems/D"/>
+<problem index="E" path="problems/E"/>
+</problems>
+</contest>
+""")
+    )

rbx/box/packaging/polygon/xml_schema.py

@@ -0,0 +1,106 @@
+from typing import List, Literal, Optional
+
+from pydantic_xml import BaseXmlModel, attr, element, wrapped
+
+
+class Name(BaseXmlModel):
+    language: str = attr()
+    value: str = attr()
+    main: bool = attr(default=False)
+
+
+class Statement(BaseXmlModel):
+    charset: Optional[Literal['UTF-8']] = attr(default=None)
+
+    language: str = attr()
+
+    mathjax: bool = attr(default=False)
+
+    path: str = attr()
+
+    type: Literal['application/x-tex', 'application/pdf', 'text/html'] = attr()
+
+
+class File(BaseXmlModel):
+    path: str = attr()
+    type: Optional[str] = attr(default=None)
+
+
+class Test(BaseXmlModel):
+    method: Literal['manual', 'generated'] = attr()
+
+    sample: Optional[bool] = attr(default=None)
+
+    description: Optional[str] = attr(default=None)
+
+
+class Testset(BaseXmlModel):
+    name: Optional[str] = attr(default=None)
+
+    timelimit: Optional[int] = element('time-limit', default=1000)
+    memorylimit: Optional[int] = element('memory-limit', default=256 * 1024 * 1024)
+
+    size: int = element('test-count', default=None)
+
+    inputPattern: str = element('input-path-pattern')
+    answerPattern: str = element('answer-path-pattern')
+
+    tests: List[Test] = wrapped('tests', element(tag='test'), default_factory=list)
+
+
+class Judging(BaseXmlModel):
+    inputFile: str = attr(default='')
+    outputFile: str = attr(default='')
+
+    testsets: List[Testset] = element(tag='testset', default_factory=list)
+
+
+class Checker(BaseXmlModel):
+    name: str = attr()
+    type: Literal['testlib'] = attr()
+    source: File = element()
+    binary: Optional[File] = element(default=None)
+    cpy: Optional[File] = element(tag='copy', default=None)
+
+    testset: Optional[Testset] = element(default=None)
+
+
+class Problem(BaseXmlModel, tag='problem'):
+    names: List[Name] = wrapped('names', element(tag='name'), default_factory=list)
+
+    statements: List[Statement] = wrapped(
+        'statements',
+        element(tag='statement', default=[]),
+        default=[],
+    )
+
+    judging: Judging = element()
+
+    files: List[File] = wrapped(
+        'files/resources',
+        element(tag='file', default=[]),
+        default=[],
+    )
+
+    checker: Checker = wrapped('assets', element(tag='checker'))
+
+
+class ContestProblem(BaseXmlModel):
+    index: str = attr()
+    path: str = attr()
+
+
+class Contest(BaseXmlModel, tag='contest'):
+    names: List[Name] = wrapped('names', element(tag='name'), default_factory=list)
+
+    statements: List[Statement] = wrapped(
+        'statements',
+        element(tag='statement', default=[]),
+        default=[],
+    )
+
+    problems: List[ContestProblem] = wrapped(
+        'problems',
+        element(tag='problem', default=[]),
+        default=[],
+    )