rbx.cp 0.8.0__py3-none-any.whl → 0.9.1__py3-none-any.whl

rbx/box/remote.py

@@ -5,7 +5,7 @@ from typing import List, Optional, Tuple, Union
 
 import typer
 
-from rbx import console
+from rbx import console, utils
 from rbx.box import cd, package
 from rbx.box.formatting import href, ref
 
@@ -85,7 +85,7 @@ REGISTERED_EXPANDERS: List['Expander'] = [
 
 
 def _relative_to_pkg(path: pathlib.Path) -> pathlib.Path:
-    return path.resolve().relative_to(pathlib.Path.cwd())
+    return utils.abspath(path).relative_to(pathlib.Path.cwd())
 
 
 def _try_cacheable_paths(
@@ -167,4 +167,4 @@ def expand_file(file: str) -> pathlib.Path:
 
 def is_path_remote(path: pathlib.Path) -> bool:
     remote_dir = package.get_problem_remote_dir()
-    return path.resolve().is_relative_to(remote_dir.resolve())
+    return utils.abspath(path).is_relative_to(utils.abspath(remote_dir))

rbx/box/retries.py

@@ -5,6 +5,7 @@ import tempfile
 from contextlib import contextmanager
 from typing import Awaitable, Callable, List, Optional
 
+from rbx import utils
 from rbx.box import package
 from rbx.box.setter_config import RepeatsConfig, get_setter_config
 from rbx.grading.steps import Evaluation, Outcome
@@ -59,8 +60,8 @@ class FileToRecover:
 
 def _move_to_temp_dir(path: pathlib.Path, temp_dir: pathlib.Path) -> FileToRecover:
     problem_path = package.find_problem()
-    path = path.resolve()
-    temp_dir = temp_dir.resolve()
+    path = utils.abspath(path)
+    temp_dir = utils.abspath(temp_dir)
     relative = path.relative_to(problem_path)
 
     temp_path = temp_dir / relative

rbx/box/sanitizers/warning_stack.py

@@ -2,7 +2,7 @@ import functools
 import pathlib
 import shutil
 
-from rbx import console
+from rbx import console, utils
 from rbx.box.schema import CodeItem
 from rbx.grading.judge.cacher import FileCacher
 from rbx.grading.steps import GradingFileOutput
@@ -60,7 +60,7 @@ def _get_warning_runs_dir(root: pathlib.Path) -> pathlib.Path:
 
 
 def get_warning_stack() -> WarningStack:
-    current_root = pathlib.Path.cwd().resolve()
+    current_root = utils.abspath(pathlib.Path.cwd())
     return _get_warning_stack(current_root)
 
 

rbx/box/setter_config.py

@@ -9,6 +9,7 @@ import typer
 from pydantic import BaseModel, Field
 
 from rbx import config, console, utils
+from rbx.grading.grading_context import CacheLevel
 
 app = typer.Typer(no_args_is_help=True)
 
@@ -52,6 +53,19 @@ class RepeatsConfig(BaseModel):
     )
 
 
+class CachingConfig(BaseModel):
+    level: CacheLevel = Field(
+        default=CacheLevel.CACHE_ALL,
+        description='Whether to enable caching and which caching level to use.',
+    )
+
+    check_integrity: bool = Field(
+        default=True,
+        description='Whether to check the integrity of the cached result, and evict it'
+        'if file has changed since it was cached.',
+    )
+
+
 class SetterConfig(BaseModel):
     sanitizers: SanitizersConfig = Field(
         default_factory=SanitizersConfig,  # type: ignore
@@ -75,6 +89,10 @@ class SetterConfig(BaseModel):
         default=True,
         description='Whether to use hyperlinks in the terminal output.',
     )
+    caching: CachingConfig = Field(
+        default_factory=CachingConfig,  # type: ignore
+        description='Configuration for caching.',
+    )
 
     def substitute_command(self, command: str, sanitized: bool = False) -> str:
         exe = shlex.split(command)[0]

rbx/box/solutions.py

@@ -54,6 +54,7 @@ from rbx.box.testcase_utils import (
     parse_interaction,
     print_interaction,
 )
+from rbx.grading import grading_context
 from rbx.grading.limits import Limits
 from rbx.grading.steps import (
     Evaluation,
@@ -498,7 +499,7 @@ async def _generate_testcase_interactively(
             console.console.print(testcase.inputPath.read_text())
         else:
             console.console.print(
-                f'Input was written to [item]{testcase.inputPath.resolve()}[/item]'
+                f'Input was written to [item]{utils.abspath(testcase.inputPath)}[/item]'
             )
         console.console.print()
 
@@ -660,23 +661,28 @@ async def run_and_print_interactive_solutions(
         tracked_solutions,
         verification=verification,
     )
-    testcase = await _generate_testcase_interactively(
-        progress=progress,
-        generator=generator,
-        testcase_entry=testcase_entry,
-        check=check,
-        custom_output=custom_output,
-        sanitized=sanitized,
-        print=print,
-    )
-    items = _run_interactive_solutions(
-        testcase,
-        skeleton=skeleton,
-        progress=progress,
-        verification=verification,
-        check=check,
-        sanitized=sanitized,
-    )
+
+    should_cache = testcase_entry is not None
+    with grading_context.cache_level(
+        grading_context.CacheLevel.CACHE_COMPILATION, when=not should_cache
+    ):
+        testcase = await _generate_testcase_interactively(
+            progress=progress,
+            generator=generator,
+            testcase_entry=testcase_entry,
+            check=check,
+            custom_output=custom_output,
+            sanitized=sanitized,
+            print=print,
+        )
+        items = _run_interactive_solutions(
+            testcase,
+            skeleton=skeleton,
+            progress=progress,
+            verification=verification,
+            check=check,
+            sanitized=sanitized,
+        )
 
     for item in items:
         sol = skeleton.find_solution_skeleton(item.solution)

rbx/box/statements/build_statements.py

@@ -6,7 +6,7 @@ from typing import Annotated, Any, Dict, List, Optional, Tuple
 import syncer
 import typer
 
-from rbx import annotations, console
+from rbx import annotations, console, utils
 from rbx.box import environment, naming, package
 from rbx.box.formatting import href
 from rbx.box.schema import Package, expand_any_vars
@@ -46,7 +46,7 @@ def get_environment_languages_for_statement() -> List[StatementCodeLanguage]:
         res.append(
             StatementCodeLanguage(
                 id=language.name,
-                name=language.readable_name or language.name,
+                name=language.readableName or language.name,
                 command=cmd or '',
             )
         )
@@ -173,7 +173,7 @@ def get_relative_assets(
     relative_to: pathlib.Path,
     assets: List[str],
 ) -> List[Tuple[pathlib.Path, pathlib.Path]]:
-    relative_to = relative_to.resolve()
+    relative_to = utils.abspath(relative_to)
     if not relative_to.is_dir():
         relative_to = relative_to.parent
     res = []
@@ -192,7 +192,7 @@ def get_relative_assets(
                 raise typer.Exit(1)
             res.extend(get_relative_assets(relative_to, list(map(str, globbed))))
             continue
-        if not relative_path.resolve().is_relative_to(relative_to):
+        if not utils.abspath(relative_path).is_relative_to(relative_to):
             console.console.print(
                 f'[error]Asset [item]{asset}[/item] is not relative to your statement.[/error]'
             )
@@ -200,8 +200,8 @@ def get_relative_assets(
 
         res.append(
             (
-                relative_path.resolve(),
-                relative_path.resolve().relative_to(relative_to),
+                utils.abspath(relative_path),
+                utils.abspath(relative_path).relative_to(relative_to),
             )
         )
 

rbx/box/statements/builders.py

@@ -319,7 +319,7 @@ class rbxTeXBuilder(StatementBuilder):
         params = typing.cast(rbxToTeX, params)
         if not params.template:
             return []
-        return [((root / params.template).resolve(), params.template)]
+        return [(utils.abspath(root / params.template), params.template)]
 
     def build(
         self,

rbx/box/stresses.py

@@ -9,7 +9,7 @@ import syncer
 import typer
 from pydantic import BaseModel
 
-from rbx import console
+from rbx import console, utils
 from rbx.box import checkers, generators, package, tasks, validators
 from rbx.box.code import SanitizationLevel, compile_item
 from rbx.box.generators import (
@@ -311,7 +311,7 @@ def print_stress_report(report: StressReport):
     console.console.print(f'Found [item]{len(report.findings)}[/item] testcases.')
 
     findings_dir = package.get_problem_runs_dir() / '.stress' / 'findings'
-    console.console.print(f'Findings: {findings_dir.resolve()}')
+    console.console.print(f'Findings: {utils.abspath(findings_dir)}')
     console.console.print()
 
     for i, finding in enumerate(report.findings):

rbx/box/testcase_utils.py

@@ -7,7 +7,7 @@ import rich.text
 import typer
 from pydantic import BaseModel
 
-from rbx import console
+from rbx import console, utils
 from rbx.box import package
 from rbx.box.package import get_build_testgroup_path, get_build_tests_path
 from rbx.box.schema import Testcase, TestcaseGroup
@@ -141,8 +141,8 @@ def get_samples() -> List[Testcase]:
     tcs = find_built_testcases(package.get_testgroup('samples'))
     return [
         Testcase(
-            inputPath=tc.inputPath.resolve(),
-            outputPath=tc.outputPath.resolve()
+            inputPath=utils.abspath(tc.inputPath),
+            outputPath=utils.abspath(tc.outputPath)
             if tc.outputPath is not None and tc.outputPath.is_file()
             else None,
         )

rbx/config.py

@@ -90,6 +90,13 @@ def get_empty_app_persist_path() -> pathlib.Path:
     return app_dir
 
 
+def get_resources_file(path: pathlib.Path) -> pathlib.Path:
+    file_path = importlib.resources.files('rbx') / 'resources' / path  # type: ignore
+    if file_path.is_file():
+        return file_path
+    raise FileNotFoundError(f'File {path} not found in {_RESOURCES_PKG}.')
+
+
 def get_app_file(path: pathlib.Path) -> pathlib.Path:
     file_path = get_app_path() / path
     if file_path.is_file():

rbx/grading/caching.py

@@ -15,7 +15,12 @@ from rbx.grading.judge.cacher import FileCacher
 from rbx.grading.judge.digester import digest_cooperatively
 from rbx.grading.judge.storage import copyfileobj
 from rbx.grading.profiling import Profiler
-from rbx.grading.steps import DigestHolder, GradingArtifacts, GradingLogsHolder
+from rbx.grading.steps import (
+    DigestHolder,
+    GradingArtifacts,
+    GradingFileOutput,
+    GradingLogsHolder,
+)
 
 VERBOSE = False
 
@@ -109,10 +114,27 @@ def _build_fingerprint_list(
     return fingerprints
 
 
+def _maybe_check_integrity(output: GradingFileOutput):
+    if not grading_context.should_check_integrity():
+        return
+    if output.dest is None or not output.dest.is_symlink():
+        return
+    if output.digest is None or output.digest.value is None:
+        return
+    with output.dest.open('rb') as f:
+        fingerprint = digest_cooperatively(f)
+    if fingerprint != output.digest.value:
+        raise ValueError(
+            f'Cache was tampered with, file {output.dest} has changed since it was cached.\nPlease run `rbx clean` to reset the cache.'
+        )
+
+
 def _build_output_fingerprint_list(artifacts_list: List[GradingArtifacts]) -> List[str]:
     fingerprints = []
     for artifacts in artifacts_list:
         for output in artifacts.outputs:
+            if output.hash:
+                _maybe_check_integrity(output)
             if output.dest is None or output.intermediate or output.hash:
                 continue
             if not output.dest.is_file():
@@ -313,7 +335,7 @@ class DependencyCache:
         self.cacher = cacher
         self.db = shelve.open(self._cache_name())
         tmp_dir = pathlib.Path(tempfile.mkdtemp())
-        self.transient_db = shelve.open(tmp_dir / '.cache_db')
+        self.transient_db = shelve.open(str(tmp_dir / '.cache_db'))
         atexit.register(lambda: self.db.close())
         atexit.register(lambda: self.transient_db.close())
         atexit.register(lambda: shutil.rmtree(tmp_dir))

rbx/grading/conftest.py

@@ -28,6 +28,6 @@ def sandbox(request, file_cacher: FileCacher) -> Iterator[SandboxBase]:
 
 @pytest.fixture
 def dependency_cache(
-    request, cleandir: pathlib.Path, storage: Storage
+    request, cleandir: pathlib.Path, file_cacher: FileCacher
 ) -> Iterator[DependencyCache]:
-    yield DependencyCache(cleandir / '.box', storage)
+    yield DependencyCache(cleandir / '.box', file_cacher)

rbx/grading/grading_context.py

@@ -94,3 +94,28 @@ class compression(ConditionedContext):
         if self.use_compression_token is not None:
             use_compression_var.reset(self.use_compression_token)
         return None
+
+
+check_integrity_var = contextvars.ContextVar('check_integrity', default=True)
+
+
+def should_check_integrity() -> bool:
+    return check_integrity_var.get()
+
+
+class check_integrity(ConditionedContext):
+    def __init__(self, enabled: bool, when: Condition = True):
+        super().__init__(when)
+        self.enabled = enabled
+        self.token = None
+
+    def __enter__(self):
+        if not self.should_enter():
+            return self
+        self.token = check_integrity_var.set(self.enabled)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.token is not None:
+            check_integrity_var.reset(self.token)
+        return None

rbx/grading/judge/sandbox.py

@@ -16,6 +16,7 @@ from typing import IO, Any, Dict, List, Optional
 
 import pydantic
 
+from rbx import utils
 from rbx.grading.judge import cacher, storage
 
 logger = logging.getLogger(__name__)
@@ -468,7 +469,7 @@ class SandboxBase(abc.ABC):
         if override:
             real_path.unlink(missing_ok=True)
         try:
-            real_path.symlink_to(from_path.resolve())
+            real_path.symlink_to(utils.abspath(from_path))
         except NotImplementedError:
             return None
         return real_path

rbx/grading/judge/sandboxes/isolate.py

@@ -9,6 +9,7 @@ import subprocess
 import tempfile
 from typing import IO, Any, Dict, List, Optional
 
+from rbx import utils
 from rbx.config import get_app_path
 from rbx.grading.judge.cacher import FileCacher
 from rbx.grading.judge.sandbox import (
@@ -180,10 +181,10 @@ class IsolateSandbox(SandboxBase):
         """
         outer_paths: List[pathlib.Path] = []
         for inner_path in inner_paths:
-            abs_inner_path = (self._home_dest / inner_path).resolve()
+            abs_inner_path = utils.abspath(self._home_dest / inner_path)
             # If an inner path is absolute (e.g., /fifo0/u0_to_m) then
             # it may be outside home and we should ignore it.
-            if not abs_inner_path.is_relative_to(self._home_dest.resolve()):
+            if not abs_inner_path.is_relative_to(utils.abspath(self._home_dest)):
                 continue
             rel_inner_path = abs_inner_path.relative_to(self._home_dest)
             outer_path = self._home / rel_inner_path

rbx/grading/judge/sandboxes/stupid_sandbox.py

@@ -11,6 +11,7 @@ import sys
 import tempfile
 from typing import Any, Dict, List, Optional
 
+from rbx import utils
 from rbx.grading.judge.cacher import FileCacher
 from rbx.grading.judge.sandbox import (
     SandboxBase,
@@ -303,8 +304,8 @@ class StupidSandbox(SandboxBase):
         real_command = (
             [
                 sys.executable,
-                str(self.get_timeit_executable().resolve()),
-                str(self.relative_path(self.get_current_log_name()).resolve()),
+                str(utils.abspath(self.get_timeit_executable())),
+                str(utils.abspath(self.relative_path(self.get_current_log_name()))),
             ]
             + self.get_timeit_args()
             + command

rbx/grading/judge/storage.py

@@ -10,6 +10,7 @@ from typing import IO, AnyStr, Dict, List, Optional, Type, TypeVar
 import lz4.frame
 from pydantic import BaseModel
 
+from rbx import utils
 from rbx.grading import grading_context
 
 logger = logging.getLogger(__name__)
@@ -408,7 +409,7 @@ class FilesystemStorage(Storage):
     def filename_from_symlink(self, link: pathlib.Path) -> Optional[str]:
         if not link.is_symlink():
             return None
-        filename = link.readlink().resolve()
+        filename = utils.abspath(link.readlink())
         if not filename.is_file():
             return None
         return str(filename.relative_to(self.path))

rbx/grading/steps.py

@@ -523,7 +523,8 @@ def _get_system_bits_stdcpp(command: str) -> Optional[GradingFileInput]:
         if not bits_candidate.is_file():
             continue
         return GradingFileInput(
-            src=bits_candidate.resolve().absolute(), dest=pathlib.Path('bits/stdc++.h')
+            src=utils.abspath(bits_candidate),
+            dest=pathlib.Path('bits/stdc++.h'),
         )
     return None