rbx.cp 0.9.0__tar.gz → 0.9.2__tar.gz

{rbx_cp-0.9.0 → rbx_cp-0.9.2}/PKG-INFO

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

{rbx_cp-0.9.0 → rbx_cp-0.9.2}/pyproject.toml

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

{rbx_cp-0.9.0 → rbx_cp-0.9.2}/rbx/box/cli.py

@@ -159,6 +159,9 @@ def main(
     state.STATE.debug_logs = capture
 
     grading_context.cache_level_var.set(grading_context.CacheLevel(cache))
+    grading_context.check_integrity_var.set(
+        setter_config.get_setter_config().caching.check_integrity
+    )
 
     if profile:
         from rbx.grading import profiling

{rbx_cp-0.9.0 → rbx_cp-0.9.2}/rbx/box/environment.py

@@ -247,13 +247,13 @@ execution config can be individually overridden in the language configuration.""
 
 
 def get_app_environment_path(env: str) -> pathlib.Path:
-    return config.get_app_file(pathlib.PosixPath('envs') / f'{env}.rbx.yml')
+    return config.get_resources_file(pathlib.PosixPath('envs') / f'{env}.rbx.yml')
 
 
 def get_active_environment_path() -> pathlib.Path:
     env_path = presets.get_preset_environment_path()
     if env_path is None:
-        env_path = get_app_environment_path(config.get_config().boxEnvironment)
+        env_path = get_app_environment_path('default')
     return env_path
 
 
@@ -261,7 +261,7 @@ def get_active_environment_path() -> pathlib.Path:
 def get_active_environment_description() -> str:
     env_path = presets.get_preset_environment_path()
     if env_path is None:
-        return config.get_config().boxEnvironment
+        return 'default'
     preset = presets.get_active_preset()
     return f'preset - {preset.name}'
 

{rbx_cp-0.9.0 → rbx_cp-0.9.2}/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_cp-0.9.0 → rbx_cp-0.9.2}/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_cp-0.9.0 → rbx_cp-0.9.2}/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_cp-0.9.0 → rbx_cp-0.9.2}/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_cp-0.9.0 → rbx_cp-0.9.2}/rbx/grading/grading_context.py

@@ -1,7 +1,8 @@
 import contextvars
-from enum import Enum
 from typing import Callable, Optional, Union
 
+from rbx.autoenum import AutoEnum, alias
+
 Condition = Union[bool, Callable[[], bool]]
 
 
@@ -15,11 +16,11 @@ class ConditionedContext:
         return self.when()
 
 
-class CacheLevel(Enum):
-    NO_CACHE = 0
-    CACHE_TRANSIENTLY = 1
-    CACHE_COMPILATION = 2
-    CACHE_ALL = 3
+class CacheLevel(AutoEnum):
+    NO_CACHE = alias('none')
+    CACHE_TRANSIENTLY = alias('transient')
+    CACHE_COMPILATION = alias('compilation')
+    CACHE_ALL = alias('all')
 
 
 cache_level_var = contextvars.ContextVar('cache_level', default=CacheLevel.CACHE_ALL)
@@ -30,11 +31,11 @@ def is_compilation_only() -> bool:
 
 
 def is_transient() -> bool:
-    return cache_level_var.get().value <= CacheLevel.CACHE_TRANSIENTLY.value
+    return cache_level_var.get() == CacheLevel.CACHE_TRANSIENTLY or is_no_cache()
 
 
 def is_no_cache() -> bool:
-    return cache_level_var.get().value <= CacheLevel.NO_CACHE.value
+    return cache_level_var.get() == CacheLevel.NO_CACHE
 
 
 class cache_level(ConditionedContext):
@@ -94,3 +95,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_cp-0.9.0 → rbx_cp-0.9.2}/rbx/grading/steps_with_caching_run_test.py

@@ -2,9 +2,12 @@ import os
 import pathlib
 import sys
 
-from rbx.grading import steps_with_caching
+import pytest
+
+from rbx.grading import grading_context, steps_with_caching
 from rbx.grading.caching import DependencyCache
 from rbx.grading.judge.cacher import FileCacher
