rbx.cp 0.5.39__tar.gz → 0.5.42__tar.gz

{rbx_cp-0.5.39 → rbx_cp-0.5.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rbx.cp
-Version: 0.5.39
+Version: 0.5.42
 Summary: 
 Author: Roberto Sales
 Requires-Python: >=3.9,<4.0
@@ -29,6 +29,7 @@ Requires-Dist: questionary (>=2.1.0,<3.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Requires-Dist: rich (>=13.9.4,<14.0.0)
 Requires-Dist: ruyaml (>=0.91.0,<0.92.0)
+Requires-Dist: syncer (>=2.0.3,<3.0.0)
 Requires-Dist: textual (>=0.79.1,<0.80.0)
 Requires-Dist: typer (>=0.15.1,<0.16.0)
 Description-Content-Type: text/markdown

{rbx_cp-0.5.39 → rbx_cp-0.5.42}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rbx.cp"
-version = "0.5.39"
+version = "0.5.42"
 description = ""
 packages = [
   {include = "rbx"}
@@ -31,6 +31,7 @@ questionary = "^2.1.0"
 lark = "^1.2.2"
 chardet = "^5.2.0"
 ruyaml = "^0.91.0"
+syncer = "^2.0.3"
 
 [tool.poetry.scripts]
 rbc = "rbx.main:app"
@@ -49,6 +50,7 @@ mkdocstrings = {extras = ["python"], version = "^0.25.1"}
 griffe-fieldz = ">=0.1.2, <1.0.0"
 pytest-cov = "^5.0.0"
 textual-dev = "^1.6.1"
+pytest-asyncio = "^0.26.0"
 
 [build-system]
 requires = ["poetry-core"]

{rbx_cp-0.5.39 → rbx_cp-0.5.42}/rbx/box/builder.py

@@ -20,7 +20,7 @@ from rbx.box.validators import (
 )
 
 
-def build(
+async def build(
     verification: environment.VerificationParam,
     groups: Optional[Set[str]] = None,
     output: Optional[bool] = True,
@@ -35,7 +35,7 @@ def build(
         'Built [item]{processed}[/item] testcases...',
         keep=True,
     ) as s:
-        generate_testcases(s, groups=groups)
+        await generate_testcases(s, groups=groups)
 
     if verification > 0:
         validator = package.get_validator_or_nil()
@@ -50,7 +50,7 @@ def build(
                 'Validated [item]{processed}[/item] testcases...',
                 keep=True,
             ) as s:
-                infos = validate_testcases(
+                infos = await validate_testcases(
                     s,
                     groups=groups,
                 )
@@ -70,9 +70,9 @@ def build(
         if output:
             entries = [
                 entry.group_entry
-                for entry in extract_generation_testcases_from_groups(groups)
+                for entry in await extract_generation_testcases_from_groups(groups)
             ]
-            generate_outputs_for_testcases(entries, s)
+            await generate_outputs_for_testcases(entries, s)
 
     console.console.print(
         '[success]Problem built.[/success] '
@@ -88,7 +88,7 @@ def build(
 
 
 async def verify(verification: environment.VerificationParam) -> bool:
-    if not build(verification=verification):
+    if not await build(verification=verification):
         return False
 
     if verification < VerificationLevel.FAST_SOLUTIONS.value:

{rbx_cp-0.5.39 → rbx_cp-0.5.42}/rbx/box/checkers.py

@@ -17,11 +17,15 @@ from rbx.grading.steps import (
     Outcome,
     RunLog,
 )
+from rbx.utils import StatusProgress
 
 
-def compile_checker() -> str:
+def compile_checker(progress: Optional[StatusProgress] = None) -> str:
     checker = package.get_checker()
 
+    if progress:
+        progress.update('Compiling checker...')
+
     try:
         digest = compile_item(checker, sanitized=SanitizationLevel.PREFER)
     except Exception as e:
@@ -30,6 +34,24 @@ def compile_checker() -> str:
     return digest
 
 
+def compile_interactor(progress: Optional[StatusProgress] = None) -> str:
+    interactor = package.get_interactor()
+
+    if interactor is None:
+        console.console.print('[error]No interactor found for this problem.[/error]')
+        raise typer.Exit(1)
+
+    if progress:
+        progress.update('Compiling interactor...')
+
+    try:
+        digest = compile_item(interactor, sanitized=SanitizationLevel.PREFER)
+    except Exception as e:
+        console.console.print('[error]Failed compiling interactor.[/error]')
+        raise typer.Exit(1) from e
+    return digest
+
+
 def _check_pre_output(run_log: Optional[RunLog]) -> CheckerResult:
     pkg = package.find_problem_package_or_die()
 
@@ -86,12 +108,39 @@ def _convert_tle(result: CheckerResult, run_log: Optional[RunLog]) -> CheckerRes
     return result
 
 
+def process_checker_run_log(
+    checker_run_log: Optional[RunLog], message: str
+) -> Optional[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]
+        )
+    ):
+        return None
+
+    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
+
+    result = CheckerResult(outcome=Outcome.ACCEPTED, message=message)
+
+    if checker_run_log.exitcode in [1, 2]:
+        result = CheckerResult(outcome=Outcome.WRONG_ANSWER, message=message)
+    if checker_run_log.exitcode == 3:
+        result = CheckerResult(outcome=Outcome.JUDGE_FAILED, message=message)
+    return result
+
+
 def check_with_no_output(run_log: Optional[RunLog]) -> CheckerResult:
     result = _check_pre_output(run_log)
     return _convert_tle(result, run_log)
 
 
-def _check(
+async def _check(
     checker_digest: str,
     run_log: Optional[RunLog],
     testcase: Testcase,
@@ -118,7 +167,7 @@ def _check(
             dest=pathlib.PosixPath('input.txt'),
         ),
         GradingFileInput(
-            src=testcase.outputPath,
+            src=testcase.outputPath or package.get_empty_sentinel_path(),
             dest=pathlib.PosixPath('expected.txt'),
         ),
         GradingFileInput(
@@ -126,7 +175,7 @@ def _check(
             dest=pathlib.PosixPath('output.txt'),
         ),
     ]
-    checker_run_log = run_item(
+    checker_run_log = await run_item(
         package.get_checker(),
         DigestOrSource.create(checker_digest),
         stderr=DigestOrDest.create(error),
@@ -135,20 +184,15 @@ def _check(
     )
     message = package.get_digest_as_string(error.value or '') or ''
 
-    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]
-        )
-    ):
+    processed_checker_result = process_checker_run_log(checker_run_log, message)
+    if processed_checker_result is None:
         console.console.print(
             f'[error]Checker [item]{package.get_checker().path}[/item] failed unexpectedly.[/error]'
         )
-        console.console.print(
-            f'[error]Summary:[/error] {checker_run_log.get_summary()}'
-        )
+        if checker_run_log is not None:
+            console.console.print(
+                f'[error]Summary:[/error] {checker_run_log.get_summary()}'
+            )
         console.console.print(
             f'[error]Testcase input:[/error] [item]{testcase.inputPath}[/item]'
         )
@@ -160,15 +204,7 @@ def _check(
         )
         raise typer.Exit(1)
 
-    if checker_run_log is None or checker_run_log.exitcode not in [0, 1, 2, 3]:
-        return CheckerResult(outcome=Outcome.INTERNAL_ERROR)
-
-    result = CheckerResult(outcome=Outcome.ACCEPTED, message=message)
-
-    if checker_run_log.exitcode in [1, 2]:
-        result = CheckerResult(outcome=Outcome.WRONG_ANSWER, message=message)
-    if checker_run_log.exitcode == 3:
-        result = CheckerResult(outcome=Outcome.JUDGE_FAILED, message=message)
+    result = processed_checker_result
 
     if skip_run_log:
         return result
@@ -181,13 +217,56 @@ def _check_sanitizer_warnings(run_log: Optional[RunLog]) -> bool:
     return run_log.warnings
 
 
-def check(
+async def check(
     checker_digest: str,
     run_log: Optional[RunLog],
     testcase: Testcase,
     program_output: pathlib.Path,
     skip_run_log: bool = False,
 ) -> CheckerResult:
-    result = _check(checker_digest, run_log, testcase, program_output, skip_run_log)
+    result = await _check(
+        checker_digest, run_log, testcase, program_output, skip_run_log
+    )
     result.sanitizer_warnings = _check_sanitizer_warnings(run_log)
     return result
+
+
+async def check_communication(
+    checker_digest: Optional[str],
+    run_log: Optional[RunLog],
+    interactor_run_log: Optional[RunLog],
+    interactor_stderr: pathlib.Path,
+    testcase: Testcase,
+    program_output: pathlib.Path,
+    skip_run_log: bool = False,
+) -> CheckerResult:
+    sanitizer_warnings = _check_sanitizer_warnings(run_log)
+
+    result = check_with_no_output(run_log)
+    result.sanitizer_warnings = sanitizer_warnings
+    if result.outcome != Outcome.ACCEPTED:
+        return 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
+
+    result.sanitizer_warnings = sanitizer_warnings
+    if result.outcome != Outcome.ACCEPTED:
+        return result
+
+    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

rbx_cp-0.5.39/rbx/box/main.py → rbx_cp-0.5.42/rbx/box/cli.py

@@ -1,43 +1,34 @@
-# flake8: noqa
-from gevent import monkey
-
-monkey.patch_all()
-
-import asyncio
-import tempfile
-import shlex
-import sys
-
-from rbx.box.schema import CodeItem, ExpectedOutcome, TestcaseGroup
-
-
 import pathlib
+import shlex
 import shutil
-from typing import Annotated, List, Optional
+import sys
+import tempfile
+from typing import Annotated, Optional
 
 import rich
 import rich.prompt
+import syncer
 import typer
 
 from rbx import annotations, config, console, utils
 from rbx.box import (
     cd,
-    setter_config,
-    state,
+    compile,
     creation,
     download,
     environment,
     generators,
     package,
-    compile,
     presets,
+    setter_config,
+    state,
     validators,
 )
 from rbx.box.contest import main as contest
 from rbx.box.contest.contest_package import find_contest_yaml
 from rbx.box.environment import VerificationLevel, get_environment_path
 from rbx.box.packaging import main as packaging
-from rbx.box.testcases import main as testcases
+from rbx.box.schema import CodeItem, ExpectedOutcome, TestcaseGroup
 from rbx.box.solutions import (
     estimate_time_limit,
     get_exact_matching_solutions,
@@ -49,6 +40,7 @@ from rbx.box.solutions import (
 )
 from rbx.box.statements import build_statements
 from rbx.box.testcase_utils import TestcaseEntry
+from rbx.box.testcases import main as testcases
 
 app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
 app.add_typer(
@@ -145,10 +137,11 @@ def edit():
     'build, b', rich_help_panel='Deploying', help='Build all tests for the problem.'
 )
 @package.within_problem
-def build(verification: environment.VerificationParam):
+@syncer.sync
+async def build(verification: environment.VerificationParam):
     from rbx.box import builder
 
-    builder.build(verification=verification)
+    await builder.build(verification=verification)
 
 
 @app.command(
@@ -157,7 +150,8 @@ def build(verification: environment.VerificationParam):
     help='Build and run solution(s).',
 )
 @package.within_problem
-def run(
+@syncer.sync
+async def run(
     verification: environment.VerificationParam,
     solution: Annotated[
         Optional[str],
@@ -227,7 +221,7 @@ def run(
 
     from rbx.box import builder
 
-    if not builder.build(verification=verification, output=check):
+    if not await builder.build(verification=verification, output=check):
         return
 
     if verification <= VerificationLevel.VALIDATE.value:
@@ -246,7 +240,7 @@ def run(
             raise typer.Exit(1)
 
         # Never use sanitizers for time estimation.
-        override_tl = _time_impl(check=check, detailed=False)
+        override_tl = await _time_impl(check=check, detailed=False)
         if override_tl is None:
             raise typer.Exit(1)
 
@@ -277,18 +271,16 @@ def run(
 
     console.console.print()
     console.console.rule('[status]Run report[/status]', style='status')
-    asyncio.run(
-        print_run_report(
-            solution_result,
-            console.console,
-            VerificationLevel(verification),
-            detailed=detailed,
-            skip_printing_limits=sanitized,
-        )
+    await print_run_report(
+        solution_result,
+        console.console,
+        VerificationLevel(verification),
+        detailed=detailed,
+        skip_printing_limits=sanitized,
     )
 
 
-def _time_impl(check: bool, detailed: bool) -> Optional[int]:
+async def _time_impl(check: bool, detailed: bool) -> Optional[int]:
     if package.get_main_solution() is None:
         console.console.print(
             '[warning]No main solution found, so cannot estimate a time limit.[/warning]'
@@ -314,14 +306,12 @@ def _time_impl(check: bool, detailed: bool) -> Optional[int]:
     console.console.rule(
         '[status]Run report (for time estimation)[/status]', style='status'
     )
-    ok = asyncio.run(
-        print_run_report(
-            solution_result,
-            console.console,
-            VerificationLevel(verification),
-            detailed=detailed,
-            skip_printing_limits=True,
-        )
+    ok = await print_run_report(
+        solution_result,
+        console.console,
+        VerificationLevel(verification),
+        detailed=detailed,
+        skip_printing_limits=True,
     )
 
     if not ok:
@@ -331,7 +321,7 @@ def _time_impl(check: bool, detailed: bool) -> Optional[int]:
         return None
 
     console.console.print()
-    return asyncio.run(estimate_time_limit(console.console, solution_result))
+    return await estimate_time_limit(console.console, solution_result)
 
 
 @app.command(
@@ -340,7 +330,8 @@ def _time_impl(check: bool, detailed: bool) -> Optional[int]:
     help='Estimate a time limit for the problem based on a time limit formula and timings of accepted solutions.',
 )
 @package.within_problem
-def time(
+@syncer.sync
+async def time(
     check: bool = typer.Option(
         True,
         '--nocheck',
@@ -364,10 +355,10 @@ def time(
     from rbx.box import builder
 
     verification = VerificationLevel.ALL_SOLUTIONS.value
-    if not builder.build(verification=verification, output=check):
+    if not await builder.build(verification=verification, output=check):
         return None
 
-    _time_impl(check, detailed)
+    await _time_impl(check, detailed)
 
 
 @app.command(
@@ -376,7 +367,8 @@ def time(
     help='Build and run solution(s) by passing testcases in the CLI.',
 )
 @package.within_problem
-def irun(
+@syncer.sync
+async def irun(
     verification: environment.VerificationParam,
     solution: Annotated[
         Optional[str],
@@ -468,20 +460,18 @@ def irun(
         }
 
     with utils.StatusProgress('Running solutions...') as s:
-        asyncio.run(
-            run_and_print_interactive_solutions(
-                progress=s,
-                tracked_solutions=tracked_solutions,
-                check=check,
-                verification=VerificationLevel(verification),
-                generator=generators.get_call_from_string(generator)
-                if generator is not None
-                else None,
-                testcase_entry=TestcaseEntry.parse(testcase) if testcase else None,
-                custom_output=output,
-                print=print,
-                sanitized=sanitized,
-            )
+        await run_and_print_interactive_solutions(
+            progress=s,
+            tracked_solutions=tracked_solutions,
+            check=check,
+            verification=VerificationLevel(verification),
+            generator=generators.get_call_from_string(generator)
+            if generator is not None
+            else None,
+            testcase_entry=TestcaseEntry.parse(testcase) if testcase else None,
+            custom_output=output,
+            print=print,
+            sanitized=sanitized,
         )
 
 
@@ -710,7 +700,8 @@ def compile_command(
     help='Run the validator in a one-off fashion, interactively.',
 )
 @package.within_problem
-def validate(
+@syncer.sync
+async def validate(
     path: Annotated[
         Optional[str],
         typer.Option('--path', '-p', help='Path to the testcase to validate.'),
@@ -730,17 +721,29 @@ def validate(
             tmppath = pathlib.Path(tmpdir) / '000.in'
             tmppath.write_text(input)
 
-            info = validators.validate_one_off(
+            info = await validators.validate_one_off(
                 pathlib.Path(tmppath), validator, validator_digest
             )
     else:
-        info = validators.validate_one_off(
+        info = await validators.validate_one_off(
             pathlib.Path(path), validator, validator_digest
         )
 
     validators.print_validation_report([info])
 
 
+@app.command(
+    'unit',
+    rich_help_panel='Testing',
+    help='Run unit tests for the validator and checker.',
+)
+def unit_tests():
+    from rbx.box import unit
+
+    with utils.StatusProgress('Running unit tests...') as s:
+        unit.run_unit_tests(s)
+
+
 @app.command(
     'environment, env',
     rich_help_panel='Configuration',