rbx.cp 0.5.24__tar.gz → 0.5.25__tar.gz

{rbx_cp-0.5.24 → rbx_cp-0.5.25}/PKG-INFO

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

{rbx_cp-0.5.24 → rbx_cp-0.5.25}/pyproject.toml

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

{rbx_cp-0.5.24 → rbx_cp-0.5.25}/rbx/box/code.py

@@ -75,7 +75,7 @@ def is_executable_sanitized(executable: DigestOrSource) -> bool:
 
 def add_sanitizer_flags_to_command(command: str) -> str:
     if is_cxx_command(command):
-        return command + ' -fsanitize=address,undefined -fno-omit-frame-pointer'
+        return command + ' -fsanitize=address,undefined -fno-omit-frame-pointer -g'
     return command
 
 

{rbx_cp-0.5.24 → rbx_cp-0.5.25}/rbx/box/main.py

@@ -42,6 +42,7 @@ from rbx.box.solutions import (
     estimate_time_limit,
     get_exact_matching_solutions,
     get_matching_solutions,
+    pick_solutions,
     print_run_report,
     run_and_print_interactive_solutions,
     run_solutions,
@@ -143,6 +144,13 @@ def run(
         '-s',
         help='Whether to compile the solutions with sanitizers enabled.',
     ),
+    choice: bool = typer.Option(
+        False,
+        '--choice',
+        '--choose',
+        '-c',
+        help='Whether to pick solutions interactively.',
+    ),
 ):
     main_solution = package.get_main_solution()
     if check and main_solution is None:
