rbx.cp 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

rbx/box/environment.py

@@ -40,102 +40,149 @@ VerificationParam = Annotated[
 class FileMapping(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
-    # Path where to copy the stdin file to before running the program,
-    # relative to the sandbox root.
-    input: str = 'stdin'
+    input: str = Field(
+        default='stdin',
+        description="""Path where to copy the stdin file to before running the program,
+relative to the sandbox root.""",
+    )
 
-    # Path where to output the stdout file after running the program,
-    # relative to the sandbox root.
-    output: str = 'stdout'
+    output: str = Field(
+        default='stdout',
+        description="""Path where to output the stdout file after running the program,
+relative to the sandbox root.""",
+    )
 
-    # Path where to output the stderr file after running the program,
-    # relative to the sandbox root.
-    error: str = 'stderr'
+    error: str = Field(
+        default='stderr',
+        description="""Path where to output the stderr file after running the program,
+relative to the sandbox root.""",
+    )
 
-    # Path where to copy the compilable file to before compiling the program,
-    # relative to the sandbox root.
-    compilable: str = 'compilable'
+    compilable: str = Field(
+        default='compilable',
+        description="""Path where to copy the compilable file to before compiling the program,
+relative to the sandbox root.""",
+    )
 
-    # Path to where to output the executable file after compiling the program,
-    # relative to the sandbox root.
-    executable: str = 'executable'
+    executable: str = Field(
+        default='executable',
+        description="""Path to where to output the executable file after compiling the program,
+relative to the sandbox root.""",
+    )
 
 
 class EnvironmentSandbox(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
-    # Max. number of process to allow to run concurrently for the program.
-    maxProcesses: Optional[int] = 1
+    maxProcesses: Optional[int] = Field(
+        default=1,
+        description="""Max. number of process to allow to run concurrently for the program.""",
+    )
 
-    # Time limit in milliseconds to allow the program to run.
-    timeLimit: Optional[int] = None
+    timeLimit: Optional[int] = Field(
+        default=None,
+        description="""Time limit in milliseconds to allow the program to run.""",
+    )
 
-    # Wall time limit in milliseconds to allow the program to run.
-    wallTimeLimit: Optional[int] = None
+    wallTimeLimit: Optional[int] = Field(
+        default=None,
+        description="""Wall time limit in milliseconds to allow the program to run.""",
+    )
 
-    # Memory limit in MiB.
-    memoryLimit: Optional[int] = None
+    memoryLimit: Optional[int] = Field(
+        default=None,
+        description="""Memory limit in MiB.""",
+    )
 
-    # File size limit in KiB
-    fileSizeLimit: Optional[int] = None
+    fileSizeLimit: Optional[int] = Field(
+        default=None,
+        description="""File size limit in KiB""",
+    )
 
-    # Stack limit in MiB.
-    stackLimit: Optional[int] = None
+    stackLimit: Optional[int] = Field(
+        default=None,
+        description="""Stack limit in MiB.""",
+    )
 
-    # Whether to preserve env. variables coming from the host.
-    preserveEnv: Optional[bool] = False
+    preserveEnv: Optional[bool] = Field(
+        default=False,
+        description="""Whether to preserve env. variables coming from the host.""",
+    )
 
-    # Directories in the host that should be read-only exposed to the sandbox.
-    mirrorDirs: Optional[List[str]] = []
+    mirrorDirs: Optional[List[str]] = Field(
+        default=[],
+        description="""Directories in the host that should be read-only exposed to the sandbox.""",
+    )
 
 
 class CompilationConfig(BaseModel):
-    # Commands to compile the program.
-    commands: Optional[List[str]] = []
+    commands: Optional[List[str]] = Field(
+        default=[],
+        description="""Commands to compile the program.""",
+    )
 
-    # Sandbox configuration to use when compiling for this language.
-    sandbox: Optional[EnvironmentSandbox] = None
+    sandbox: Optional[EnvironmentSandbox] = Field(
+        default=None,
+        description="""Sandbox configuration to use when compiling for this language.""",
+    )
 
 
 class ExecutionConfig(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
-    # Command to run the program.
-    command: Optional[str] = None
+    command: Optional[str] = Field(
+        default=None,
+        description="""Command to run the program.""",
+    )
 
-    # Sandbox configuration to use when executing for this language.
-    sandbox: Optional[EnvironmentSandbox] = None
+    sandbox: Optional[EnvironmentSandbox] = Field(
+        default=None,
+        description="""Sandbox configuration to use when executing for this language.""",
+    )
 
-    # Original limits of the problem.
-    problemLimits: Limits = Field(default_factory=Limits)
+    problemLimits: Limits = Field(
+        default_factory=Limits,
+        description="""Original limits of the problem.""",
+    )
 
 
 class EnvironmentLanguage(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
-    # Identifier of this language within this environment.
-    name: str
+    name: str = Field(
+        description="""Identifier of this language within this environment."""
+    )
 
-    # Readable name for this language.
-    readable_name: Optional[str] = None
+    readableName: Optional[str] = Field(
+        default=None,
+        description="""Readable name for this language.""",
+    )
 
-    # File extension supported by this language. If there's only one language
-    # that supports a certain file extension in the environment, the tool
-    # will automatically identify the language based on such extension.
-    extension: str
+    extension: str = Field(
+        description="""File extension supported by this language. If there's only one language
+that supports a certain file extension in the environment, the tool
+will automatically identify the language based on such extension."""
+    )
 
-    # Compilation config to use when compiling programs for this language.
-    compilation: Optional[CompilationConfig] = None
+    compilation: Optional[CompilationConfig] = Field(
+        default=None,
+        description="""Compilation config to use when compiling programs for this language.""",
+    )
 
-    # Execution config to use when running programs for this language.
-    execution: ExecutionConfig
+    execution: ExecutionConfig = Field(
+        description="""Execution config to use when running programs for this language."""
+    )
 
-    # Mapping for files within the sandbox. If not specified, the default mapping
-    # for the environment will be used.
-    fileMapping: Optional[FileMapping] = None
+    fileMapping: Optional[FileMapping] = Field(
+        default=None,
+        description="""Mapping for files within the sandbox. If not specified, the default mapping
+for the environment will be used.""",
+    )
 
-    # Exntensions to apply for this language.
-    extensions: Optional[LanguageExtensions] = None
+    extensions: Optional[LanguageExtensions] = Field(
+        default=None,
+        description="""Extensions to apply for this language.""",
+    )
 
     def get_extension(self, name: str, _: Type[T]) -> Optional[T]:
         if self.extensions is None:
@@ -151,39 +198,52 @@ class EnvironmentLanguage(BaseModel):
 class TimingConfig(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
-    # Formula to use to calculate the time limit for the environment.
-    formula: str = 'step_up(max(fastest * 3, slowest * 1.5), 100)'
+    formula: str = Field(
+        default='step_up(max(fastest * 3, slowest * 1.5), 100)',
+        description="""Formula to use to calculate the time limit for the environment.""",
+    )
 
 
 class Environment(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
-    # Default mapping for files within the sandbox. Fields in the mapping can be
-    # individually overridden in the language configuration.
-    defaultFileMapping: Optional[FileMapping] = None
-
-    # Default compilation configuration to use when compiling programs. Fields in
-    # the compilation config can be individually overridden in the language configuration.
-    defaultCompilation: Optional[CompilationConfig] = None
+    defaultFileMapping: Optional[FileMapping] = Field(
+        default=None,
+        description="""Default mapping for files within the sandbox. Fields in the mapping can be
+individually overridden in the language configuration.""",
+    )
 
-    # Default execution configuration to use when running programs. Fields in the
-    # execution config can be individually overridden in the language configuration.
-    defaultExecution: Optional[ExecutionConfig] = None
+    defaultCompilation: Optional[CompilationConfig] = Field(
+        default=None,
+        description="""Default compilation configuration to use when compiling programs. Fields in
+the compilation config can be individually overridden in the language configuration.""",
+    )
 
-    # Configuration for each language supported in this environment.
-    languages: List[EnvironmentLanguage] = []
+    defaultExecution: Optional[ExecutionConfig] = Field(
+        default=None,
+        description="""Default execution configuration to use when running programs. Fields in the
+execution config can be individually overridden in the language configuration.""",
+    )
 
-    # Identifier of the sandbox used by this environment (e.g. "stupid", "isolate")
-    sandbox: str = 'stupid'
+    languages: List[EnvironmentLanguage] = Field(
+        default=[],
+        description="""Configuration for each language supported in this environment.""",
+    )
 
-    # Identifier of the preset that should be used when creating new problems.
-    preset: str = 'default'
+    sandbox: str = Field(
+        default='stupid',
+        description="""Identifier of the sandbox used by this environment (e.g. "stupid", "isolate")""",
+    )
 
-    # Timing configuration for the environment.
-    timing: TimingConfig = Field(default_factory=TimingConfig)
+    timing: TimingConfig = Field(
+        default_factory=TimingConfig,
+        description="""Timing configuration for the environment.""",
+    )
 
-    # Extensions to be added to the environment.
-    extensions: Optional[Extensions] = None
+    extensions: Optional[Extensions] = Field(
+        default=None,
+        description="""Extensions to be added to the environment.""",
+    )
 
 
 def get_app_environment_path(env: str) -> pathlib.Path:

rbx/box/formatting.py

@@ -2,6 +2,7 @@ import os
 import pathlib
 from typing import Any, Optional
 
+from rbx import utils
 from rbx.box import setter_config
 
 
@@ -23,7 +24,7 @@ def href(url: os.PathLike[str], text: Optional[str] = None, style: str = 'item')
             return f'[{style}]{text}[/{style}]'
 
     if isinstance(url, pathlib.Path):
-        url = url.resolve()
+        url = utils.abspath(url)
 
     url_str = str(url)
     if pathlib.Path(url_str).exists():

rbx/box/global_package.py

@@ -0,0 +1,74 @@
+import functools
+import pathlib
+import shutil
+
+from rbx.config import get_app_path
+from rbx.grading.caching import DependencyCache
+from rbx.grading.judge.cacher import FileCacher
+from rbx.grading.judge.sandbox import SandboxBase
+from rbx.grading.judge.sandboxes.stupid_sandbox import StupidSandbox
+from rbx.grading.judge.storage import FilesystemStorage, Storage
+
+CACHE_STEP_VERSION = 3
+
+
+def get_cache_fingerprint() -> str:
+    return f'{CACHE_STEP_VERSION}'
+
+
+@functools.cache
+def is_cache_valid(cache_dir: pathlib.Path) -> bool:
+    if not cache_dir.is_dir():
+        return True
+    fingerprint_file = cache_dir / 'fingerprint'
+    if not fingerprint_file.is_file():
+        return False
+    fingerprint = fingerprint_file.read_text()
+    if fingerprint.strip() != get_cache_fingerprint():
+        return False
+    return True
+
+
+@functools.cache
+def get_global_cache_dir() -> pathlib.Path:
+    cache_dir = get_app_path() / '.box'
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    fingerprint_file = cache_dir / 'fingerprint'
+    if not fingerprint_file.is_file():
+        fingerprint_file.write_text(get_cache_fingerprint())
+    return cache_dir
+
+
+def is_global_cache_valid() -> bool:
+    return is_cache_valid(get_global_cache_dir())
+
+
+@functools.cache
+def get_global_storage_dir() -> pathlib.Path:
+    storage_dir = get_global_cache_dir() / '.storage'
+    storage_dir.mkdir(parents=True, exist_ok=True)
+    return storage_dir
+
+
+@functools.cache
+def get_global_cache_storage() -> Storage:
+    return FilesystemStorage(get_global_storage_dir())
+
+
+@functools.cache
+def get_global_file_cacher() -> FileCacher:
+    return FileCacher(get_global_cache_storage())
+
+
+@functools.cache
+def get_global_dependency_cache() -> DependencyCache:
+    return DependencyCache(get_global_cache_dir(), get_global_file_cacher())
+
+
+@functools.cache
+def get_global_sandbox() -> SandboxBase:
+    return StupidSandbox(get_global_file_cacher())
+
+
+def clear_global_cache():
+    shutil.rmtree(get_global_cache_dir(), ignore_errors=True)

rbx/box/package.py

@@ -11,8 +11,9 @@ import typer
 from pydantic import ValidationError
 
 from rbx import console, utils
-from rbx.box import cd
+from rbx.box import cd, global_package
 from rbx.box.environment import get_sandbox_type
+from rbx.box.global_package import get_cache_fingerprint
 from rbx.box.schema import (
     CodeItem,
     ExpectedOutcome,
@@ -34,12 +35,11 @@ YAML_NAME = 'problem.rbx.yml'
 _DEFAULT_CHECKER = 'wcmp.cpp'
 _NOOP_CHECKER = 'noop.cpp'
 TEMP_DIR = None
-CACHE_STEP_VERSION = 1
 
 
 @functools.cache
 def find_problem_yaml(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Path]:
-    root = root.resolve()
+    root = utils.abspath(root)
     problem_yaml_path = root / YAML_NAME
     while root != pathlib.PosixPath('/') and not problem_yaml_path.is_file():
         root = root.parent
@@ -107,17 +107,13 @@ def get_ruyaml(root: pathlib.Path = pathlib.Path()) -> Tuple[ruyaml.YAML, ruyaml
     return res, res.load(problem_yaml_path.read_text())
 
 
-def _get_fingerprint() -> str:
-    return f'{CACHE_STEP_VERSION}'
-
-
 @functools.cache
 def get_problem_cache_dir(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
     cache_dir = find_problem(root) / '.box'
     cache_dir.mkdir(parents=True, exist_ok=True)
     fingerprint_file = cache_dir / 'fingerprint'
     if not fingerprint_file.is_file():
-        fingerprint_file.write_text(_get_fingerprint())
+        fingerprint_file.write_text(get_cache_fingerprint())
     return cache_dir
 
 
@@ -156,8 +152,8 @@ def get_problem_iruns_dir(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
 def get_problem_preprocessed_path(
     item: pathlib.Path, root: pathlib.Path = pathlib.Path()
 ) -> pathlib.Path:
-    root_resolved = root.resolve()
-    item_resolved = item.resolve()
+    root_resolved = utils.abspath(root)
+    item_resolved = utils.abspath(item)
 
     if not item_resolved.is_relative_to(root_resolved):
         final_path = pathlib.Path('remote') / item_resolved.name
@@ -170,12 +166,12 @@ def get_problem_preprocessed_path(
 
 @functools.cache
 def get_cache_storage(root: pathlib.Path = pathlib.Path()) -> Storage:
-    return FilesystemStorage(get_problem_storage_dir(root))
+    return FilesystemStorage(get_problem_storage_dir(root), compress=False)
 
 
 @functools.cache
 def get_dependency_cache(root: pathlib.Path = pathlib.Path()) -> DependencyCache:
-    return DependencyCache(get_problem_cache_dir(root), get_cache_storage(root))
+    return DependencyCache(get_problem_cache_dir(root), get_file_cacher(root))
 
 
 @functools.cache
@@ -364,11 +360,11 @@ def get_test_groups_by_name(
 # Return each compilation file and to where it should be moved inside
 # the sandbox.
 def get_compilation_files(code: CodeItem) -> List[Tuple[pathlib.Path, pathlib.Path]]:
-    code_dir = code.path.parent.resolve()
+    code_dir = utils.abspath(code.path.parent)
 
     res = []
     for compilation_file in code.compilationFiles or []:
-        compilation_file_path = pathlib.Path(compilation_file).resolve()
+        compilation_file_path = utils.abspath(pathlib.Path(compilation_file))
         if not compilation_file_path.is_file():
             console.console.print(
                 f'[error]Compilation file [item]{compilation_file}[/item] for '
@@ -427,16 +423,7 @@ def get_merged_capture_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path
 @functools.cache
 def is_cache_valid(root: pathlib.Path = pathlib.Path()):
     cache_dir = find_problem(root) / '.box'
-    if not cache_dir.is_dir():
-        return True
-
-    fingerprint_file = cache_dir / 'fingerprint'
-    if not fingerprint_file.is_file():
-        return False
-    fingerprint = fingerprint_file.read_text()
-    if fingerprint.strip() != _get_fingerprint():
-        return False
-    return True
+    return global_package.is_cache_valid(cache_dir)
 
 
 def clear_package_cache():

rbx/box/packaging/polygon/packager.py

@@ -4,7 +4,7 @@ from typing import List, Optional
 
 import typer
 
-from rbx import console
+from rbx import console, utils
 from rbx.box import header, package
 from rbx.box.lang import code_to_langs, is_valid_lang_code
 from rbx.box.packaging.packager import (
@@ -129,7 +129,7 @@ class PolygonPackager(BasePackager):
         shutil.copyfile(built_statement.path, final_path)
 
         return polygon_schema.Statement(
-            path=str(final_path.resolve().relative_to(into_path.resolve())),
+            path=str(utils.abspath(final_path).relative_to(utils.abspath(into_path))),
             language=language,
             type=self._statement_application_type(built_statement),  # type: ignore
         )
@@ -238,7 +238,7 @@ class PolygonContestPackager(BaseContestPackager):
         shutil.copyfile(built_statement.path, final_path)
 
         return polygon_schema.Statement(
-            path=str(final_path.resolve().relative_to(into_path.resolve())),
+            path=str(utils.abspath(final_path).relative_to(utils.abspath(into_path))),
             language=language,
             type='application/pdf',  # type: ignore
         )