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

rbx/box/builder.py

@@ -96,10 +96,10 @@ async def verify(verification: environment.VerificationParam) -> bool:
 
     tracked_solutions = None
     if verification < VerificationLevel.ALL_SOLUTIONS.value:
-        pkg = package.find_problem_package_or_die()
-
         tracked_solutions = {
-            str(solution.path) for solution in pkg.solutions if is_fast(solution)
+            str(solution.path)
+            for solution in package.get_solutions()
+            if is_fast(solution)
         }
 
     with utils.StatusProgress('Running solutions...') as s:

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/contest/build_contest_statements.py

@@ -1,6 +1,5 @@
 import dataclasses
 import pathlib
-import subprocess
 import tempfile
 import typing
 from typing import Any, Dict, List, Optional, Tuple
@@ -13,7 +12,7 @@ from rbx.box.contest.contest_package import get_problems
 from rbx.box.contest.schema import Contest, ContestProblem, ContestStatement
 from rbx.box.formatting import href
 from rbx.box.schema import Package, Testcase
-from rbx.box.statements import build_statements
+from rbx.box.statements import build_statements, latex
 from rbx.box.statements.build_statements import (
     get_builders,
     get_environment_languages_for_statement,
@@ -253,10 +252,10 @@ def build_contest_only(
                 console.console.log(
                     f'Installing LaTeX packages for [item]{statement.name} {statement.language}[/item]...'
                 )
-                subprocess.run(
-                    ['texliveonfly', output],
-                    cwd=td,
-                )
+                tmp_file = pathlib.Path(td) / '__tmp_install__.tex'
+                tmp_file.write_bytes(output)
+                latex.install_tex_packages(tmp_file, pathlib.Path(td))
+
         last_content = output
         last_output = bdr.output_type()
 

rbx/box/contest/statements.py

@@ -49,7 +49,6 @@ async def build(
     vars: Annotated[
         Optional[List[str]],
         typer.Option(
-            '-v',
             '--vars',
             help='Variables to be used in the statements.',
         ),

rbx/box/generators.py

@@ -1,3 +1,4 @@
+import functools
 import pathlib
 import shutil
 from typing import Dict, List, Optional, Set
@@ -40,12 +41,44 @@ def _compile_generator(generator: CodeItem) -> str:
     return compile_item(generator, sanitized=SanitizationLevel.PREFER)
 
 
+@functools.cache
+def _warn_once_about_crlf():
+    console.console.print(
+        '[warning]It seems a few files have CRLF (\\r\\n) line endings.[/warning]'
+    )
+    console.console.print(
+        '[warning]This usually happens when the file is created on Windows. Please convert the file to LF (\\n) line endings.[/warning]'
+    )
+    console.console.print(
+        '[warning]If you are in VSCode, you can make sure LF (\\n) line endings are used by changing the [item]"files.eol"[/item] setting.[/warning]'
+    )
+
+
+@functools.cache
+def _warn_about_crlf(path: pathlib.Path):
+    _warn_once_about_crlf()
+    console.console.print(
+        f'[warning]Testcase file [item]{path}[/item] has CRLF (\\r\\n) line endings, converting to LF (\\n).[/warning]'
+    )
+
+
+def _check_crlf(path: pathlib.Path):
+    with open(path, 'rb') as f:
+        for line in f:
+            if line.endswith(b'\r\n') or line.endswith(b'\n\r'):
+                _warn_about_crlf(path)
+                break
+
+    path.write_text(path.read_text().replace('\r', ''))
+
+
 def _copy_testcase_over(
     testcase: Testcase,
     dest: Testcase,
 ):
     testcase = fill_output_for_defined_testcase(testcase)
     dest.inputPath.parent.mkdir(parents=True, exist_ok=True)
+    _check_crlf(testcase.inputPath)
     shutil.copy(
         str(testcase.inputPath),
         str(dest.inputPath),
@@ -55,6 +88,7 @@ def _copy_testcase_over(
         and testcase.outputPath.is_file()
         and dest.outputPath is not None
     ):
+        _check_crlf(testcase.outputPath)
         dest.outputPath.parent.mkdir(parents=True, exist_ok=True)
         shutil.copy(
             str(testcase.outputPath),
@@ -63,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)
 
@@ -71,38 +108,64 @@ def _copy_testcase_output_over(
     if not src_path.is_file():
         return False
 
+    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():
-        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}
@@ -120,35 +183,42 @@ def get_call_from_string(call_str: str) -> GeneratorCall:
 async def _get_necessary_generators_for_groups(
     groups: Optional[Set[str]] = None,
 ) -> Set[str]:
-    pkg = package.find_problem_package_or_die()
-    existing_generators = set(generator.name for generator in pkg.generators)
     necessary_generators = set()
 
     class NecessaryGeneratorsVisitor(TestcaseGroupVisitor):
         async def visit(self, entry: GenerationTestcaseEntry):
             if entry.metadata.generator_call is not None:
+                if (
+                    package.get_generator_or_nil(entry.metadata.generator_call.name)
+                    is None
+                ):
+                    console.console.print(
+                        f'[error]Generator [item]{entry.metadata.generator_call.name}[/item] is not present in the package.[/error]'
+                    )
+                    if entry.metadata.generator_script is not None:
+                        console.console.print(
+                            f'[error]This generator is referenced from [item]{entry.metadata.generator_script}[/item].[/error]'
+                        )
+                    raise typer.Exit(1)
                 necessary_generators.add(entry.metadata.generator_call.name)
 
     await run_testcase_visitor(NecessaryGeneratorsVisitor(groups))
 
-    return existing_generators.intersection(necessary_generators)
+    return necessary_generators
 
 
 def compile_generators(
+    tracked_generators: Set[str],
     progress: Optional[StatusProgress] = None,
-    tracked_generators: Optional[Set[str]] = None,
 ) -> Dict[str, str]:
     def update_status(text: str):
         if progress is not None:
             progress.update(text)
 
-    pkg = package.find_problem_package_or_die()
-
     generator_to_compiled_digest = {}
 
-    for generator in pkg.generators:
-        if tracked_generators is not None and generator.name not in tracked_generators:
-            continue
+    for generator_name in tracked_generators:
+        generator = package.get_generator(generator_name)
         update_status(f'Compiling generator [item]{generator.name}[/item]')
         try:
             generator_to_compiled_digest[generator.name] = _compile_generator(generator)
@@ -267,9 +337,7 @@ async def generate_testcases(
 
     compiled_generators = compile_generators(
         progress=progress,
-        tracked_generators=await _get_necessary_generators_for_groups(groups)
-        if groups is not None
-        else None,
+        tracked_generators=await _get_necessary_generators_for_groups(groups),
     )
 
     testcase_utils.clear_built_testcases()
@@ -353,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:
@@ -376,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():
@@ -392,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/package.py

@@ -229,13 +229,45 @@ def get_build_testgroup_path(
 
 
 @functools.cache
-def get_generator(name: str, root: pathlib.Path = pathlib.Path()) -> Generator:
+def get_generator_or_nil(
+    name: str, root: pathlib.Path = pathlib.Path()
+) -> Optional[Generator]:
     package = find_problem_package_or_die(root)
     for generator in package.generators:
         if generator.name == name:
             return generator
-    console.console.print(f'[error]Generator [item]{name}[/item] not found[/error]')
-    raise typer.Exit(1)
+
+    path = pathlib.Path(root / name)
+    if path.is_file():
+        return Generator(name=name, path=path)
+
+    path_pattern = path.with_suffix('.*')
+    matching_files = list(
+        file.relative_to(root) for file in root.glob(str(path_pattern))
+    )
+
+    if len(matching_files) > 1:
+        console.console.print(
+            f'[error]Multiple candidate generators found for [item]{name}[/item]: {matching_files}[/error]'
+        )
+        console.console.print(
+            '[info]Please specify the generator path explicitly, including the extension, or rename the conflicting files.[/info]'
+        )
+        raise typer.Exit(1)
+
+    if matching_files:
+        return Generator(name=name, path=matching_files[0])
+
+    return None
+
+
+@functools.cache
+def get_generator(name: str, root: pathlib.Path = pathlib.Path()) -> Generator:
+    generator = get_generator_or_nil(name, root)
+    if generator is None:
+        console.console.print(f'[error]Generator [item]{name}[/item] not found[/error]')
+        raise typer.Exit(1)
+    return generator
 
 
 @functools.cache
@@ -292,7 +324,27 @@ def get_interactor(root: pathlib.Path = pathlib.Path()) -> CodeItem:
 @functools.cache
 def get_solutions(root: pathlib.Path = pathlib.Path()) -> List[Solution]:
     package = find_problem_package_or_die(root)
-    return package.solutions
+    seen_paths = set()
+    res = []
+
+    def add_solution(entry: Solution):
+        if entry.path in seen_paths:
+            return
+        seen_paths.add(entry.path)
+        res.append(entry)
+
+    for entry in package.solutions:
+        if '*' in str(entry.path):
+            for file in root.glob(str(entry.path)):
+                relative_file = file.relative_to(root)
+                add_solution(
+                    Solution.model_copy(
+                        entry, update={'path': relative_file}, deep=True
+                    )
+                )
+            continue
+        add_solution(entry)
+    return res
 
 
 @functools.cache

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)