rbx.cp 0.5.16__py3-none-any.whl → 0.5.17__py3-none-any.whl

rbx/box/solutions.py

@@ -5,17 +5,17 @@ import dataclasses
 import pathlib
 import shutil
 from collections.abc import Iterator
-from typing import Dict, List, Optional, Set
+from typing import Dict, Iterable, List, Optional, Set
 
 import rich
 import rich.live
 import rich.table
-from more_itertools import seekable
 from pydantic import BaseModel
 
 from rbx import console
 from rbx.box import checkers, environment, package
-from rbx.box.code import compile_item, run_item
+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.generators import generate_output_for_testcase, generate_standalone
 from rbx.box.schema import (
@@ -36,14 +36,15 @@ from rbx.grading.steps import (
 )
 from rbx.utils import StatusProgress, model_to_yaml
 
-StructuredEvaluation = Dict[str, Dict[str, List[Optional[Evaluation]]]]
+StructuredEvaluation = Dict[str, Dict[str, List[Optional[Deferred[Evaluation]]]]]
 
 
-class EvaluationItem(BaseModel):
+@dataclasses.dataclass(frozen=True)
+class EvaluationItem:
     solution_index: int
     group_name: str
     testcase_index: int
-    eval: Evaluation
+    eval: Deferred[Evaluation]
 
 
 class GroupSkeleton(BaseModel):
@@ -54,7 +55,6 @@ class GroupSkeleton(BaseModel):
 class SolutionReportSkeleton(BaseModel):
     solutions: List[Solution]
     groups: List[GroupSkeleton]
-    group_first: bool
 
     def find_group_skeleton(self, group_name: str) -> Optional[GroupSkeleton]:
         groups = [group for group in self.groups if group.name == group_name]
@@ -74,7 +74,7 @@ class SolutionReportSkeleton(BaseModel):
 @dataclasses.dataclass
 class RunSolutionResult:
     skeleton: SolutionReportSkeleton
-    items: Iterator[EvaluationItem]
+    items: List[EvaluationItem]
 
     def empty_structured_evaluation(self) -> StructuredEvaluation:
         return self.skeleton.empty_structured_evaluation()
@@ -94,9 +94,18 @@ def get_matching_solutions(expected_outcome: ExpectedOutcome) -> List[Solution]:
     return res
 
 
+def get_exact_matching_solutions(expected_outcome: ExpectedOutcome) -> List[Solution]:
+    res = []
+    for solution in package.get_solutions():
+        if solution.outcome == expected_outcome:
+            res.append(solution)
+    return res
+
+
 def compile_solutions(
     progress: Optional[StatusProgress] = None,
     tracked_solutions: Optional[Set[str]] = None,
+    sanitized: bool = False,
 ) -> Dict[pathlib.Path, str]:
     pkg = package.find_problem_package_or_die()
 
@@ -111,7 +120,12 @@ def compile_solutions(
         if progress:
             progress.update(f'Compiling solution [item]{solution.path}[/item]...')
         try:
-            compiled_solutions[solution.path] = compile_item(solution)
+            compiled_solutions[solution.path] = compile_item(
+                solution,
+                sanitized=SanitizationLevel.FORCE
+                if sanitized
+                else SanitizationLevel.NONE,
+            )
         except:
             console.console.print(
                 f'[error]Failed compiling solution [item]{solution.path}[/item][/error]'
@@ -129,11 +143,12 @@ def _run_solution_on_testcase(
     output_dir: pathlib.Path,
     testcase_index: int = 0,
     verification: VerificationLevel = VerificationLevel.NONE,
+    timelimit_override: Optional[int] = None,
 ) -> Evaluation:
     pkg = package.find_problem_package_or_die()
     actual_sandbox = package.get_singleton_sandbox()
 
-    timelimit = pkg.timelimit_for_language(solution.language)
+    timelimit = timelimit_override or pkg.timelimit_for_language(solution.language)
 
     sandbox = EnvironmentSandbox()
     sandbox.timeLimit = timelimit
@@ -196,11 +211,13 @@ def _run_solution(
     group_name: str,
     progress: Optional[StatusProgress] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
-) -> Iterator[Evaluation]:
+    timelimit_override: Optional[int] = None,
+) -> List[Deferred[Evaluation]]:
     runs_dir = package.get_problem_runs_dir()
 
     group = package.get_testgroup(group_name)
     testcases = find_built_testcases(group)
+    res: List[Deferred[Evaluation]] = []
     for i, testcase in enumerate(testcases):
         assert testcase.outputPath is not None
         output_path = runs_dir / f'{solution_index}' / group.name
@@ -210,19 +227,25 @@ def _run_solution(
                 f'Running solution [item]{solution.path}[/item] on test [item]{group.name}[/item] / [item]{i}[/item]...'
             )
 
-        yield _run_solution_on_testcase(
-            solution,
-            compiled_digest,
-            checker_digest,
-            testcase,
-            output_path,
-            testcase_index=i,
-            verification=verification,
-        )
+        async def run_fn(i=i, testcase=testcase, output_path=output_path):
+            return _run_solution_on_testcase(
+                solution,
+                compiled_digest,
+                checker_digest,
+                testcase,
+                output_path,
+                testcase_index=i,
+                verification=verification,
+                timelimit_override=timelimit_override,
+            )
+
+        res.append(Deferred(run_fn))
+
+    return res
 
 
-def convert_list_of_solution_evaluations_to_dict(
-    items: Iterator[EvaluationItem],
+async def convert_list_of_solution_evaluations_to_dict(
+    items: Iterable[EvaluationItem],
 ) -> List[Dict[str, List[Evaluation]]]:
     pkg = package.find_problem_package_or_die()
     res: List[Dict[str, List[Evaluation]]] = [
@@ -230,14 +253,13 @@ def convert_list_of_solution_evaluations_to_dict(
     ]
 
     for item in items:
-        res[item.solution_index][item.group_name].append(item.eval)
+        res[item.solution_index][item.group_name].append(await item.eval())
 
     return res
 
 
 def _get_report_skeleton(
     tracked_solutions: Optional[Set[str]] = None,
-    group_first: bool = False,
     verification: VerificationLevel = VerificationLevel.NONE,
 ) -> SolutionReportSkeleton:
     pkg = package.find_problem_package_or_die()
@@ -258,7 +280,8 @@ def _get_report_skeleton(
         testcases = find_built_testcases(group)
         groups.append(GroupSkeleton(name=group.name, testcases=testcases))
     return SolutionReportSkeleton(
-        solutions=solutions, groups=groups, group_first=group_first
+        solutions=solutions,
+        groups=groups,
     )
 
 
@@ -267,13 +290,14 @@ def _produce_solution_items(
     tracked_solutions: Optional[Set[str]] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
     check: bool = True,
-    group_first: bool = False,
-) -> Iterator[EvaluationItem]:
+    timelimit_override: Optional[int] = None,
+    sanitized: bool = False,
+) -> List[EvaluationItem]:
     pkg = package.find_problem_package_or_die()
 
     checker_digest = checkers.compile_checker() if check else None
     compiled_solutions = compile_solutions(
-        progress=progress, tracked_solutions=tracked_solutions
+        progress=progress, tracked_solutions=tracked_solutions, sanitized=sanitized
     )
 
     # Clear run directory and rely on cache to
@@ -293,7 +317,8 @@ def _produce_solution_items(
 
     def yield_items(
         solution_index: int, solution: Solution, group_name: str
-    ) -> Iterator[EvaluationItem]:
+    ) -> List[EvaluationItem]:
+        res: List[EvaluationItem] = []
         for i, eval in enumerate(
             _run_solution(
                 solution,
@@ -303,25 +328,28 @@ def _produce_solution_items(
                 group_name,
                 progress=progress,
                 verification=verification,
+                timelimit_override=timelimit_override,
             )
         ):
-            yield EvaluationItem(
-                solution_index=solution_index,
-                group_name=group_name,
-                testcase_index=i,
-                eval=eval,
+            res.append(
+                EvaluationItem(
+                    solution_index=solution_index,
+                    group_name=group_name,
+                    testcase_index=i,
+                    eval=eval,
+                )
             )
 
-    groups = pkg.testcases
-    if group_first:
-        for group in groups:
-            for i, solution in solutions:
-                yield from yield_items(i, solution, group.name)
-        return
+        return res
+
+    res: List[EvaluationItem] = []
 
+    groups = pkg.testcases
     for i, solution in solutions:
         for group in groups:
-            yield from yield_items(i, solution, group.name)
+            res.extend(yield_items(i, solution, group.name))
+
+    return res
 
 
 def run_solutions(
@@ -329,18 +357,18 @@ def run_solutions(
     tracked_solutions: Optional[Set[str]] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
     check: bool = True,
-    group_first: bool = False,
+    timelimit_override: Optional[int] = None,
+    sanitized: bool = False,
 ) -> RunSolutionResult:
     return RunSolutionResult(
-        skeleton=_get_report_skeleton(
-            tracked_solutions, group_first, verification=verification
-        ),
+        skeleton=_get_report_skeleton(tracked_solutions, verification=verification),
         items=_produce_solution_items(
             progress=progress,
             tracked_solutions=tracked_solutions,
             verification=verification,
             check=check,
-            group_first=group_first,
+            timelimit_override=timelimit_override,
+            sanitized=sanitized,
         ),
     )
 
@@ -350,18 +378,26 @@ def _run_interactive_solutions(
     verification: VerificationLevel = VerificationLevel.NONE,
     generator: Optional[GeneratorCall] = None,
     check: bool = True,
+    sanitized: bool = False,
 ) -> Iterator[EvaluationItem]:
     pkg = package.find_problem_package_or_die()
     main_solution = package.get_main_solution()
     check = check and main_solution is not None
 
     checker_digest = checkers.compile_checker() if check else None
-    compiled_solutions = compile_solutions(tracked_solutions=tracked_solutions)
+    compiled_solutions = compile_solutions(
+        tracked_solutions=tracked_solutions, sanitized=sanitized
+    )
 
     main_solution_digest = None
     if check and main_solution is not None:
         try:
-            main_solution_digest = compile_item(main_solution)
+            main_solution_digest = compile_item(
+                main_solution,
+                sanitized=SanitizationLevel.FORCE
+                if sanitized
+                else SanitizationLevel.NONE,
+            )
         except:
             console.console.print(
                 '[error]Failed compiling main solution. If you do not want to check against a main solution, run with --nocheck flag.[/error]'
@@ -399,27 +435,31 @@ def _run_interactive_solutions(
     for i, solution in solutions:
         output_dir = irun_dir / f'{i}'
 
-        yield EvaluationItem(
-            solution_index=i,
-            group_name='irun',
-            testcase_index=0,
-            eval=_run_solution_on_testcase(
+        async def run_fn(solution=solution, output_dir=output_dir):
+            return _run_solution_on_testcase(
                 solution,
                 compiled_solutions[solution.path],
                 checker_digest,
                 testcase,
                 output_dir,
                 verification=verification,
-            ),
+            )
+
+        yield EvaluationItem(
+            solution_index=i,
+            group_name='irun',
+            testcase_index=0,
+            eval=Deferred(run_fn),
         )
 
 
-def run_and_print_interactive_solutions(
+async def run_and_print_interactive_solutions(
     tracked_solutions: Optional[Set[str]] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
     generator: Optional[GeneratorCall] = None,
     check: bool = True,
     print: bool = False,
+    sanitized: bool = False,
 ):
     pkg = package.find_problem_package_or_die()
     items = _run_interactive_solutions(
@@ -427,16 +467,19 @@ def run_and_print_interactive_solutions(
         verification=verification,
         check=check,
         generator=generator,
+        sanitized=sanitized,
     )
 
     for item in items:
         sol = pkg.solutions[item.solution_index]
         _print_solution_header(sol, console.console)
 
-        stdout_path = item.eval.log.stdout_absolute_path
+        eval = await item.eval()
+
+        stdout_path = eval.log.stdout_absolute_path
         if print:
             if (
-                item.eval.testcase.output is not None
+                eval.testcase.output is not None
                 and stdout_path is not None
                 and stdout_path.is_file()
             ):
@@ -485,12 +528,6 @@ def _get_evals_time_in_ms(evals: List[Evaluation]) -> int:
     return max(int((eval.log.time or 0.0) * 1000) for eval in evals)
 
 
-def _get_evals_memory_in_mb(evals: List[Evaluation]) -> int:
-    if not evals:
-        return 0
-    return max(int(eval.log.memory or 0) // (1024 * 1024) for eval in evals)
-
-
 def _get_evals_memory_in_bytes(evals: List[Evaluation]) -> int:
     if not evals:
         return 0
@@ -522,6 +559,7 @@ def _print_solution_outcome(
     has_plain_tle = False
     bad_verdicts = set()
     no_tle_bad_verdicts = set()
+    has_sanitizer_warnings = False
     for eval in evals:
         if eval.result.outcome != Outcome.ACCEPTED:
             bad_verdicts.add(eval.result.outcome)
@@ -534,7 +572,9 @@ def _print_solution_outcome(
             eval.result.outcome == Outcome.TIME_LIMIT_EXCEEDED
             and eval.result.no_tle_outcome is None
         )
-
+        has_sanitizer_warnings = (
+            has_sanitizer_warnings or eval.result.sanitizer_warnings
+        )
     unmatched_bad_verdicts = set(
         v for v in bad_verdicts if not solution.outcome.match(v)
     )
@@ -556,7 +596,9 @@ def _print_solution_outcome(
 
     console.print()
     evals_time = _get_evals_time_in_ms(evals)
-    expected_outcome_is_tle = solution.outcome.match(Outcome.TIME_LIMIT_EXCEEDED)
+    expected_outcome_is_tle = solution.outcome.match(
+        Outcome.TIME_LIMIT_EXCEEDED
+    ) and not solution.outcome.match(Outcome.ACCEPTED)
     if (
         # Running verification with double TL.
         verification.value >= VerificationLevel.FULL.value
@@ -583,15 +625,21 @@ def _print_solution_outcome(
             console.print(
                 f'[yellow]WARNING[/yellow] The solution could still run under double TL, but failed with [item]{other_verdicts_names}[/item].'
             )
+
+    if has_sanitizer_warnings:
+        console.print(
+            '[warning]WARNING[/warning] The solution had sanitizer errors or warnings, marked with [item]*[/item]. See their stderr for more details.'
+        )
+
     console.print(f'Time: {get_evals_formatted_time(evals)}')
     console.print(f'Memory: {get_evals_formatted_memory(evals)}')
     return len(unmatched_bad_verdicts) == 0
 
 
 def _consume_and_key_evaluation_items(
-    items: Iterator[EvaluationItem],
+    items: Iterable[EvaluationItem],
     skeleton: SolutionReportSkeleton,
-) -> Iterator[StructuredEvaluation]:
+) -> StructuredEvaluation:
     """
     Consumes EvaluationItems from a run_solutions call and build a view
     with them, possibly marking with optional unprocessed items.
@@ -602,7 +650,8 @@ def _consume_and_key_evaluation_items(
     for item in items:
         solution = pkg.solutions[item.solution_index]
         res[str(solution.path)][item.group_name][item.testcase_index] = item.eval
-        yield res
+
+    return res
 
 
 def _print_solution_header(solution: Solution, console: rich.console.Console):
@@ -615,18 +664,17 @@ def _print_solution_header(solution: Solution, console: rich.console.Console):
     console.print(f'({solution_testdir})')
 
 
-def _print_timing(
+async def _print_timing(
     console: rich.console.Console,
     skeleton: SolutionReportSkeleton,
-    structured_evaluation: StructuredEvaluation,
+    evaluations: StructuredEvaluation,
 ):
     slowest_good = None
     fastest_slow = None
     for solution in skeleton.solutions:
-        evals_per_group = structured_evaluation[str(solution.path)]
         all_evals = []
-        for evals in evals_per_group.values():
-            all_evals.extend([eval for eval in evals if eval is not None])
+        for evals in evaluations[str(solution.path)].values():
+            all_evals.extend([await eval() for eval in evals if eval is not None])
         solution_time = _get_evals_time_in_ms(all_evals)
         if solution.outcome.match(Outcome.ACCEPTED):
             if slowest_good is None or solution_time > slowest_good:
@@ -645,16 +693,16 @@ def _print_timing(
         console.print(f'Fastest [error]slow[/error] solution: {fastest_slow} ms')
 
 
-def _render_detailed_group_table(
+async def _render_detailed_group_table(
     group: TestcaseGroup,
     skeleton: SolutionReportSkeleton,
-    structured_evaluations: Iterator[StructuredEvaluation],
+    structured_evaluations: StructuredEvaluation,
     console: rich.console.Console,
 ):
     group_skeleton = skeleton.find_group_skeleton(group.name)
     assert group_skeleton is not None
 
-    def generate_table(
+    async def generate_table(
         structured_evaluation: StructuredEvaluation, group_name: str
     ) -> rich.table.Table:
         table = rich.table.Table()
@@ -666,12 +714,19 @@ def _render_detailed_group_table(
             row = []
             for solution in skeleton.solutions:
                 eval = structured_evaluation[str(solution.path)][group_name][tc]
-                evals_per_solution[str(solution.path)].append(eval)
                 if eval is None:
                     row.append('...')
                     continue
+                eval = eval.peek()
+                if eval is None:
+                    row.append('...')
+                    continue
+
                 verdict = get_testcase_markup_verdict(eval)
                 time = get_evals_formatted_time([eval])
+                if eval.result.sanitizer_warnings:
+                    time = f'{time} [item]*[/item]'
+                evals_per_solution[str(solution.path)].append(eval)
                 row.append(f'{verdict} {time}')
             table.add_row(*row)
 
@@ -689,28 +744,30 @@ def _render_detailed_group_table(
         return table
 
     with rich.live.Live(
-        generate_table(skeleton.empty_structured_evaluation(), group.name),
+        await generate_table(skeleton.empty_structured_evaluation(), group.name),
         refresh_per_second=5,
         console=console,
     ) as live:
-        for _ in skeleton.solutions:
-            for _ in group_skeleton.testcases:
-                structured_evaluation = next(structured_evaluations)
-                live.update(generate_table(structured_evaluation, group.name))
+        for solution in skeleton.solutions:
+            for tc, _ in enumerate(group_skeleton.testcases):
+                eval = structured_evaluations[str(solution.path)][group.name][tc]
+                if eval is None:
+                    continue
+                await eval()
+                live.update(await generate_table(structured_evaluations, group.name))
                 live.refresh()
 
 
-def _print_detailed_run_report(
+async def _print_detailed_run_report(
     result: RunSolutionResult,
     console: rich.console.Console,
-    structured_evaluations: Iterator[StructuredEvaluation],
+    structured_evaluations: StructuredEvaluation,
     timing: bool = True,
 ):
-    structured_evaluations = seekable(structured_evaluations)
     for group in result.skeleton.groups:
         console.print(f'[bold][status]{group.name}[/status][/bold]')
 
-        _render_detailed_group_table(
+        await _render_detailed_group_table(
             package.get_testgroup(group.name),
             result.skeleton,
             structured_evaluations,
@@ -719,12 +776,13 @@ def _print_detailed_run_report(
         continue
 
     ok = True
-    structured_evaluations.seek(-1)
-    structured_evaluation = next(structured_evaluations)
     for solution in result.skeleton.solutions:
         all_evals = []
-        for evals in structured_evaluation[str(solution.path)].values():
+        for evals in structured_evaluations[str(solution.path)].values():
             all_evals.extend(evals)
+
+        # Resolve futures.
+        all_evals = [await eval() for eval in all_evals if eval is not None]
         _print_solution_header(solution, console)
         cur_ok = _print_solution_outcome(
             solution,
@@ -737,93 +795,123 @@ def _print_detailed_run_report(
     console.print()
 
     if timing:
-        _print_timing(console, result.skeleton, structured_evaluation)
+        await _print_timing(console, result.skeleton, structured_evaluations)
     return ok
 
 
-def print_run_report(
+async def print_run_report(
     result: RunSolutionResult,
     console: rich.console.Console,
     verification: environment.VerificationParam,
     detailed: bool = False,
     timing: bool = True,
 ) -> bool:
-    pkg = package.find_problem_package_or_die()
-    items = seekable(result.items)
-    structured_evaluations = _consume_and_key_evaluation_items(items, result.skeleton)
+    structured_evaluations = _consume_and_key_evaluation_items(
+        result.items, result.skeleton
+    )
     if detailed:
-        return _print_detailed_run_report(
+        return await _print_detailed_run_report(
             result, console, structured_evaluations, timing=timing
         )
 
-    assert not result.skeleton.group_first
-    # Since we're now streaming the evaluation results, the for-loop is a bit
-    # confusing. We must keep state across the iteration to understand whether
-    # we're seeing a new solution or a new testgroup.
     ok = True
-    last_solution: Optional[Solution] = None
-    last_group: Optional[str] = None
-    test_index = 0
-    all_evals = []
-    group_evals = []
-
-    def print_last_solution():
-        nonlocal ok
-        if last_solution is None:
-            return
-        cur_ok = _print_solution_outcome(
-            last_solution,
-            all_evals,
-            console,
-            verification=VerificationLevel(verification),
-        )
-        console.print()
-        ok = ok and cur_ok
 
-    for item in items:
-        eval = item.eval
-        solution = pkg.solutions[item.solution_index]
-        is_new_solution = last_solution is None or solution.path != last_solution.path
-        is_new_group = is_new_solution or last_group != item.group_name
-        is_closing_group = last_group is not None and is_new_group
+    for solution in result.skeleton.solutions:
+        _print_solution_header(solution, console)
+        solution_evals = []
+        for group in result.skeleton.groups:
+            console.print(f'[bold][status]{group.name}[/status][/bold] ', end='')
+            group_evals = []
+            for i, _ in enumerate(group.testcases):
+                eval = structured_evaluations[str(solution.path)][group.name][i]
+                if eval is None:
+                    continue
+                eval = await eval()
+                console.print(f'{i}/', end='')
+                console.print(get_testcase_markup_verdict(eval), end='')
+                if eval.result.sanitizer_warnings:
+                    console.print('[item]*[/item]', end='')
+                console.print('', end=' ')
+                group_evals.append(eval)
+                solution_evals.append(eval)
 
-        if is_closing_group:
             console.print(
                 f'({get_evals_formatted_time(group_evals)}, {get_evals_formatted_memory(group_evals)})',
                 end='',
             )
             console.print()
 
-        if is_new_solution:
-            print_last_solution()
-            all_evals = []
-            last_solution = solution
-            _print_solution_header(last_solution, console)
+        ok = ok and _print_solution_outcome(
+            solution,
+            solution_evals,
+            console,
+            verification=VerificationLevel(verification),
+        )
+        console.print()
 
-        if is_new_group:
-            group_evals = []
-            last_group = item.group_name
-            test_index = 0
-            console.print(f'[bold][status]{item.group_name}[/status][/bold]', end=' ')
+    await _print_timing(console, result.skeleton, structured_evaluations)
 
-        all_evals.append(eval)
-        group_evals.append(eval)
-        console.print(f'{test_index}/', end='')
-        console.print(get_testcase_markup_verdict(eval), end=' ')
+    return ok
 
-        test_index += 1
 
-    console.print(
-        f'({get_evals_formatted_time(group_evals)}, {get_evals_formatted_memory(group_evals)})',
-        end=' ',
+async def estimate_time_limit(
+    console: rich.console.Console,
+    result: RunSolutionResult,
+) -> Optional[int]:
+    structured_evaluations = _consume_and_key_evaluation_items(
+        result.items, result.skeleton
     )
-    console.print()
-    print_last_solution()
 
-    items.seek(0)
-    structured_evaluations_list = list(structured_evaluations)
+    timing_per_solution = {}
+    timing_per_language = {}
 
-    if structured_evaluations_list:
-        _print_timing(console, result.skeleton, structured_evaluations_list[-1])
+    if not result.skeleton.solutions:
+        console.print('[error]No solutions to estimate time limit from.[/error]')
+        return None
 
-    return ok
+    for solution in result.skeleton.solutions:
+        timings = []
+        for evals in structured_evaluations[str(solution.path)].values():
+            for eval in evals:
+                if eval is None:
+                    continue
+                eval = await eval()
+                if eval.log.time is not None:
+                    timings.append(int(eval.log.time * 1000))
+
+        if not timings:
+            console.print(
+                f'[warning]No timings for solution [item]{solution.path}[/item].[/warning]'
+            )
+            continue
+
+        timing_per_solution[str(solution.path)] = max(timings)
+        lang = find_language_name(solution)
+        if lang not in timing_per_language:
+            timing_per_language[lang] = 0
+        timing_per_language[lang] = max(timing_per_language[lang], max(timings))
+
+    console.rule('[status]Time estimation[/status]', style='status')
+
+    fastest_time = min(timing_per_solution.values())
+    slowest_time = max(timing_per_solution.values())
+
+    console.print(f'Fastest solution: {fastest_time} ms')
+    console.print(f'Slowest solution: {slowest_time} ms')
+
+    if len(timing_per_language) > 0:
+        timing_language_list = [(t, lang) for lang, t in timing_per_language.items()]
+        fastest_language_time, fastest_language = min(timing_language_list)
+        slowest_language_time, slowest_language = max(timing_language_list)
+
+        console.print(
+            f'Fastest language: {fastest_language} ({fastest_language_time} ms)'
+        )
+        console.print(
+            f'Slowest language: {slowest_language} ({slowest_language_time} ms)'
+        )
+
+    estimated_tl = int(max(fastest_time * 3, slowest_time * 1.5))
+    console.print(f'[success]Estimated time limit:[/success] {estimated_tl} ms')
+
+    return estimated_tl