+from rbx.grading.judge.digester import digest_cooperatively
 from rbx.grading.judge.sandbox import SandboxBase, SandboxParams
 from rbx.grading.steps import (
     DigestOrSource,
@@ -74,6 +77,124 @@ async def test_run_from_disk(
     assert not artifacts.logs.cached
 
 
+async def test_run_reruns_if_cache_disabled(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+    file_cacher: FileCacher,
+):
+    async def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+        executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=dest)
+        )
+        with grading_context.cache_level(grading_context.CacheLevel.NO_CACHE):
+            await steps_with_caching.run(
+                f'{sys.executable} executable.py',
+                params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+                sandbox=sandbox,
+                artifacts=artifacts,
+                dependency_cache=dependency_cache,
+            )
+        return artifacts
+
+    artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+
+    another_artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert another_artifacts.logs is not None
+    assert not another_artifacts.logs.cached
+
+
+async def test_run_reruns_if_first_run_cache_disabled(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+    file_cacher: FileCacher,
+):
+    async def configure_and_run_with_dest(
+        dest: pathlib.Path, cache: bool = True
+    ) -> GradingArtifacts:
+        executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=dest)
+        )
+        with grading_context.cache_level(
+            grading_context.CacheLevel.NO_CACHE, when=cache
+        ):
+            await steps_with_caching.run(
+                f'{sys.executable} executable.py',
+                params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+                sandbox=sandbox,
+                artifacts=artifacts,
+                dependency_cache=dependency_cache,
+            )
+        return artifacts
+
+    artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'), cache=False)
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+
+    another_artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert another_artifacts.logs is not None
+    assert not another_artifacts.logs.cached
+
+
+async def test_run_reruns_if_second_run_cache_disabled(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+    file_cacher: FileCacher,
+):
+    async def configure_and_run_with_dest(
+        dest: pathlib.Path, cache: bool = True
+    ) -> GradingArtifacts:
+        executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=dest)
+        )
+        with grading_context.cache_level(
+            grading_context.CacheLevel.NO_CACHE, when=cache
+        ):
+            await steps_with_caching.run(
+                f'{sys.executable} executable.py',
+                params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+                sandbox=sandbox,
+                artifacts=artifacts,
+                dependency_cache=dependency_cache,
+            )
+        return artifacts
+
+    artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+
+    another_artifacts = await configure_and_run_with_dest(
+        pathlib.Path('out.txt'), cache=False
+    )
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert another_artifacts.logs is not None
+    assert not another_artifacts.logs.cached
+
+
 async def test_run_caches_intermediate_digest_if_dest_changes(
     cleandir: pathlib.Path,
     dependency_cache: DependencyCache,
@@ -106,12 +227,127 @@ async def test_run_caches_intermediate_digest_if_dest_changes(
     another_artifacts = await configure_and_run_with_dest(
         pathlib.Path('another-out.txt')
     )
+    assert (cleandir / 'another-out.txt').read_text().strip() == '5'
+    assert another_artifacts.logs is not None
+    assert another_artifacts.logs.cached
+
+
+async def test_run_caches_intermediate_digest_if_dest_changes_and_cache_transient(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+    file_cacher: FileCacher,
+):
+    async def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+        executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=dest)
+        )
+
+        with grading_context.cache_level(grading_context.CacheLevel.CACHE_TRANSIENTLY):
+            await steps_with_caching.run(
+                f'{sys.executable} executable.py',
+                params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+                sandbox=sandbox,
+                artifacts=artifacts,
+                dependency_cache=dependency_cache,
+            )
+        return artifacts
+
+    artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+
+    another_artifacts = await configure_and_run_with_dest(
+        pathlib.Path('another-out.txt')
+    )
+    assert (cleandir / 'another-out.txt').read_text().strip() == '5'
+    assert another_artifacts.logs is not None
+    assert another_artifacts.logs.cached
+
+
+async def test_run_overwrites_changed_file_when_storage_value_is_changed_and_cache_transient(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+    file_cacher: FileCacher,
+):
+    async def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+        executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=dest)
+        )
+        with grading_context.cache_level(grading_context.CacheLevel.CACHE_TRANSIENTLY):
+            await steps_with_caching.run(
+                f'{sys.executable} executable.py',
+                params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+                sandbox=sandbox,
+                artifacts=artifacts,
+                dependency_cache=dependency_cache,
+            )
+        return artifacts
+
+    artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+
+    pathlib.Path('out.txt').write_text('42')
+
+    another_artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert another_artifacts.logs is not None
+    assert another_artifacts.logs.cached
+
+
+async def test_run_overwrites_changed_file_when_file_deleted_and_cache_transient(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+    file_cacher: FileCacher,
+):
+    async def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+        executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=dest)
+        )
+        with grading_context.cache_level(grading_context.CacheLevel.CACHE_TRANSIENTLY):
+            await steps_with_caching.run(
+                f'{sys.executable} executable.py',
+                params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+                sandbox=sandbox,
+                artifacts=artifacts,
+                dependency_cache=dependency_cache,
+            )
+        return artifacts
+
+    artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+
+    pathlib.Path('out.txt').unlink()
+
+    another_artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert another_artifacts.logs is not None
     assert another_artifacts.logs.cached
 
 
-async def test_run_overwrite_changed_file_with_storage_value(
+async def test_run_fails_when_storage_value_is_changed_and_integrity_check_is_enabled(
     cleandir: pathlib.Path,
     dependency_cache: DependencyCache,
     sandbox: SandboxBase,
@@ -142,13 +378,50 @@ async def test_run_overwrite_changed_file_with_storage_value(
 
     pathlib.Path('out.txt').write_text('42')
 
+    with pytest.raises(ValueError) as exc_info:
+        await configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert 'rbx clean' in str(exc_info.value)
+    assert (cleandir / 'out.txt').read_text().strip() == '42'
+
+
+async def test_run_evicts_and_recreates_deleted_file_with_storage_value(
+    cleandir: pathlib.Path,
+    dependency_cache: DependencyCache,
+    sandbox: SandboxBase,
+    file_cacher: FileCacher,
+):
+    async def configure_and_run_with_dest(dest: pathlib.Path) -> GradingArtifacts:
+        executable = DigestOrSource.create(file_cacher.put_file_text('print(5)'))
+        artifacts = GradingArtifacts()
+        artifacts.inputs.append(
+            GradingFileInput(**executable.expand(), dest=pathlib.Path('executable.py'))
+        )
+        artifacts.outputs.append(
+            GradingFileOutput(src=pathlib.Path('box-out.txt'), dest=dest)
+        )
+        await steps_with_caching.run(
+            f'{sys.executable} executable.py',
+            params=SandboxParams(stdout_file=pathlib.Path('box-out.txt')),
+            sandbox=sandbox,
+            artifacts=artifacts,
+            dependency_cache=dependency_cache,
+        )
+        return artifacts
+
+    artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
+    assert (cleandir / 'out.txt').read_text().strip() == '5'
+    assert artifacts.logs is not None
+    assert not artifacts.logs.cached
+
+    pathlib.Path('out.txt').unlink()
+
     another_artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert another_artifacts.logs is not None
     assert another_artifacts.logs.cached
 
 
-async def test_run_recreates_deleted_file_with_storage_value(
+async def test_run_evicts_when_storage_value_deleted(
     cleandir: pathlib.Path,
     dependency_cache: DependencyCache,
     sandbox: SandboxBase,
@@ -177,12 +450,15 @@ async def test_run_recreates_deleted_file_with_storage_value(
     assert artifacts.logs is not None
     assert not artifacts.logs.cached
 
-    pathlib.Path('out.txt').unlink()
+    # Delete the file from the cache
+    with pathlib.Path('out.txt').open('rb') as f:
+        digest = digest_cooperatively(f)
+    file_cacher.delete(digest)
 
     another_artifacts = await configure_and_run_with_dest(pathlib.Path('out.txt'))
     assert (cleandir / 'out.txt').read_text().strip() == '5'
     assert another_artifacts.logs is not None
-    assert another_artifacts.logs.cached
+    assert not another_artifacts.logs.cached
 
 
 async def test_run_overwrite_exec_bit_when_changed(

{rbx_cp-0.9.0 → rbx_cp-0.9.2}/rbx/resources/default_setter_config.mac.yml

@@ -14,6 +14,21 @@ command_substitutions:
   python2: python2
   python3: python3
 
+caching:
+  # Set the caching level.
+  #
+  # CACHE_ALL: Cache everything.
+  # CACHE_COMPILATION: Cache only compilation.
+  # NO_CACHE: Do not cache anything.
+  level: CACHE_ALL
+
+  # Whether to check the integrity of the cached result, and evict it
+  # if file has changed since it was cached.
+  #
+  # Disable for more performance, but be careful to not modify any generated
+  # files.
+  check_integrity: true
+
 repeats:
   # Number of times to run the solution.
   reps: 1

{rbx_cp-0.9.0 → rbx_cp-0.9.2}/rbx/resources/default_setter_config.yml

@@ -14,6 +14,21 @@ command_substitutions:
   python2: python2
   python3: python3
 
+caching:
+  # Set the caching level.
+  #
+  # CACHE_ALL: Cache everything.
+  # CACHE_COMPILATION: Cache only compilation.
+  # NO_CACHE: Do not cache anything.
+  level: CACHE_ALL
+
+  # Whether to check the integrity of the cached result, and evict it
+  # if file has changed since it was cached.
+  #
+  # Disable for more performance, but be careful to not modify any generated
+  # files.
+  check_integrity: true
+
 repeats:
   # Number of times to run the solution.
   reps: 1

rbx_cp-0.9.2/rbx/resources/presets/default/env.rbx.yml

@@ -0,0 +1,67 @@
+---
+sandbox: "stupid"
+defaultCompilation:
+  sandbox:
+    maxProcesses: 1000
+    timeLimit: 50000 # 50 seconds
+    wallTimeLimit: 50000 # 50 seconds
+    memoryLimit: 1024 # 1gb
+defaultExecution:
+  sandbox:
+    # Useful for checkers, validators, etc.
+    timeLimit: 50000 # 50 seconds
+    wallTimeLimit: 50000 # 50 seconds
+    memoryLimit: 1024 # 1gb
+languages:
+  - name: "cpp"
+    readableName: "C++20"
+    extension: "cpp"
+    compilation:
+      commands: ["g++ -std=c++20 -O2 -o {executable} {compilable}"]
+    execution:
+      command: "./{executable}"
+    fileMapping:
+      compilable: "compilable.cpp"
+    extensions:
+      boca:
+        bocaLanguage: "cc"
+  - name: "c"
+    readableName: "C"
+    extension: "c"
+    compilation:
+      commands: ["gcc -std=gnu11 -O2 -lm -o {executable} {compilable}"]
+    execution:
+      command: "./{executable}"
+    fileMapping:
+      compilable: "compilable.c"
+  - name: "py"
+    readableName: "Python3"
+    extension: "py"
+    execution:
+      command: "python3 {executable}"
+    fileMapping:
+      executable: "executable.py"
+    extensions:
+      boca:
+        bocaLanguage: "py3"
+  - name: "java"
+    readableName: "Java"
+    extension: "java"
+    compilation:
+      commands:
+        - "javac -Xlint -encoding UTF-8 {compilable}"
+        - "jar cvf {executable} @glob:*.class"
+    execution:
+      command:
+        "java -Xss100m -Xmx{{memory}}m -Xms{{initialMemory}}m -cp {executable}
+        Main"
+    fileMapping:
+      compilable: "Main.java"
+      executable: "Main.jar"
+extensions:
+  boca:
+    languages: ["c", "cc", "java", "py3"]
+    flags:
+      c: "-O2 -lm -static"
+      cc: "-std=c++20 -O2 -lm -static"
+    preferContestLetter: true