rbx.cp 0.18.3__tar.gz → 0.18.4__tar.gz

{rbx_cp-0.18.3 → rbx_cp-0.18.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rbx.cp
-Version: 0.18.3
+Version: 0.18.4
 Summary: 
 Author: Roberto Sales
 Requires-Python: >=3.9.1,<4.0.0

{rbx_cp-0.18.3 → rbx_cp-0.18.4}/pyproject.toml

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

rbx_cp-0.18.4/rbx/__version__.py

@@ -0,0 +1 @@
+__version__ = '0.18.4'

{rbx_cp-0.18.3 → rbx_cp-0.18.4}/rbx/box/cli.py

@@ -680,6 +680,12 @@ async def stress(
         help='Whether to print descriptors of the stress test.',
         hidden=True,
     ),
+    skip_invalid_testcases: bool = typer.Option(
+        False,
+        '--skip-invalid',
+        '--skip',
+        help='Whether to skip invalid testcases.',
+    ),
 ):
     if finder and not generator_args or generator_args and not finder:
         console.console.print(
@@ -701,6 +707,7 @@ async def stress(
                 verbose=verbose,
                 sanitized=sanitized,
                 print_descriptors=print_descriptors,
+                skip_invalid_testcases=skip_invalid_testcases,
             )
 
     stresses.print_stress_report(report)

{rbx_cp-0.18.3 → rbx_cp-0.18.4}/rbx/box/code.py

@@ -443,17 +443,19 @@ def _precompile_header(
     )
 
     with profiling.PushContext('code.precompile_header'):
-        if not steps_with_caching.compile(
-            commands,
-            params=sandbox_params,
-            artifacts=precompilation_artifacts,
-            sandbox=sandbox,
-            dependency_cache=dependency_cache,
-        ):
-            console.console.print(
+        try:
+            steps_with_caching.compile(
+                commands,
+                params=sandbox_params,
+                artifacts=precompilation_artifacts,
+                sandbox=sandbox,
+                dependency_cache=dependency_cache,
+            )
+        except steps.CompilationError as e:
+            e.print(
                 f'[error]Failed to precompile header file: [item]{input_artifact.src}[/item][/error]'
             )
-            raise typer.Exit(1)
+            raise
 
         if verbose:
             console.console.print(
@@ -487,13 +489,14 @@ def _precompile_header(
             ):
                 input = DigestOrSource.create(local_cacher.put_file_from_fobj(f))
 
-    return GradingFileInput(
+    res = GradingFileInput(
         **input.expand(),
         dest=input_artifact.dest.with_suffix('.h.gch'),
         # Do not track fingerprint of the precompiled header file,
         # trust the compilation step above.
         hash=False,
     )
+    return res
 
 
 # Compile code item and return its digest in the storage.
@@ -609,14 +612,19 @@ def compile_item(
             grading_context.CacheLevel.NO_CACHE,
             when=lambda: is_path_remote(code.path),
         ):
-            if not steps_with_caching.compile(
-                commands,
-                params=sandbox_params,
-                artifacts=artifacts,
-                sandbox=sandbox,
-                dependency_cache=dependency_cache,
-            ):
-                raise typer.Exit(1)
+            try:
+                steps_with_caching.compile(
+                    commands,
+                    params=sandbox_params,
+                    artifacts=artifacts,
+                    sandbox=sandbox,
+                    dependency_cache=dependency_cache,
+                )
+            except steps.CompilationError as e:
+                e.print(
+                    f'[error]Failed to compile item: [item]{code.path}[/item][/error]'
+                )
+                raise
 
     assert compiled_digest.value is not None
 

{rbx_cp-0.18.3 → rbx_cp-0.18.4}/rbx/box/contest/build_contest_statements.py

@@ -1,5 +1,6 @@
 import dataclasses
 import pathlib
+import shutil
 import tempfile
 import typing
 from typing import Any, Dict, List, Optional, Tuple
@@ -228,10 +229,10 @@ def _build_problem_statements(
                 )
                 issue_stack.add_issue(StatementBuildIssue(extracted_problem.problem))
                 continue
-        dest_dir = root / '.problems' / extracted_problem.problem.short_name
+        dest_dir = pathlib.Path('.problems') / extracted_problem.problem.short_name
         dest_path = dest_dir / f'statement{output_type.get_file_suffix()}'
-        dest_dir.mkdir(parents=True, exist_ok=True)
-        dest_path.write_bytes(content)
+        (root / dest_dir).mkdir(parents=True, exist_ok=True)
+        (root / dest_path).write_bytes(content)
 
         problem_assets = (
             get_relative_assets(
@@ -240,7 +241,7 @@ def _build_problem_statements(
             )
             + contest_assets
         )
-        prepare_assets(problem_assets, dest_dir)
+        prepare_assets(problem_assets, root / dest_dir)
 
         res.append(dataclasses.replace(extracted_problem, built_statement=dest_path))
     return res
@@ -393,6 +394,10 @@ def build_statement_rooted(
     return last_content, last_output
 
 
+def get_statement_build_dir(statement: ContestStatement) -> pathlib.Path:
+    return pathlib.Path('build') / 'statement_build' / statement.name
+
+
 def build_statement(
     statement: ContestStatement,
     contest: Contest,
@@ -401,17 +406,18 @@ def build_statement(
     custom_vars: Optional[Dict[str, Any]] = None,
     install_tex: bool = False,
 ) -> pathlib.Path:
-    with tempfile.TemporaryDirectory() as td:
-        root = pathlib.Path(td)
-        last_content, last_output = build_statement_rooted(
-            statement,
-            contest,
-            root,
-            output_type=output_type,
-            use_samples=use_samples,
-            custom_vars=custom_vars,
-            install_tex=install_tex,
-        )
+    root = get_statement_build_dir(statement)
+    shutil.rmtree(root, ignore_errors=True)
+    root.mkdir(parents=True, exist_ok=True)
+    last_content, last_output = build_statement_rooted(
+        statement,
+        contest,
+        root,
+        output_type=output_type,
+        use_samples=use_samples,
+        custom_vars=custom_vars,
+        install_tex=install_tex,
+    )
 
     statement_path = (pathlib.Path('build') / statement.name).with_suffix(
         last_output.get_file_suffix()

{rbx_cp-0.18.3 → rbx_cp-0.18.4}/rbx/box/environment.py

@@ -252,7 +252,7 @@ execution config can be individually overridden in the language configuration.""
 
 
 def get_app_environment_path(env: str) -> pathlib.Path:
-    return config.get_resources_file(pathlib.PosixPath('envs') / f'{env}.rbx.yml')
+    return config.get_resources_file(pathlib.PosixPath('presets') / env / 'env.rbx.yml')
 
 
 def get_active_environment_path() -> pathlib.Path:

rbx_cp-0.18.4/rbx/box/exception.py

@@ -0,0 +1,71 @@
+from typing import List, Optional
+
+from rich.console import Capture, Console
+
+from rbx import console
+
+
+class PossiblyCapture:
+    def __init__(
+        self, console: Console, msg: List[str], capture: Optional[Capture] = None
+    ):
+        self.console = console
+        self.msg = msg
+        self.capture = capture
+        self.actual_capture = None
+
+    def __enter__(self):
+        if self.capture is not None:
+            return
+        self.actual_capture = self.console.capture()
+        self.actual_capture.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self.actual_capture is not None:
+            self.actual_capture.__exit__(exc_type, exc_value, traceback)
+            self.msg.append(self.actual_capture.get())
+            self.actual_capture = None
+
+
+class RbxException(RuntimeError):
+    def __init__(self):
+        super().__init__()
+        self.msg = []
+        self.capture = None
+        self.console = console.new_console()
+
+    def possibly_capture(self):
+        return PossiblyCapture(self.console, self.msg, self.capture)
+
+    def rule(self, *args, **kwargs):
+        with self.possibly_capture():
+            self.console.rule(*args, **kwargs)
+
+    def print(self, *args, **kwargs):
+        with self.possibly_capture():
+            self.console.print(*args, **kwargs)
+
+    def log(self, *args, **kwargs):
+        with self.possibly_capture():
+            self.console.log(*args, **kwargs)
+
+    def __enter__(self):
+        capture = self.console.capture()
+        capture.__enter__()
+        self.capture = capture
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self.capture is not None:
+            self.capture.__exit__(exc_type, exc_value, traceback)
+            self.msg.append(self.capture.get())
+            self.capture = None
+        if exc_type is not None:
+            return
+        raise self
+
+    def __str__(self) -> str:
+        if not self.msg:
+            return ''
+        return ''.join(self.msg)

{rbx_cp-0.18.3 → rbx_cp-0.18.4}/rbx/box/generators.py

@@ -4,10 +4,12 @@ import shutil
 from typing import Dict, List, Optional, Set
 
 import typer
+from rich.console import Console
 
 from rbx import console
 from rbx.box import checkers, package, testcase_utils, validators
 from rbx.box.code import SanitizationLevel, compile_item, run_item
+from rbx.box.exception import RbxException
 from rbx.box.schema import (
     CodeItem,
     GeneratorCall,
@@ -37,6 +39,10 @@ from rbx.grading.steps import (
 from rbx.utils import StatusProgress
 
 
+class ValidationError(RbxException):
+    pass
+
+
 def _compile_generator(generator: CodeItem) -> str:
     return compile_item(generator, sanitized=SanitizationLevel.PREFER)
 
@@ -261,7 +267,7 @@ async def generate_standalone(
     validator_digest: Optional[str] = None,
     progress: Optional[StatusProgress] = None,
 ):
-    def _print_error_header(text: Optional[str] = None):
+    def _print_error_header(console: Console, text: Optional[str] = None):
         prefix = 'Failed generating test'
         if group_entry is not None:
             prefix += (
@@ -271,11 +277,11 @@ async def generate_standalone(
         if text:
             suffix = f': {text}'
         if spec.generator_call is not None:
-            console.console.print(
+            console.print(
                 f'[error]{prefix} using generator call [info]{spec.generator_call.name} {spec.generator_call.args}[/info]{suffix}[/error]'
             )
         else:
-            console.console.print(f'[error]{prefix}{suffix}[/error]')
+            console.print(f'[error]{prefix}{suffix}[/error]')
 
     if spec.generator_call is not None:
         call = spec.generator_call
@@ -333,12 +339,12 @@ async def generate_standalone(
             validator_digest,
         )
         if not validation_info.ok:
-            _print_error_header('failed validating testcase.')
-            console.console.print(f'[error]Message:[/error] {validation_info.message}')
-            console.console.print(
-                f'Testcase written at [item]{spec.copied_to.inputPath}[/item]'
-            )
-            raise typer.Exit(1)
+            with ValidationError() as err:
+                _print_error_header(err.console, 'failed validating testcase.')
+                err.print(f'[error]Message:[/error] {validation_info.message}')
+                err.print(
+                    f'Testcase written at [item]{spec.copied_to.inputPath}[/item]'
+                )
 
 
 async def generate_testcases(

rbx_cp-0.18.4/rbx/box/main.py

@@ -0,0 +1,17 @@
+# flake8: noqa
+import nest_asyncio
+import sys
+
+from rbx.box.exception import RbxException
+
+nest_asyncio.apply()
+
+from rbx.box.cli import app as app_cli
+
+
+def app():
+    try:
+        app_cli()
+    except RbxException as e:
+        print(str(e))
+        sys.exit(1)

{rbx_cp-0.18.3 → rbx_cp-0.18.4}/rbx/box/solutions.py

@@ -55,7 +55,7 @@ from rbx.box.testcase_utils import (
     parse_interaction,
     print_interaction,
 )
-from rbx.grading import grading_context
+from rbx.grading import grading_context, steps
 from rbx.grading.limits import Limits
 from rbx.grading.steps import (
     Evaluation,
@@ -90,6 +90,7 @@ class SolutionReportSkeleton(BaseModel):
     entries: List[TestcaseEntry]
     groups: List[GroupSkeleton]
     limits: Dict[str, Limits]
+    compiled_solutions: Dict[str, str]
     verification: VerificationLevel
     capture_pipes: bool = False
 
@@ -125,6 +126,9 @@ class SolutionReportSkeleton(BaseModel):
                 return i
         return None
 
+    def get_solution_compiled_digest(self, solution: Solution) -> str:
+        return self.compiled_solutions[str(solution.path)]
+
     def get_solution_path_set(self) -> Set[str]:
         return set(str(sol.path) for sol in self.solutions)
 
@@ -179,10 +183,22 @@ def get_exact_matching_solutions(expected_outcome: ExpectedOutcome) -> List[Solu
     return res
 
 
+class FailedToCompileSolutionIssue(issue_stack.Issue):
+    def __init__(self, solution: Solution):
+        self.solution = solution
+
+    def get_detailed_section(self) -> Tuple[str, ...]:
+        return ('solutions',)
+
+    def get_detailed_message(self) -> str:
+        return f'[item]{href(self.solution.path)}[/item] could not be compiled and was skipped.'
+
+
 def compile_solutions(
     progress: Optional[StatusProgress] = None,
     tracked_solutions: Optional[Set[str]] = None,
     sanitized: bool = False,
+    fail_if_one: bool = True,
 ) -> Dict[pathlib.Path, str]:
     compiled_solutions = {}
 
@@ -199,6 +215,10 @@ def compile_solutions(
                 if sanitized
                 else SanitizationLevel.NONE,
             )
+        except steps.CompilationError:
+            if fail_if_one and len(tracked_solutions) <= 1:
+                raise
+            issue_stack.add_issue(FailedToCompileSolutionIssue(solution))
         except:
             console.console.print(
                 f'[error]Failed compiling solution {href(solution.path)}.[/error]'
@@ -283,13 +303,48 @@ def _get_solutions_for_skeleton(
     return solutions
 
 
+def _get_compiled_solutions_for_skeleton(
+    tracked_solutions: Optional[Iterable[str]] = None,
+    progress: Optional[StatusProgress] = None,
+    sanitized: bool = False,
+    verification: VerificationLevel = VerificationLevel.NONE,
+) -> Tuple[List[Solution], Dict[str, str]]:
+    solutions_to_compile = _get_solutions_for_skeleton(tracked_solutions, verification)
+
+    compiled_solutions = compile_solutions(
+        progress=progress,
+        tracked_solutions=set(str(solution.path) for solution in solutions_to_compile),
+        sanitized=sanitized,
+    )
+
+    # TODO: Handle solutions that failed to compile.
+    solutions = [
+        solution
+        for solution in solutions_to_compile
+        if solution.path in compiled_solutions
+    ]
+
+    return solutions, {
+        str(solution_path): digest
+        for solution_path, digest in compiled_solutions.items()
+    }
+
+
 def _get_report_skeleton(
     tracked_solutions: Optional[Iterable[str]] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
     timelimit_override: Optional[int] = None,
+    progress: Optional[StatusProgress] = None,
+    sanitized: bool = False,
 ) -> SolutionReportSkeleton:
     pkg = package.find_problem_package_or_die()
-    solutions = _get_solutions_for_skeleton(tracked_solutions, verification)
+
+    solutions, compiled_solutions = _get_compiled_solutions_for_skeleton(
+        tracked_solutions=tracked_solutions,
+        verification=verification,
+        progress=progress,
+        sanitized=sanitized,
+    )
 
     langs = set(find_language_name(solution) for solution in solutions)
     limits = {
@@ -324,6 +379,7 @@ def _get_report_skeleton(
         groups=groups,
         limits=limits,
         entries=entries,
+        compiled_solutions=compiled_solutions,
         verification=verification,
         capture_pipes=state.STATE.debug_logs,
     )
@@ -340,7 +396,6 @@ def _produce_solution_items(
     verification: VerificationLevel = VerificationLevel.NONE,
     check: bool = True,
     timelimit_override: Optional[int] = None,
-    sanitized: bool = False,
     nruns: int = 0,
 ) -> List[EvaluationItem]:
     pkg = package.find_problem_package_or_die()
@@ -354,12 +409,6 @@ def _produce_solution_items(
         checker_digest = checkers.compile_checker() if check else None
         interactor_digest = None
 
-    compiled_solutions = compile_solutions(
-        progress=progress,
-        tracked_solutions=skeleton.get_solution_path_set(),
-        sanitized=sanitized,
-    )
-
     def yield_items(
         solution: SolutionSkeleton, group_name: str
     ) -> List[EvaluationItem]:
@@ -367,7 +416,7 @@ def _produce_solution_items(
         for i, eval in enumerate(
             _run_solution(
                 solution,
-                compiled_solutions[solution.path],
+                skeleton.get_solution_compiled_digest(solution),
                 checker_digest,
                 solution.runs_dir,
                 group_name,
@@ -425,9 +474,11 @@ def run_solutions(
     nruns: int = 0,
 ) -> RunSolutionResult:
     skeleton = _get_report_skeleton(
-        tracked_solutions,
+        progress=progress,
+        tracked_solutions=tracked_solutions,
         verification=verification,
         timelimit_override=timelimit_override,
+        sanitized=sanitized,
     )
     result = RunSolutionResult(
         skeleton=skeleton,
@@ -437,7 +488,6 @@ def run_solutions(
             verification=verification,
             check=check,
             timelimit_override=timelimit_override,
-            sanitized=sanitized,
             nruns=nruns,
         ),
     )
@@ -588,7 +638,6 @@ def _run_interactive_solutions(
     progress: Optional[StatusProgress] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
     check: bool = True,
-    sanitized: bool = False,
 ) -> Iterator[EvaluationItem]:
     pkg = package.find_problem_package_or_die()
 
@@ -599,12 +648,6 @@ def _run_interactive_solutions(
         checker_digest = checkers.compile_checker() if check else None
         interactor_digest = None
 
-    compiled_solutions = compile_solutions(
-        progress=progress,
-        tracked_solutions=skeleton.get_solution_path_set(),
-        sanitized=sanitized,
-    )
-
     if progress:
         progress.update('Running solutions...')
 
@@ -614,7 +657,7 @@ def _run_interactive_solutions(
         async def run_fn(solution=solution, output_dir=output_dir):
             return await run_solution_on_testcase(
                 solution,
-                compiled_solutions[solution.path],
+                skeleton.get_solution_compiled_digest(solution),
                 checker_digest,
                 testcase,
                 output_dir=output_dir,
@@ -632,9 +675,16 @@ def _run_interactive_solutions(
 
 def _get_interactive_skeleton(
     tracked_solutions: Optional[Iterable[str]] = None,
+    progress: Optional[StatusProgress] = None,
+    sanitized: bool = False,
     verification: VerificationLevel = VerificationLevel.NONE,
 ) -> SolutionReportSkeleton:
-    solutions = _get_solutions_for_skeleton(tracked_solutions, verification)
+    solutions, compiled_solutions = _get_compiled_solutions_for_skeleton(
+        tracked_solutions,
+        verification=verification,
+        progress=progress,
+        sanitized=sanitized,
+    )
 
     langs = set(find_language_name(solution) for solution in solutions)
     limits = {
@@ -660,6 +710,7 @@ def _get_interactive_skeleton(
         limits=limits,
         entries=[],
         verification=verification,
+        compiled_solutions=compiled_solutions,
         capture_pipes=True,
     )
 
@@ -682,8 +733,10 @@ async def run_and_print_interactive_solutions(
 ):
     pkg = package.find_problem_package_or_die()
     skeleton = _get_interactive_skeleton(
-        tracked_solutions,
+        tracked_solutions=tracked_solutions,
         verification=verification,
+        sanitized=sanitized,
+        progress=progress,
     )
 
     should_cache = testcase_entry is not None
@@ -705,7 +758,6 @@ async def run_and_print_interactive_solutions(
             progress=progress,
             verification=verification,
             check=check,
-            sanitized=sanitized,
         )
 
     for item in items:

{rbx_cp-0.18.3 → rbx_cp-0.18.4}/rbx/box/statements/latex.py

@@ -37,16 +37,17 @@ class Latex:
         self.latex = latex
 
     def build_pdf(self, temp_dir: pathlib.Path) -> LatexResult:
-        temp_path = temp_dir / 'statement.tex'
+        temp_path = pathlib.Path('statement.tex')
         output_path = temp_path.with_suffix('.pdf')
         args = ['pdflatex', '-interaction', 'nonstopmode', str(temp_path)]
-        temp_path.write_text(self.latex)
+
+        (temp_dir / temp_path).write_text(self.latex)
 
         completed = subprocess.run(args, timeout=15, capture_output=True, cwd=temp_dir)
-        if completed.returncode != 0 or not output_path.exists():
+        if completed.returncode != 0 or not (temp_dir / output_path).exists():
             return LatexResult(result=completed, pdf=None)
 
-        return LatexResult(result=completed, pdf=output_path.read_bytes())
+        return LatexResult(result=completed, pdf=(temp_dir / output_path).read_bytes())
 
 
 def install_tex_packages(path: pathlib.Path, cwd: pathlib.Path):