rbx.cp 0.5.19__tar.gz → 0.5.20__tar.gz

{rbx_cp-0.5.19 → rbx_cp-0.5.20}/PKG-INFO

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

{rbx_cp-0.5.19 → rbx_cp-0.5.20}/pyproject.toml

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

{rbx_cp-0.5.19 → rbx_cp-0.5.20}/rbx/box/code.py

@@ -106,6 +106,13 @@ def compile_item(
     verbose: bool = False,
 ) -> str:
     generator_path = PosixPath(code.path)
+
+    if not generator_path.is_file():
+        console.console.print(
+            f'[error]Compilation file not found: [item]{generator_path}[/item][/error]'
+        )
+        raise typer.Exit(1)
+
     language = find_language_name(code)
     compilation_options = get_compilation_config(language)
     file_mapping = get_file_mapping(language)
@@ -281,7 +288,12 @@ def run_item(
         sandbox=sandbox,
         artifacts=artifacts,
         dependency_cache=dependency_cache,
-        metadata=RunLogMetadata(language=code.language, is_sanitized=sanitized),
+        metadata=RunLogMetadata(
+            language=code.language,
+            is_sanitized=sanitized,
+            timeLimit=sandbox_params.timeout,
+            memoryLimit=sandbox_params.address_space,
+        ),
     )
 
     # Find sanitizer logs.

{rbx_cp-0.5.19 → rbx_cp-0.5.20}/rbx/box/contest/build_contest_statements.py

@@ -343,6 +343,6 @@ def build_statement(
     console.console.print(
         f'Statement built successfully for language '
         f'[item]{statement.language}[/item] at '
-        f'[item]{statement_path}[/item].'
+        f'[item]{statement_path.resolve()}[/item]'
     )
     return statement_path

{rbx_cp-0.5.19 → rbx_cp-0.5.20}/rbx/box/contest/main.py

@@ -59,7 +59,7 @@ def create(
     fetch_info = get_preset_fetch_info(preset)
     if fetch_info is None:
         console.console.print(
-            f'[error]Invalid preset name/URI [item]{preset}[/item].[/error]'
+            f'[error]Invalid preset name/URI [item]{preset}[/item][/error]'
         )
         raise typer.Exit(1)
 

{rbx_cp-0.5.19 → rbx_cp-0.5.20}/rbx/box/environment.py

@@ -221,7 +221,7 @@ def install_environment(name: str, file: pathlib.Path):
     get_environment_path(name).parent.mkdir(parents=True, exist_ok=True)
     get_environment_path(name).write_bytes(file.read_bytes())
     console.console.print(
-        f'[success]Environment [item]{name}[/item] was installed from [item]{file}[/item].'
+        f'[success]Environment [item]{name}[/item] was installed from [item]{file}[/item]'
     )
 
 

{rbx_cp-0.5.19 → rbx_cp-0.5.20}/rbx/box/generators.py

@@ -149,13 +149,11 @@ def generate_output_for_testcase(
             console.console.print(
                 f'[warning]Message: [info]{checker_result.message}[/info][/warning]',
             )
+            console.console.print(f'Input written at [item]{testcase.inputPath}[/item]')
             console.console.print(
-                f'Input written at [item]{testcase.inputPath}[/item].'
+                f'Output written at [item]{testcase.outputPath}[/item]'
             )
-            console.console.print(
-                f'Output written at [item]{testcase.outputPath}[/item].'
-            )
-            console.console.print(f'Stderr written at [item]{stderr_path}[/item].')
+            console.console.print(f'Stderr written at [item]{stderr_path}[/item]')
         raise typer.Exit(1)
 
 
@@ -206,6 +204,13 @@ def generate_outputs_for_testcases(
 
 def _run_generator_script(testcase: TestcaseSubgroup, cacher: FileCacher) -> str:
     assert testcase.generatorScript is not None
+
+    if not testcase.generatorScript.path.is_file():
+        console.console.print(
+            f'[error]Generator script not found: [item]{testcase.generatorScript.path}[/item][/error]'
+        )
+        raise typer.Exit(1)
+
     script_digest = DigestHolder()
     if testcase.generatorScript.path.suffix == '.txt':
         script_digest.value = cacher.put_file_from_path(testcase.generatorScript.path)

{rbx_cp-0.5.19 → rbx_cp-0.5.20}/rbx/box/main.py

@@ -217,6 +217,7 @@ def run(
             console.console,
             VerificationLevel(verification),
             detailed=detailed,
+            skip_printing_limits=sanitized,
         )
     )
 
@@ -252,6 +253,7 @@ def _time_impl(check: bool, detailed: bool) -> Optional[int]:
             console.console,
             VerificationLevel(verification),
             detailed=detailed,
+            skip_printing_limits=True,
         )
     )
 
@@ -540,7 +542,7 @@ def stress(
                 f.write(f'\n{stress_text}\n{finding_text}\n')
 
             console.console.print(
-                f"Added [item]{len(report.findings)}[/item] tests to test group [item]{testgroup}[/item]'s generatorScript at [item]{subgroup.generatorScript.path}[/item]."
+                f"Added [item]{len(report.findings)}[/item] tests to test group [item]{testgroup}[/item]'s generatorScript at [item]{subgroup.generatorScript.path}[/item]"
             )
         except typer.Exit:
             continue

{rbx_cp-0.5.19 → rbx_cp-0.5.20}/rbx/box/package.py

@@ -152,6 +152,12 @@ def get_problem_runs_dir(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
     return runs_dir
 
 
+def get_problem_iruns_dir(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
+    iruns_dir = get_problem_runs_dir(root) / '.irun'
+    iruns_dir.mkdir(parents=True, exist_ok=True)
+    return iruns_dir
+
+
 @functools.cache
 def get_cache_storage(root: pathlib.Path = pathlib.Path()) -> Storage:
     return FilesystemStorage(get_problem_storage_dir(root))

{rbx_cp-0.5.19 → rbx_cp-0.5.20}/rbx/box/packaging/main.py

@@ -50,7 +50,7 @@ def run_packager(
     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].')
+    console.console.print(f'Package was saved at [item]{result_path.resolve()}[/item]')
     return result_path
 
 

{rbx_cp-0.5.19 → rbx_cp-0.5.20}/rbx/box/schema.py

@@ -293,6 +293,22 @@ class Stress(BaseModel):
     )
 
 
+class Limits(BaseModel):
+    time: Optional[int] = Field(
+        None, description='Value to override time limit with, in milliseconds.'
+    )
+    memory: Optional[int] = Field(
+        None, description='Value to override memory limit with, in MB.'
+    )
+    output: Optional[int] = Field(
+        None, description='Value to override output limit with, in KB.'
+    )
+
+    isDoubleTL: bool = Field(
+        False, description='Whether to use double TL for this language.'
+    )
+
+
 class LimitModifiers(BaseModel):
     timeMultiplier: Optional[float] = Field(
         None, description='Multiplier for time limit.'

{rbx_cp-0.5.19 → rbx_cp-0.5.20}/rbx/box/solutions.py

@@ -5,22 +5,29 @@ import dataclasses
 import pathlib
 import shutil
 from collections.abc import Iterator
-from typing import Dict, Iterable, List, Optional, Set
+from typing import Dict, Iterable, List, Optional, Set, Tuple
 
 import rich
 import rich.live
+import rich.markup
 import rich.table
+import rich.text
 from pydantic import BaseModel
 
 from rbx import console
 from rbx.box import checkers, package
 from rbx.box.code import SanitizationLevel, compile_item, find_language_name, run_item
 from rbx.box.deferred import Deferred
-from rbx.box.environment import EnvironmentSandbox, ExecutionConfig, VerificationLevel
+from rbx.box.environment import (
+    EnvironmentSandbox,
+    ExecutionConfig,
+    VerificationLevel,
+)
 from rbx.box.generators import generate_output_for_testcase, generate_standalone
 from rbx.box.schema import (
     ExpectedOutcome,
     GeneratorCall,
+    Limits,
     Solution,
     Testcase,
     TestcaseGroup,
@@ -55,6 +62,7 @@ class GroupSkeleton(BaseModel):
 class SolutionReportSkeleton(BaseModel):
     solutions: List[Solution]
     groups: List[GroupSkeleton]
+    limits: Dict[str, Limits]
 
     def find_group_skeleton(self, group_name: str) -> Optional[GroupSkeleton]:
         groups = [group for group in self.groups if group.name == group_name]
@@ -135,6 +143,20 @@ def compile_solutions(
     return compiled_solutions
 
 
+def get_limits_for_language(
+    lang: Optional[str],
+    verification: VerificationLevel,
+    timelimit_override: Optional[int],
+) -> Limits:
+    pkg = package.find_problem_package_or_die()
+    time = timelimit_override or pkg.timelimit_for_language(lang)
+    isDoubleTL = verification.value >= VerificationLevel.FULL.value
+    memory = pkg.memorylimit_for_language(lang)
+    return Limits(
+        time=time, memory=memory, output=pkg.outputLimit, isDoubleTL=isDoubleTL
+    )
+
+
 def _run_solution_on_testcase(
     solution: Solution,
     compiled_digest: str,
@@ -145,21 +167,22 @@ def _run_solution_on_testcase(
     verification: VerificationLevel = VerificationLevel.NONE,
     timelimit_override: Optional[int] = None,
 ) -> Evaluation:
-    pkg = package.find_problem_package_or_die()
     actual_sandbox = package.get_singleton_sandbox()
 
-    timelimit = timelimit_override or pkg.timelimit_for_language(solution.language)
+    limits = get_limits_for_language(
+        solution.language, verification, timelimit_override
+    )
 
     sandbox = EnvironmentSandbox()
-    sandbox.timeLimit = timelimit
-    if verification.value >= VerificationLevel.FULL.value:
-        # Use double TL.
+    sandbox.timeLimit = limits.time
+    if limits.isDoubleTL and sandbox.timeLimit is not None:
+        # Double TL.
         sandbox.timeLimit = sandbox.timeLimit * 2
-    sandbox.wallTimeLimit = (
-        timelimit * 2 if actual_sandbox.use_soft_timeout() else sandbox.timeLimit
-    )
-    sandbox.memoryLimit = pkg.memorylimit_for_language(solution.language)
-    sandbox.fileSizeLimit = pkg.outputLimit
+    sandbox.wallTimeLimit = sandbox.timeLimit
+    if sandbox.timeLimit is not None and actual_sandbox.use_soft_timeout():
+        sandbox.wallTimeLimit = sandbox.timeLimit * 2
+    sandbox.memoryLimit = limits.memory
+    sandbox.fileSizeLimit = limits.output
     extra_config = ExecutionConfig(sandbox=sandbox)
 
     output_path = output_dir / testcase.inputPath.with_suffix('.out').name
@@ -261,6 +284,7 @@ async def convert_list_of_solution_evaluations_to_dict(
 def _get_report_skeleton(
     tracked_solutions: Optional[Set[str]] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
+    timelimit_override: Optional[int] = None,
 ) -> SolutionReportSkeleton:
     pkg = package.find_problem_package_or_die()
     solutions = [
@@ -275,6 +299,13 @@ def _get_report_skeleton(
             if str(solution.path) in tracked_solutions
         ]
 
+    langs = set(find_language_name(solution) for solution in solutions)
+    limits = {
+        lang: get_limits_for_language(lang, verification, timelimit_override)
+        for lang in langs
+        if lang is not None
+    }
+
     groups = []
     for group in pkg.testcases:
         testcases = find_built_testcases(group)
@@ -282,6 +313,7 @@ def _get_report_skeleton(
     return SolutionReportSkeleton(
         solutions=solutions,
         groups=groups,
+        limits=limits,
     )
 
 
@@ -361,7 +393,11 @@ def run_solutions(
     sanitized: bool = False,
 ) -> RunSolutionResult:
     return RunSolutionResult(
-        skeleton=_get_report_skeleton(tracked_solutions, verification=verification),
+        skeleton=_get_report_skeleton(
+            tracked_solutions,
+            verification=verification,
+            timelimit_override=timelimit_override,
+        ),
         items=_produce_solution_items(
             progress=progress,
             tracked_solutions=tracked_solutions,
@@ -378,6 +414,7 @@ def _run_interactive_solutions(
     verification: VerificationLevel = VerificationLevel.NONE,
     generator: Optional[GeneratorCall] = None,
     check: bool = True,
+    print: bool = False,
     sanitized: bool = False,
 ) -> Iterator[EvaluationItem]:
     pkg = package.find_problem_package_or_die()
@@ -410,7 +447,7 @@ def _run_interactive_solutions(
             (i, sol) for i, sol in solutions if str(sol.path) in tracked_solutions
         ]
 
-    irun_dir = package.get_problem_runs_dir() / '.irun'
+    irun_dir = package.get_problem_iruns_dir()
     shutil.rmtree(str(irun_dir), ignore_errors=True)
     irun_dir.mkdir(parents=True, exist_ok=True)
     inputs_dir = irun_dir / 'inputs'
@@ -423,6 +460,13 @@ def _run_interactive_solutions(
         console.console.print(
             f'Using input from generator call [item]{expanded_call.name} {expanded_call.args}[/item].'
         )
+        if print:
+            console.console.print(input_path.read_text())
+        else:
+            console.console.print(
+                f'Input was written to [item]{input_path.resolve()}[/item]'
+            )
+        console.console.print()
     else:
         input = console.multiline_prompt('Testcase input')
         input_path.write_text(input)
@@ -468,11 +512,12 @@ async def run_and_print_interactive_solutions(
         check=check,
         generator=generator,
         sanitized=sanitized,
+        print=print,
     )
 
     for item in items:
         sol = pkg.solutions[item.solution_index]
-        _print_solution_header(sol, console.console)
+        _print_solution_header(sol, console.console, is_irun=True)
 
         eval = await item.eval()
 
@@ -487,7 +532,11 @@ async def run_and_print_interactive_solutions(
             else:
                 console.console.print('[warning]Solution produced no output.[/warning]')
         elif stdout_path is not None:
-            console.console.print(f'Output: {stdout_path}.')
+            console.console.print(f'[status]Output:[/status] {stdout_path}')
+            if eval.log.stderr_absolute_path is not None:
+                console.console.print(
+                    f'[status]Stderr:[/status] {eval.log.stderr_absolute_path}'
+                )
             console.console.print()
 
 
@@ -534,9 +583,13 @@ def _get_evals_memory_in_bytes(evals: List[Evaluation]) -> int:
     return max(int(eval.log.memory or 0) for eval in evals)
 
 
+def get_formatted_time(time_in_ms: int) -> str:
+    return f'{time_in_ms} ms'
+
+
 def get_evals_formatted_time(evals: List[Evaluation]) -> str:
     max_time = _get_evals_time_in_ms(evals)
-    return f'{max_time} ms'
+    return get_formatted_time(max_time)
 
 
 def get_capped_evals_formatted_time(
@@ -546,24 +599,37 @@ def get_capped_evals_formatted_time(
 
     max_time = _get_evals_time_in_ms(evals)
     has_tle = any(eval.result.outcome == Outcome.TIME_LIMIT_EXCEEDED for eval in evals)
-    tl = pkg.timelimit_for_language(solution.language)
+    timelimits = [
+        eval.log.metadata.timeLimit
+        for eval in evals
+        if eval.log.metadata is not None and eval.log.metadata.timeLimit is not None
+    ]
+    tl = None
+    if timelimits:
+        tl = min(timelimits)
+    if tl is None:
+        tl = pkg.timelimit_for_language(solution.language)
 
-    if verification.value >= VerificationLevel.FULL.value:
-        # Using double TL for verification.
-        tl = tl * 2
+        if verification.value >= VerificationLevel.FULL.value:
+            # Using double TL for verification.
+            tl = tl * 2
 
-    if has_tle and max_time > tl:
+    if has_tle and max_time >= tl:
         return f'>{tl} ms'
     return f'{max_time} ms'
 
 
+def get_formatted_memory(memory_in_bytes: int) -> str:
+    if memory_in_bytes < 1024 * 1024:
+        if memory_in_bytes < 1024:
+            return f'{memory_in_bytes} B'
+        return f'{memory_in_bytes // 1024} KiB'
+    return f'{memory_in_bytes // (1024 * 1024)} MiB'
+
+
 def get_evals_formatted_memory(evals: List[Evaluation]) -> str:
     max_memory = _get_evals_memory_in_bytes(evals)
-    if max_memory < 1024 * 1024:
-        if max_memory < 1024:
-            return f'{max_memory} B'
-        return f'{max_memory // 1024} KiB'
-    return f'{max_memory // (1024 * 1024)} MiB'
+    return get_formatted_memory(max_memory)
 
 
 def _print_solution_outcome(
@@ -674,12 +740,18 @@ def _consume_and_key_evaluation_items(
     return res
 
 
-def _print_solution_header(solution: Solution, console: rich.console.Console):
+def _print_solution_header(
+    solution: Solution, console: rich.console.Console, is_irun: bool = False
+):
     solutions = package.get_solutions()
     solution_index = [
         i for i, sol in enumerate(solutions) if sol.path == solution.path
     ][0]
-    solution_testdir = package.get_problem_runs_dir() / f'{solution_index}'
+    solution_testdir = (
+        package.get_problem_iruns_dir() / f'{solution_index}'
+        if is_irun
+        else package.get_problem_runs_dir() / f'{solution_index}'
+    )
     console.print(f'[item]{solution.path}[/item]', end=' ')
     console.print(f'({solution_testdir})')
 
@@ -713,6 +785,45 @@ async def _print_timing(
         console.print(f'Fastest [error]slow[/error] solution: {fastest_slow} ms')
 
 
+def _length_markup(markup: str) -> int:
+    text = rich.markup.render(markup)
+    return text.cell_len
+
+
+def _length_pointwise(ls: Iterable[str]) -> Tuple[int, ...]:
+    return tuple(_length_markup(x) for x in ls)
+
+
+def _max_pointwise(ls: Iterable[Tuple[int, ...]]) -> Tuple[int, ...]:
+    return tuple(max(x) for x in zip(*ls))
+
+
+def _get_indented_text(s: str, width: int):
+    text = rich.markup.render(s)
+    text.align('right', width=width)
+    return text
+
+
+def _render_padded_rows(
+    rows: List[List[Tuple[str, ...]]],
+) -> List[List[rich.text.Text]]:
+    max_widths_per_column = [
+        _max_pointwise(_length_pointwise(cell) for cell in col) for col in zip(*rows)
+    ]
+    res = []
+    for row in rows:
+        acc_row = []
+        for i, cell in enumerate(row):
+            acc_row.append(
+                rich.text.Text(' ').join(
+                    _get_indented_text(item, width)
+                    for item, width in zip(cell, max_widths_per_column[i])
+                )
+            )
+        res.append(acc_row)
+    return res
+
+
 async def _render_detailed_group_table(
     group: TestcaseGroup,
     skeleton: SolutionReportSkeleton,
@@ -730,17 +841,19 @@ async def _render_detailed_group_table(
         for solution in skeleton.solutions:
             table.add_column(f'[item]{solution.path}[/item]', justify='full')
 
+        padded_rows = []
+
         evals_per_solution = collections.defaultdict(list)
         for tc, _ in enumerate(group_skeleton.testcases):
             row = []
             for solution in skeleton.solutions:
                 eval = structured_evaluation[str(solution.path)][group_name][tc]
                 if eval is None:
-                    row.append('...')
+                    row.append((f'[info]#{tc}[/info]', '', '...', '', '', ''))
                     continue
                 eval = eval.peek()
                 if eval is None:
-                    row.append('...')
+                    row.append((f'[info]#{tc}[/info]', '', '...', '', '', ''))
                     continue
 
                 evals_per_solution[str(solution.path)].append(eval)
@@ -748,14 +861,14 @@ async def _render_detailed_group_table(
                 verdict = get_testcase_markup_verdict(eval)
                 time = get_capped_evals_formatted_time(solution, [eval], verification)
                 memory = get_evals_formatted_memory([eval])
-                full_item = f'{verdict} {time} / {memory}'
+                full_item = (f'[info]#{tc}[/info]', verdict, time, '/', memory, '')
                 if eval.result.sanitizer_warnings:
-                    full_item = f'{full_item} [warning]*[/warning]'
+                    full_item = (*full_item[:-1], '[warning]*[/warning]')
 
                 row.append(full_item)
-            table.add_row(*row)
+            padded_rows.append(row)
 
-        if table.row_count > 0:
+        if padded_rows:
             summary_row = []
             for solution in skeleton.solutions:
                 evals = evals_per_solution[str(solution.path)]
@@ -767,9 +880,14 @@ async def _render_detailed_group_table(
                     solution, non_null_evals, verification
                 )
                 formatted_memory = get_evals_formatted_memory(non_null_evals)
-                summary_row.append(f' {formatted_time} / {formatted_memory}')
-            table.add_section()
-            table.add_row(*summary_row)
+                summary_row.append(('', '', formatted_time, '/', formatted_memory, ''))
+            padded_rows.append(summary_row)
+
+        for row in _render_padded_rows(padded_rows):
+            table.add_row(*row)
+
+        if padded_rows:
+            table.rows[-2].end_section = True
         return table
 
     with rich.live.Live(
@@ -831,13 +949,31 @@ async def _print_detailed_run_report(
     return ok
 
 
+def _print_limits(limits: Dict[str, Limits]):
+    console.console.print(
+        '[bold][success]Running with the following limits (per language):[/success][/bold]'
+    )
+    for lang, limit in limits.items():
+        console.console.print(f'[bold][status]{lang}[/status][/bold]')
+        console.console.print(f'Time: {get_formatted_time(limit.time or int('+inf'))}')
+        memory = limit.memory * 1024 * 1024 if limit.memory is not None else int('+inf')
+        console.console.print(f'Memory: {get_formatted_memory(memory)}')
+        if limit.isDoubleTL:
+            console.console.print('[warning]Running with 2*TL[/warning]')
+    console.console.print()
+
+
 async def print_run_report(
     result: RunSolutionResult,
     console: rich.console.Console,
     verification: VerificationLevel,
     detailed: bool = False,
     timing: bool = True,
+    skip_printing_limits: bool = False,
 ) -> bool:
+    if not skip_printing_limits:
+        _print_limits(result.skeleton.limits)
+
     structured_evaluations = _consume_and_key_evaluation_items(
         result.items, result.skeleton
     )

{rbx_cp-0.5.19 → rbx_cp-0.5.20}/rbx/box/statements/build_statements.py

@@ -297,7 +297,7 @@ def build_statement(
     console.console.print(
         f'Statement built successfully for language '
         f'[item]{statement.language}[/item] at '
-        f'[item]{statement_path}[/item].'
+        f'[item]{statement_path.resolve()}[/item]'
     )
     return statement_path
 

{rbx_cp-0.5.19 → rbx_cp-0.5.20}/rbx/box/stresses.py

@@ -161,12 +161,12 @@ def run_stress(
                 console.console.print(
                     '[error]Error while generating main solution output.[/error]'
                 )
-                console.console.print(f'Input written at [item]{input_path}[/item].')
+                console.console.print(f'Input written at [item]{input_path}[/item]')
                 console.console.print(
-                    f'Output written at [item]{main_result.output_path}[/item].'
+                    f'Output written at [item]{main_result.output_path}[/item]'
                 )
                 console.console.print(
-                    f'Stderr written at [item]{main_result.stderr_path}[/item].'
+                    f'Stderr written at [item]{main_result.stderr_path}[/item]'
                 )
                 console.console.print()
                 console.console.print(

{rbx_cp-0.5.19 → rbx_cp-0.5.20}/rbx/grading/steps.py

@@ -161,6 +161,8 @@ class TestcaseIO(BaseModel):
 class RunLogMetadata(BaseModel):
     language: Optional[str] = None
     is_sanitized: bool = False
+    timeLimit: Optional[int] = None
+    memoryLimit: Optional[int] = None
 
 
 class RunLog(BaseModel):