@@ -174,31 +182,37 @@ def run(
         if override_tl is None:
             raise typer.Exit(1)
 
-    with utils.StatusProgress('Running solutions...') as s:
-        if sanitized:
-            console.console.print(
-                '[warning]Sanitizers are running, so the time limit for the problem will be dropped, '
-                'and the environment default time limit will be used instead.[/warning]'
-            )
+    if sanitized:
+        console.console.print(
+            '[warning]Sanitizers are running, so the time limit for the problem will be dropped, '
+            'and the environment default time limit will be used instead.[/warning]'
+        )
 
-        tracked_solutions = None
-        if outcome is not None:
-            tracked_solutions = {
-                str(solution.path)
-                for solution in get_matching_solutions(ExpectedOutcome(outcome))
-            }
-        if solution:
-            tracked_solutions = {solution}
+    tracked_solutions = None
+    if outcome is not None:
+        tracked_solutions = {
+            str(solution.path)
+            for solution in get_matching_solutions(ExpectedOutcome(outcome))
+        }
+    if solution:
+        tracked_solutions = {solution}
 
-        if sanitized and tracked_solutions is None:
-            console.console.print(
-                '[warning]Sanitizers are running, and no solutions were specified to run. Will only run [item]ACCEPTED[/item] solutions.'
-            )
-            tracked_solutions = {
-                str(solution.path)
-                for solution in get_exact_matching_solutions(ExpectedOutcome.ACCEPTED)
-            }
+    if sanitized and tracked_solutions is None:
+        console.console.print(
+            '[warning]Sanitizers are running, and no solutions were specified to run. Will only run [item]ACCEPTED[/item] solutions.'
+        )
+        tracked_solutions = {
+            str(solution.path)
+            for solution in get_exact_matching_solutions(ExpectedOutcome.ACCEPTED)
+        }
+
+    if choice:
+        tracked_solutions = set(pick_solutions(tracked_solutions))
+        if not tracked_solutions:
+            console.console.print('[error]No solutions selected. Exiting.[/error]')
+            raise typer.Exit(1)
 
+    with utils.StatusProgress('Running solutions...') as s:
         solution_result = run_solutions(
             progress=s,
             tracked_solutions=tracked_solutions,
@@ -338,6 +352,13 @@ def irun(
         '-s',
         help='Whether to compile the solutions with sanitizers enabled.',
     ),
+    choice: bool = typer.Option(
+        False,
+        '--choice',
+        '--choose',
+        '-c',
+        help='Whether to pick solutions interactively.',
+    ),
 ):
     if not print:
         console.console.print(
@@ -373,18 +394,26 @@ def irun(
             for solution in get_exact_matching_solutions(ExpectedOutcome.ACCEPTED)
         }
 
-    asyncio.run(
-        run_and_print_interactive_solutions(
-            tracked_solutions=tracked_solutions,
-            check=check,
-            verification=VerificationLevel(verification),
-            generator=generators.get_call_from_string(generator)
-            if generator is not None
-            else None,
-            print=print,
-            sanitized=sanitized,
+    if choice:
+        tracked_solutions = set(pick_solutions(tracked_solutions))
+        if not tracked_solutions:
+            console.console.print('[error]No solutions selected. Exiting.[/error]')
+            raise typer.Exit(1)
+
+    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,
+                print=print,
+                sanitized=sanitized,
+            )
         )
-    )
 
 
 @app.command('create, c', help='Create a new problem package.')
@@ -551,7 +580,10 @@ def stress(
 @app.command('compile', help='Compile an asset given its path.')
 @package.within_problem
 def compile_command(
-    path: Annotated[str, typer.Argument(help='Path to the asset to compile.')],
+    path: Annotated[
+        Optional[str],
+        typer.Argument(help='Path to the asset to compile.'),
+    ] = None,
     sanitized: bool = typer.Option(
         False,
         '--sanitized',
@@ -565,6 +597,12 @@ def compile_command(
         help='Whether to compile the asset with warnings enabled.',
     ),
 ):
+    if path is None:
+        path = questionary.path("What's the path to your asset?").ask()
+        if path is None:
+            console.console.print('[error]No path specified.[/error]')
+            raise typer.Exit(1)
+
     compile.any(path, sanitized, warnings)
 
 

{rbx_cp-0.5.24 → rbx_cp-0.5.25}/rbx/box/solutions.py

@@ -7,6 +7,7 @@ import shutil
 from collections.abc import Iterator
 from typing import Dict, Iterable, List, Optional, Set, Tuple
 
+import questionary
 import rich
 import rich.live
 import rich.markup
@@ -410,6 +411,7 @@ def run_solutions(
 
 
 def _run_interactive_solutions(
+    progress: Optional[StatusProgress] = None,
     tracked_solutions: Optional[Set[str]] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
     generator: Optional[GeneratorCall] = None,
@@ -423,7 +425,7 @@ def _run_interactive_solutions(
 
     checker_digest = checkers.compile_checker() if check else None
     compiled_solutions = compile_solutions(
-        tracked_solutions=tracked_solutions, sanitized=sanitized
+        progress=progress, tracked_solutions=tracked_solutions, sanitized=sanitized
     )
 
     main_solution_digest = None
@@ -498,6 +500,7 @@ def _run_interactive_solutions(
 
 
 async def run_and_print_interactive_solutions(
+    progress: Optional[StatusProgress] = None,
     tracked_solutions: Optional[Set[str]] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
     generator: Optional[GeneratorCall] = None,
@@ -507,6 +510,7 @@ async def run_and_print_interactive_solutions(
 ):
     pkg = package.find_problem_package_or_die()
     items = _run_interactive_solutions(
+        progress=progress,
         tracked_solutions=tracked_solutions,
         verification=verification,
         check=check,
@@ -515,6 +519,9 @@ async def run_and_print_interactive_solutions(
         print=print,
     )
 
+    if progress:
+        progress.stop()
+
     for item in items:
         sol = pkg.solutions[item.solution_index]
         _print_solution_header(sol, console.console, is_irun=True)
@@ -540,6 +547,16 @@ async def run_and_print_interactive_solutions(
             console.console.print()
 
 
+def pick_solutions(tracked_solutions: Optional[Set[str]]) -> List[str]:
+    pkg = package.find_problem_package_or_die()
+    if tracked_solutions is None:
+        tracked_solutions = set(str(sol.path) for sol in pkg.solutions)
+
+    return questionary.checkbox(
+        'Select solutions', choices=list(tracked_solutions)
+    ).ask()
+
+
 def get_outcome_style_verdict(outcome: Outcome) -> str:
     if outcome == Outcome.ACCEPTED:
         return 'green'
@@ -554,21 +571,25 @@ def get_outcome_style_verdict(outcome: Outcome) -> str:
     return 'magenta'
 
 
-def get_testcase_markup_verdict(eval: Evaluation) -> str:
+def get_outcome_markup_verdict(outcome: Outcome) -> str:
     res = '✓'
-    if eval.result.outcome != Outcome.ACCEPTED:
+    if outcome != Outcome.ACCEPTED:
         res = '✗'
-    if eval.result.outcome == Outcome.TIME_LIMIT_EXCEEDED:
+    if outcome == Outcome.TIME_LIMIT_EXCEEDED:
         res = '⧖'
-    if eval.result.outcome == Outcome.RUNTIME_ERROR:
+    if outcome == Outcome.RUNTIME_ERROR:
         res = '✗'
-    style = get_outcome_style_verdict(eval.result.outcome)
+    style = get_outcome_style_verdict(outcome)
     res = f'[{style}]{res}[/{style}]'
+    return res
+
+
+def get_testcase_markup_verdict(eval: Evaluation) -> str:
     # if eval.log.stdout_absolute_path:
     #     output_path = eval.log.stdout_absolute_path.resolve()
     #     output_link = f'file://{output_path}'
     #     res = f'[link={output_link}]{res}[/link]'
-    return res
+    return get_outcome_markup_verdict(eval.result.outcome)
 
 
 def _get_evals_time_in_ms(evals: List[Evaluation]) -> int:
@@ -632,6 +653,10 @@ def get_evals_formatted_memory(evals: List[Evaluation]) -> str:
     return get_formatted_memory(max_memory)
 
 
+def get_worst_outcome(evals: List[Evaluation]) -> Outcome:
+    return Outcome.worst_outcome(eval.result.outcome for eval in evals)
+
+
 def _print_solution_outcome(
     solution: Solution,
     evals: List[Evaluation],
@@ -880,7 +905,11 @@ async def _render_detailed_group_table(
                     solution, non_null_evals, verification
                 )
                 formatted_memory = get_evals_formatted_memory(non_null_evals)
-                summary_row.append(('', '', formatted_time, '/', formatted_memory, ''))
+                worst_outcome = get_worst_outcome(non_null_evals)
+                verdict = get_outcome_markup_verdict(worst_outcome)
+                summary_row.append(
+                    ('', verdict, formatted_time, '/', formatted_memory, '')
+                )
             padded_rows.append(summary_row)
 
         for row in _render_padded_rows(padded_rows):
@@ -1020,12 +1049,13 @@ async def print_run_report(
             )
             console.print()
 
-        ok = ok and _print_solution_outcome(
+        cur_ok = _print_solution_outcome(
             solution,
             solution_evals,
             console,
             verification=verification,
         )
+        ok = ok and cur_ok
         console.print()
 
     await _print_timing(console, result.skeleton, structured_evaluations)

{rbx_cp-0.5.24 → rbx_cp-0.5.25}/rbx/grading/steps.py

@@ -6,7 +6,7 @@ import shutil
 import subprocess
 import sys
 from enum import Enum
-from typing import IO, Any, Dict, List, Optional, Tuple, Union
+from typing import IO, Any, Dict, Iterable, List, Optional, Tuple, Union
 
 import typer
 from pydantic import BaseModel
@@ -24,13 +24,20 @@ MAX_STDOUT_LEN = 1024 * 1024 * 128  # 128 MB
 class Outcome(Enum):
     ACCEPTED = 'accepted'
     WRONG_ANSWER = 'wrong-answer'
-    JUDGE_FAILED = 'judge-failed'
-    RUNTIME_ERROR = 'runtime-error'
-    TIME_LIMIT_EXCEEDED = 'time-limit-exceeded'
     MEMORY_LIMIT_EXCEEDED = 'memory-limit-exceeded'
+    TIME_LIMIT_EXCEEDED = 'time-limit-exceeded'
+    RUNTIME_ERROR = 'runtime-error'
     OUTPUT_LIMIT_EXCEEDED = 'output-limit-exceeded'
+    JUDGE_FAILED = 'judge-failed'
     INTERNAL_ERROR = 'internal-error'
 
+    @classmethod
+    def worst_outcome(cls, outcomes: Iterable['Outcome']) -> 'Outcome':
+        def _outcome_to_int(o: 'Outcome') -> int:
+            return cls._member_names_.index(o.name)
+
+        return max(outcomes, key=_outcome_to_int)
+
 
 class DigestHolder(BaseModel):
     value: Optional[str] = None