rbx.cp 0.5.46__tar.gz → 0.5.48__tar.gz

{rbx_cp-0.5.46 → rbx_cp-0.5.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rbx.cp
-Version: 0.5.46
+Version: 0.5.48
 Summary: 
 Author: Roberto Sales
 Requires-Python: >=3.9,<4.0

{rbx_cp-0.5.46 → rbx_cp-0.5.48}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rbx.cp"
-version = "0.5.46"
+version = "0.5.48"
 description = ""
 packages = [
   {include = "rbx"}

{rbx_cp-0.5.46 → rbx_cp-0.5.48}/rbx/box/checkers.py

@@ -1,4 +1,5 @@
 import pathlib
+import signal
 from typing import Optional
 
 import typer
@@ -108,23 +109,31 @@ def _convert_tle(result: CheckerResult, run_log: Optional[RunLog]) -> CheckerRes
     return result
 
 
+def _is_checker_exitcode(exitcode: int) -> bool:
+    return exitcode in [0, 1, 2, 3]
+
+
 def process_checker_run_log(
     checker_run_log: Optional[RunLog], message: str
-) -> Optional[CheckerResult]:
+) -> CheckerResult:
     if (
         checker_run_log is not None
-        and checker_run_log.exitcode != 0
-        and (
-            checker_run_log.exitstatus != SandboxBase.EXIT_NONZERO_RETURN
-            or checker_run_log.exitcode not in [0, 1, 2, 3]
-        )
+        and checker_run_log.exitstatus == SandboxBase.EXIT_SANDBOX_ERROR
     ):
-        return None
+        # When the sandbox fails, it means the checker failed to run.
+        # We don't know what happened.
+        return CheckerResult(
+            outcome=Outcome.INTERNAL_ERROR,
+            message='sandbox failed to run checker',
+        )
 
     if checker_run_log is None:
         return CheckerResult(outcome=Outcome.INTERNAL_ERROR)
-    if checker_run_log.exitcode not in [0, 1, 2, 3]:
-        return None
+    if not _is_checker_exitcode(checker_run_log.exitcode):
+        return CheckerResult(
+            outcome=Outcome.JUDGE_FAILED,
+            message=f'checker failed with unknown exit code {checker_run_log.exitcode}: {message}',
+        )
 
     result = CheckerResult(outcome=Outcome.ACCEPTED, message=message)
 
@@ -185,7 +194,7 @@ async def _check(
     message = package.get_digest_as_string(error.value or '') or ''
 
     processed_checker_result = process_checker_run_log(checker_run_log, message)
-    if processed_checker_result is None:
+    if processed_checker_result.outcome == Outcome.INTERNAL_ERROR:
         console.console.print(
             f'[error]Checker [item]{package.get_checker().path}[/item] failed unexpectedly.[/error]'
         )
@@ -240,33 +249,77 @@ async def check_communication(
     program_output: pathlib.Path,
     skip_run_log: bool = False,
 ) -> CheckerResult:
-    sanitizer_warnings = _check_sanitizer_warnings(run_log)
+    def _extra_check_and_sanitize(result: CheckerResult) -> CheckerResult:
+        result.sanitizer_warnings = _check_sanitizer_warnings(run_log)
+        return result
+
+    def _check_interactor(reinterpret_rte: bool = True) -> Optional[CheckerResult]:
+        result = process_checker_run_log(
+            interactor_run_log, interactor_stderr.read_text()
+        )
+        if result.outcome in [Outcome.JUDGE_FAILED, Outcome.WRONG_ANSWER]:
+            # Only return testlib errors (exit code 2 and 3), skip other types of RTEs and verdicts.
+            if (
+                interactor_run_log is not None
+                and _is_checker_exitcode(interactor_run_log.exitcode)
+                and interactor_run_log.exitstatus == SandboxBase.EXIT_NONZERO_RETURN
+            ):
+                return _extra_check_and_sanitize(result)
+            else:
+                # Check for other verdicts, but potentially reinterpret RTEs as JUDGE_FAILED.
+                result = check_with_no_output(interactor_run_log)
+                if result.outcome == Outcome.RUNTIME_ERROR and reinterpret_rte:
+                    result.outcome = Outcome.JUDGE_FAILED
+                if result.outcome != Outcome.ACCEPTED:
+                    return _extra_check_and_sanitize(result)
+        else:
+            # Return any other checker/interactor errors, such as INTERNAL_ERRORs.
+            return _extra_check_and_sanitize(result)
+
+        # No relevant error was found.
+        return None
 
+    # 1. If the solution received SIGPIPE or was terminated, it means the
+    # interactor exited before it. Thus, check the interactor, as it might have
+    # returned a checker verdict.
+    #
+    # Also, do the same if the solution returned a non-zero exit code. Checker verdict
+    # should usually supersede a solution's RTE verdict.
+    if (
+        interactor_run_log is not None
+        and run_log is not None
+        and (
+            run_log.exitcode == -signal.SIGPIPE
+            or run_log.exitstatus == SandboxBase.EXIT_TERMINATED
+            or run_log.exitstatus == SandboxBase.EXIT_NONZERO_RETURN
+        )
+    ):
+        result = _check_interactor()
+        if result is not None and result.outcome != Outcome.ACCEPTED:
+            return _extra_check_and_sanitize(result)
+
+    # 2. Check if the solution failed without looking at its output (TLE, MLE, RTE, etc).
     result = check_with_no_output(run_log)
-    result.sanitizer_warnings = sanitizer_warnings
     if result.outcome != Outcome.ACCEPTED:
-        return result
+        return _extra_check_and_sanitize(result)
 
-    result = process_checker_run_log(
-        interactor_run_log,
-        interactor_stderr.read_text(),
-    )
-
-    if result is None:
-        result = check_with_no_output(interactor_run_log)
-        result.sanitizer_warnings = sanitizer_warnings
-        if result.outcome != Outcome.ACCEPTED:
-            result.outcome = Outcome.JUDGE_FAILED
-            return result
+    # 3. Now check interactor return code regardless of what happened to the
+    # solution.
+    result = _check_interactor()
+    if result is not None and result.outcome != Outcome.ACCEPTED:
+        return _extra_check_and_sanitize(result)
 
-    result.sanitizer_warnings = sanitizer_warnings
+    # Just a defensive pattern to ensure result is not None, should never happen.
+    result = check_with_no_output(interactor_run_log)
     if result.outcome != Outcome.ACCEPTED:
-        return result
+        if result.outcome == Outcome.RUNTIME_ERROR:
+            result.outcome = Outcome.JUDGE_FAILED
+        return _extra_check_and_sanitize(result)
 
+    # 4. Now actually check the output with a checker.
     if checker_digest is not None:
         result = await check(
             checker_digest, run_log, testcase, program_output, skip_run_log
         )
-        result.sanitizer_warnings = sanitizer_warnings
 
-    return result
+    return _extra_check_and_sanitize(result)

{rbx_cp-0.5.46 → rbx_cp-0.5.48}/rbx/box/cli.py

@@ -222,7 +222,7 @@ async def run(
         tracked_solutions = {solution}
 
     if choice:
-        tracked_solutions = set(pick_solutions(tracked_solutions))
+        tracked_solutions = set(await pick_solutions(tracked_solutions))
         if not tracked_solutions:
             console.console.print('[error]No solutions selected. Exiting.[/error]')
             raise typer.Exit(1)
@@ -453,7 +453,7 @@ async def irun(
         tracked_solutions = {solution}
 
     if choice:
-        tracked_solutions = set(pick_solutions(tracked_solutions))
+        tracked_solutions = set(await pick_solutions(tracked_solutions))
         if not tracked_solutions:
             console.console.print('[error]No solutions selected. Exiting.[/error]')
             raise typer.Exit(1)
@@ -515,7 +515,8 @@ def create(
     help='Run a stress test.',
 )
 @package.within_problem
-def stress(
+@syncer.sync
+async def stress(
     name: Annotated[
         str,
         typer.Argument(
@@ -574,7 +575,7 @@ def stress(
     from rbx.box import stresses
 
     with utils.StatusProgress('Running stress...') as s:
-        report = stresses.run_stress(
+        report = await stresses.run_stress(
             name,
             timeout,
             args=generator_args,
@@ -608,15 +609,15 @@ def stress(
 
         import questionary
 
-        testgroup = questionary.select(
+        testgroup = await questionary.select(
             'Choose the testgroup to add the tests to.\nOnly test groups that have a .txt generatorScript are shown below: ',
             choices=list(groups_by_name) + ['(create new script)', '(skip)'],
-        ).ask()
+        ).ask_async()
 
         if testgroup == '(create new script)':
-            new_script_name = questionary.text(
+            new_script_name = await questionary.text(
                 'Enter the name of the new .txt generatorScript file: '
-            ).ask()
+            ).ask_async()
             new_script_path = pathlib.Path(new_script_name).with_suffix('.txt')
             new_script_path.parent.mkdir(parents=True, exist_ok=True)
             new_script_path.touch()
@@ -673,7 +674,8 @@ def stress(
     help='Compile an asset given its path.',
 )
 @package.within_problem
-def compile_command(
+@syncer.sync
+async def compile_command(
     path: Annotated[
         Optional[str],
         typer.Argument(help='Path to the asset to compile.'),
@@ -694,7 +696,7 @@ def compile_command(
     if path is None:
         import questionary
 
-        path = questionary.path("What's the path to your asset?").ask()
+        path = await questionary.path("What's the path to your asset?").ask_async()
         if path is None:
             console.console.print('[error]No path specified.[/error]')
             raise typer.Exit(1)

{rbx_cp-0.5.46 → rbx_cp-0.5.48}/rbx/box/environment.py

@@ -343,7 +343,7 @@ def get_extension(name: str, _: Type[T]) -> Optional[T]:
     pkg = get_environment()
     if pkg.extensions is None:
         return None
-    if hasattr(pkg.extensions, name):
+    if not hasattr(pkg.extensions, name):
         return None
     return getattr(pkg.extensions, name)
 

rbx_cp-0.5.48/rbx/box/naming.py

@@ -0,0 +1,22 @@
+from typing import Optional
+
+from rbx.box import package
+from rbx.box.contest import contest_package
+
+
+def get_problem_shortname() -> Optional[str]:
+    contest = contest_package.find_contest_package()
+    if contest is None:
+        return None
+    problem_path = package.find_problem()
+    contest_path = contest_package.find_contest()
+
+    for problem in contest.problems:
+        if problem.path is None:
+            continue
+        if (problem_path / 'problem.rbx.yml').samefile(
+            contest_path / problem.path / 'problem.rbx.yml'
+        ):
+            return problem.short_name
+
+    return None

{rbx_cp-0.5.46 → rbx_cp-0.5.48}/rbx/box/packaging/boca/extension.py

@@ -11,6 +11,7 @@ class BocaExtension(BaseModel):
     languages: typing.List[BocaLanguage] = list(typing.get_args(BocaLanguage))
     flags: typing.Dict[BocaLanguage, str] = {}
     maximumTimeError: float = _MAX_REP_ERROR
+    preferContestLetter: bool = False
 
     def flags_with_defaults(self) -> typing.Dict[BocaLanguage, str]:
         res: typing.Dict[BocaLanguage, str] = {

{rbx_cp-0.5.46 → rbx_cp-0.5.48}/rbx/box/packaging/boca/packager.py

@@ -6,10 +6,11 @@ from typing import List
 import typer
 
 from rbx import console
-from rbx.box import package
+from rbx.box import naming, package
 from rbx.box.environment import get_extension_or_default
 from rbx.box.packaging.boca.extension import BocaExtension, BocaLanguage
 from rbx.box.packaging.packager import BasePackager, BuiltStatement
+from rbx.box.schema import TaskType
 from rbx.box.statements.schema import Statement
 from rbx.config import get_default_app_path, get_testlib
 
@@ -24,6 +25,10 @@ def test_time(time):
 
 
 class BocaPackager(BasePackager):
+    @classmethod
+    def task_types(cls) -> List[TaskType]:
+        return [TaskType.BATCH, TaskType.COMMUNICATION]
+
     def _get_main_statement(self) -> Statement:
         pkg = package.find_problem_package_or_die()
 
@@ -47,14 +52,20 @@ class BocaPackager(BasePackager):
         raise typer.Exit(1)
 
     def _get_problem_name(self) -> str:
-        pkg = package.find_problem_package_or_die()
         # BOCA forces Java class names to be the name of the problem.
-        return pkg.name.replace('-', '_')
+        return self.package_basename().replace('-', '_')
+
+    def _get_problem_basename(self) -> str:
+        extension = get_extension_or_default('boca', BocaExtension)
+        shortname = naming.get_problem_shortname()
+        if extension.preferContestLetter and shortname is not None:
+            return shortname
+        return self._get_problem_name()
 
     def _get_problem_info(self) -> str:
         statement = self._get_main_statement()
         return (
-            f'basename={self._get_problem_name()}\n'
+            f'basename={self._get_problem_basename()}\n'
             f'fullname={statement.title}\n'
             f'descfile={self._get_problem_name()}.pdf\n'
         )
@@ -119,7 +130,7 @@ class BocaPackager(BasePackager):
         )
 
     def _get_compare(self) -> str:
-        compare_path = get_default_app_path() / 'packagers' / 'boca' / 'compare'
+        compare_path = get_default_app_path() / 'packagers' / 'boca' / 'compare.sh'
         if not compare_path.exists():
             console.console.print(
                 '[error]BOCA template compare script not found.[/error]'
@@ -145,7 +156,26 @@ class BocaPackager(BasePackager):
             .replace('{{checker_content}}', checker)
         )
 
+    def _get_interactor(self) -> str:
+        extension = get_extension_or_default('boca', BocaExtension)
+
+        interactor_path = (
+            get_default_app_path() / 'packagers' / 'boca' / 'interactor_compile.sh'
+        )
+        if not interactor_path.exists():
+            console.console.print(
+                '[error]BOCA template interactor compile script not found.[/error]'
+            )
+            raise typer.Exit(1)
+
+        interactor_text = interactor_path.read_text()
+        interactor = package.get_interactor().path.read_text()
+        return interactor_text.replace(
+            '{{rbxFlags}}', extension.flags_with_defaults()['cc']
+        ).replace('{{interactor_content}}', interactor)
+
     def _get_compile(self, language: BocaLanguage) -> str:
+        pkg = package.find_problem_package_or_die()
         extension = get_extension_or_default('boca', BocaExtension)
 
         compile_path = (
@@ -160,6 +190,10 @@ class BocaPackager(BasePackager):
         compile_text = compile_path.read_text()
 
         assert 'umask 0022' in compile_text
+        if pkg.type == TaskType.COMMUNICATION:
+            compile_text = compile_text.replace(
+                'umask 0022', 'umask 0022\n\n' + self._get_interactor()
+            )
         compile_text = compile_text.replace(
             'umask 0022', 'umask 0022\n\n' + self._get_checker()
         )
@@ -197,7 +231,8 @@ class BocaPackager(BasePackager):
                     )
                 )
 
-    def name(self) -> str:
+    @classmethod
+    def name(cls) -> str:
         return 'boca'
 
     def package(
@@ -207,7 +242,7 @@ class BocaPackager(BasePackager):
         built_statements: List[BuiltStatement],
     ) -> pathlib.Path:
         extension = get_extension_or_default('boca', BocaExtension)
-
+        pkg = package.find_problem_package_or_die()
         # Prepare limits
         limits_path = into_path / 'limits'
         limits_path.mkdir(parents=True, exist_ok=True)
@@ -227,9 +262,17 @@ class BocaPackager(BasePackager):
             run_orig_path = (
                 get_default_app_path() / 'packagers' / 'boca' / 'run' / language
             )
+            if pkg.type == TaskType.COMMUNICATION:
+                run_orig_path = (
+                    get_default_app_path()
+                    / 'packagers'
+                    / 'boca'
+                    / 'interactive'
+                    / language
+                )
             if not run_orig_path.is_file():
                 console.console.print(
-                    f'[error]Run script for language [item]{language}[/item] not found.[/error]'
+                    f'[error]Run script for language [item]{language}[/item] not found for task of type [item]{pkg.type}[/item].[/error]'
                 )
                 raise typer.Exit(1)
             shutil.copyfile(run_orig_path, run_path / language)
@@ -268,11 +311,11 @@ class BocaPackager(BasePackager):
 
         testcases = self.get_flattened_built_testcases()
         for i, testcase in enumerate(testcases):
-            shutil.copyfile(testcase.inputPath, inputs_path / f'{i+1:03d}')
+            shutil.copyfile(testcase.inputPath, inputs_path / f'{i + 1:03d}')
             if testcase.outputPath is not None:
-                shutil.copyfile(testcase.outputPath, outputs_path / f'{i+1:03d}')
+                shutil.copyfile(testcase.outputPath, outputs_path / f'{i + 1:03d}')
             else:
-                (outputs_path / f'{i+1:03d}').touch()
+                (outputs_path / f'{i + 1:03d}').touch()
 
         # Zip all.
         shutil.make_archive(

{rbx_cp-0.5.46 → rbx_cp-0.5.48}/rbx/box/packaging/main.py

@@ -28,6 +28,13 @@ async def run_packager(
         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()

{rbx_cp-0.5.46 → rbx_cp-0.5.48}/rbx/box/packaging/moj/packager.py

@@ -7,10 +7,10 @@ import typer
 from rbx import console
 from rbx.box import package
 from rbx.box.environment import get_extension_or_default
-from rbx.box.packaging.boca.extension import BocaExtension
+from rbx.box.packaging.boca.extension import BocaExtension, BocaLanguage
 from rbx.box.packaging.boca.packager import BocaPackager
 from rbx.box.packaging.packager import BuiltStatement
-from rbx.box.schema import ExpectedOutcome
+from rbx.box.schema import ExpectedOutcome, TaskType
 from rbx.config import get_default_app_path, get_testlib
 from rbx.grading.judge.digester import digest_cooperatively
 
@@ -20,13 +20,9 @@ class MojPackager(BocaPackager):
         super().__init__()
         self.for_boca = for_boca
 
-    def _get_problem_info(self) -> str:
-        statement = self._get_main_statement()
-        return (
-            f'basename={self._get_problem_name()}\n'
-            f'fullname={statement.title}\n'
-            f'descfile={self._get_problem_name()}.pdf\n'
-        )
+    @classmethod
+    def task_types(cls) -> List[TaskType]:
+        return [TaskType.COMMUNICATION, TaskType.BATCH]
 
     def _get_tl(self) -> str:
         extension = get_extension_or_default('boca', BocaExtension)
@@ -40,8 +36,12 @@ class MojPackager(BocaPackager):
     def _get_limits(self) -> str:
         pkg = package.find_problem_package_or_die()
         ml = pkg.memoryLimit
-        ol = pkg.outputLimit
-        return f'ULIMITS[-f]={ol}\n' f'ULIMITS[-v]={ml * 1024}\n'
+        # ol = pkg.outputLimit
+        limits = [
+            f'ULIMITS[-v]={ml * 1024}',
+            # f'ULIMITS[-f]={ol}',
+        ]
+        return '\n'.join(limits) + '\n'
 
     def _get_compare(self) -> str:
         extension = get_extension_or_default('boca', BocaExtension)
@@ -65,6 +65,33 @@ class MojPackager(BocaPackager):
     def _get_checker(self) -> str:
         return package.get_checker().path.read_text()
 
+    def _get_interactor(self) -> str:
+        return package.get_interactor().path.read_text()
+
+    def _expand_language_vars(self, language: BocaLanguage, dir: pathlib.Path):
+        extension = get_extension_or_default('boca', BocaExtension)
+
+        for path in dir.glob('**/*'):
+            if not path.is_file():
+                continue
+
+            replaced = path.read_text()
+            replaced = replaced.replace(
+                '{{rbxMaxMemory}}', f'{self._get_pkg_memorylimit(language)}'
+            ).replace(
+                '{{rbxInitialMemory}}',
+                f'{min(512, int(self._get_pkg_memorylimit(language) * 0.9))}',
+            )
+
+            flags = extension.flags_with_defaults()
+            if language in flags:
+                replaced = replaced.replace('{{rbxFlags}}', flags[language])
+
+            path.write_text(replaced)
+
+            if path.suffix == '.sh':
+                path.chmod(0o755)
+
     def _copy_solutions_moj(self, into_path: pathlib.Path):
         into_path = into_path / 'sols'
         has_good = False
@@ -83,7 +110,8 @@ class MojPackager(BocaPackager):
             console.console.print('[error]No good solution found.[/error]')
             raise typer.Exit(1)
 
-    def name(self) -> str:
+    @classmethod
+    def name(cls) -> str:
         return 'moj'
 
     def package(
@@ -92,6 +120,8 @@ class MojPackager(BocaPackager):
         into_path: pathlib.Path,
         built_statements: List[BuiltStatement],
     ) -> pathlib.Path:
+        pkg = package.find_problem_package_or_die()
+
         # Prepare dummy files
         author_path = into_path / 'author'
         author_path.parent.mkdir(parents=True, exist_ok=True)
@@ -128,6 +158,48 @@ class MojPackager(BocaPackager):
         checker_path.parent.mkdir(parents=True, exist_ok=True)
         checker_path.write_text(self._get_checker())
 
+        # Prepare interactor
+        if pkg.type == TaskType.COMMUNICATION:
+            interactor_path = into_path / 'scripts' / 'interactor.cpp'
+            interactor_path.parent.mkdir(parents=True, exist_ok=True)
+            interactor_path.write_text(self._get_interactor())
+
+            interactor_prep_path = into_path / 'scripts' / 'interactor_prep.sh'
+            interactor_prep_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(
+                get_default_app_path()
+                / 'packagers'
+                / 'moj'
+                / 'scripts'
+                / 'interactor_prep.sh',
+                interactor_prep_path,
+            )
+            interactor_prep_path.chmod(0o755)
+
+            interactor_run_path = into_path / 'scripts' / 'interactor_run.sh'
+            interactor_run_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(
+                get_default_app_path()
+                / 'packagers'
+                / 'moj'
+                / 'scripts'
+                / 'interactor_run.sh',
+                interactor_run_path,
+            )
+            interactor_run_path.chmod(0o755)
+
+        # Prepare language scripts
+        extension = get_extension_or_default('boca', BocaExtension)
+        for language in extension.languages:
+            language_path = into_path / 'scripts' / language
+            language_path.parent.mkdir(parents=True, exist_ok=True)
+            src_path = (
+                get_default_app_path() / 'packagers' / 'moj' / 'scripts' / language
+            )
+            if src_path.exists():
+                shutil.copytree(src_path, language_path)
+                self._expand_language_vars(language, language_path)
+
         # Problem statement
         enunciado_path = into_path / 'docs' / 'enunciado.pdf'
         enunciado_path.parent.mkdir(parents=True, exist_ok=True)
@@ -150,15 +222,13 @@ class MojPackager(BocaPackager):
 
         testcases = self.get_flattened_built_testcases()
         for i, testcase in enumerate(testcases):
-            shutil.copyfile(testcase.inputPath, inputs_path / f'{i+1:03d}')
+            shutil.copyfile(testcase.inputPath, inputs_path / f'{i + 1:03d}')
             if testcase.outputPath is not None:
-                shutil.copyfile(testcase.outputPath, outputs_path / f'{i+1:03d}')
+                shutil.copyfile(testcase.outputPath, outputs_path / f'{i + 1:03d}')
             else:
-                (outputs_path / f'{i+1:03d}').touch()
+                (outputs_path / f'{i + 1:03d}').touch()
 
         # Zip all.
-        shutil.make_archive(
-            str(build_path / self._get_problem_name()), 'zip', into_path
-        )
+        shutil.make_archive(str(build_path / self.package_basename()), 'zip', into_path)
 
-        return (build_path / self._get_problem_name()).with_suffix('.zip')
+        return (build_path / self.package_basename()).with_suffix('.zip')

{rbx_cp-0.5.46 → rbx_cp-0.5.48}/rbx/box/packaging/packager.py

@@ -3,11 +3,11 @@ import pathlib
 from abc import ABC, abstractmethod
 from typing import List, Tuple
 
-from rbx.box import package
+from rbx.box import naming, 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.schema import Package, TaskType, Testcase, TestcaseGroup
 from rbx.box.statements.schema import Statement, StatementType
 
 
@@ -33,10 +33,15 @@ class BuiltProblemPackage:
 
 
 class BasePackager(ABC):
+    @classmethod
     @abstractmethod
-    def name(self) -> str:
+    def name(cls) -> str:
         pass
 
+    @classmethod
+    def task_types(cls) -> List[TaskType]:
+        return [TaskType.BATCH]
+
     def languages(self):
         pkg = package.find_problem_package_or_die()
 
@@ -45,6 +50,13 @@ class BasePackager(ABC):
             res.add(statement.language)
         return list(res)
 
+    def package_basename(self):
+        pkg = package.find_problem_package_or_die()
+        shortname = naming.get_problem_shortname()
+        if shortname is not None:
+            return f'{shortname}-{pkg.name}'
+        return pkg.name
+
     def statement_types(self) -> List[StatementType]:
         return [StatementType.PDF]