rbx.cp 0.5.30__tar.gz → 0.5.32__tar.gz

{rbx_cp-0.5.30 → rbx_cp-0.5.32}/PKG-INFO

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

{rbx_cp-0.5.30 → rbx_cp-0.5.32}/pyproject.toml

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

{rbx_cp-0.5.30 → rbx_cp-0.5.32}/rbx/box/code.py

@@ -152,23 +152,26 @@ def _ignore_warning_in_cxx_input(input: GradingFileInput):
     input.src = preprocessed_path
 
 
+def _format_stack_limit(limit: int) -> str:
+    if limit == resource.RLIM_INFINITY:
+        return 'unlimited'
+    return get_formatted_memory(limit)
+
+
 def _check_stack_limit():
     if not state.STATE.run_through_cli:
         return
-    soft, hard = None, None
+    soft, hard = resource.RLIM_INFINITY, resource.RLIM_INFINITY
+
+    TARGET = 256 * 1024 * 1024  # 256 MiB
     try:
         soft, hard = resource.getrlimit(resource.RLIMIT_STACK)
     except Exception:
         pass
 
-    if (
-        soft is not None
-        and hard is not None
-        and soft < hard
-        and soft < 256 * 1024 * 1024  # 256 MiB
-    ):
-        soft_fmt = get_formatted_memory(soft)
-        hard_fmt = get_formatted_memory(hard)
+    if soft != hard and soft != resource.RLIM_INFINITY and soft < TARGET:
+        soft_fmt = _format_stack_limit(soft)
+        hard_fmt = _format_stack_limit(hard)
         console.console.print(
             f'[error]Stack limit is too low (limit is set as [item]{soft_fmt}[/item], but configured user capacity is [item]{hard_fmt}[/item]).[/error]'
         )
@@ -178,15 +181,20 @@ def _check_stack_limit():
         console.console.print(
             'To solve this, add the following lines to the end of your [item]~/.bashrc[/item] or [item]~/.zshrc[/item] file (or equivalent shell configuration file):'
         )
+
+        target_text = TARGET
+        if hard != resource.RLIM_INFINITY:
+            target_text = min(hard, TARGET)
         console.console.print(
             """
 ```
 export RBX_BIN_PATH=`which rbx`
 function rbx() {
-        ulimit -s unlimited && $RBX_BIN_PATH $@
+        ulimit -s %s && $RBX_BIN_PATH $@
 }
 ```
             """
+            % target_text
         )
         console.console.print()
         console.console.print(

{rbx_cp-0.5.30 → rbx_cp-0.5.32}/rbx/box/generators.py

@@ -435,7 +435,7 @@ def generate_standalone(
             validator_digest,
         )
         if not ok:
-            _print_error_header('Failed validating testcase.')
+            _print_error_header('failed validating testcase.')
             console.console.print(f'[error]Message:[/error] {message}')
             console.console.print(
                 f'Testcase written at [item]{spec.copied_to.inputPath}[/item]'

{rbx_cp-0.5.30 → rbx_cp-0.5.32}/rbx/box/main.py

@@ -359,6 +359,12 @@ def irun(
         '-t',
         help='Testcase to run, in the format "[group]/[index]". If not specified, will run interactively.',
     ),
+    output: bool = typer.Option(
+        False,
+        '--output',
+        '-o',
+        help='Whether to ask user for custom output.',
+    ),
     print: bool = typer.Option(
         False, '--print', '-p', help='Whether to print outputs to terminal.'
     ),
@@ -421,6 +427,7 @@ def irun(
                 if generator is not None
                 else None,
                 testcase_entry=TestcaseEntry.parse(testcase) if testcase else None,
+                custom_output=output,
                 print=print,
                 sanitized=sanitized,
             )

{rbx_cp-0.5.30 → rbx_cp-0.5.32}/rbx/box/solutions.py

@@ -431,6 +431,7 @@ async def _generate_testcase_interactively(
     generator: Optional[GeneratorCall] = None,
     testcase_entry: Optional[TestcaseEntry] = None,
     check: bool = True,
+    custom_output: bool = False,
     sanitized: bool = False,
     print: bool = False,
 ) -> Testcase:
@@ -469,7 +470,7 @@ async def _generate_testcase_interactively(
         if (
             testcase.outputPath is not None
             and not testcase.outputPath.is_file()
-            and main_solution is None
+            and (main_solution is None or custom_output)
         ):
             with utils.no_progress(progress):
                 output = console.multiline_prompt('Testcase output')
@@ -605,6 +606,7 @@ async def run_and_print_interactive_solutions(
     generator: Optional[GeneratorCall] = None,
     testcase_entry: Optional[TestcaseEntry] = None,
     check: bool = True,
+    custom_output: bool = False,
     print: bool = False,
     sanitized: bool = False,
 ):
@@ -619,6 +621,7 @@ async def run_and_print_interactive_solutions(
         generator=generator,
         testcase_entry=testcase_entry,
         check=check,
+        custom_output=custom_output,
         sanitized=sanitized,
         print=print,
     )
@@ -895,33 +898,51 @@ def _print_solution_header(
     console.print(f'({solution_testdir})')
 
 
+@dataclasses.dataclass
+class TimingSummary:
+    slowest_good: Optional[int] = None
+    fastest_slow: Optional[int] = None
+
+    def add_good(self, time: int):
+        if self.slowest_good is None or time > self.slowest_good:
+            self.slowest_good = time
+
+    def add_slow(self, time: int):
+        if self.fastest_slow is None or time < self.fastest_slow:
+            self.fastest_slow = time
+
+
 async def _print_timing(
     console: rich.console.Console,
     skeleton: SolutionReportSkeleton,
     evaluations: StructuredEvaluation,
 ):
-    slowest_good = None
-    fastest_slow = None
+    summary = TimingSummary()
+    sumamry_per_language = collections.defaultdict(TimingSummary)
     for solution in skeleton.solutions:
         all_evals = []
         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:
-                slowest_good = solution_time
+            summary.add_good(solution_time)
+            sumamry_per_language[solution.language].add_good(solution_time)
         if solution.outcome.is_slow():
-            if fastest_slow is None or solution_time < fastest_slow:
-                fastest_slow = solution_time
+            summary.add_slow(solution_time)
+            sumamry_per_language[solution.language].add_slow(solution_time)
 
-    if slowest_good is None and fastest_slow is None:
+    if summary.slowest_good is None and summary.fastest_slow is None:
         return
 
     console.print('[status]Timing summary:[/status]')
-    if slowest_good is not None:
-        console.print(f'Slowest [success]OK[/success] solution: {slowest_good} ms')
-    if fastest_slow is not None:
-        console.print(f'Fastest [error]slow[/error] solution: {fastest_slow} ms')
+    if summary.slowest_good is not None:
+        console.print(
+            f'Slowest [success]OK[/success] solution: {summary.slowest_good} ms'
+        )
+    if summary.fastest_slow is not None:
+        console.print(
+            f'Fastest [error]slow[/error] solution: {summary.fastest_slow} ms'
+        )
 
 
 def _length_markup(markup: str) -> int: