rbx.cp 0.5.61__py3-none-any.whl → 0.5.62__py3-none-any.whl

rbx/box/cd.py

@@ -25,6 +25,20 @@ def find_package(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Path]:
     return root
 
 
+def is_problem_package(root: pathlib.Path = pathlib.Path()) -> bool:
+    dir = find_package(root)
+    if dir is None:
+        return False
+    return (dir / 'problem.rbx.yml').is_file()
+
+
+def is_contest_package(root: pathlib.Path = pathlib.Path()) -> bool:
+    dir = find_package(root)
+    if dir is None:
+        return False
+    return (dir / 'contest.rbx.yml').is_file()
+
+
 def within_closest_package(func):
     @functools.wraps(func)
     def wrapper(*args, **kwargs):

rbx/box/cli.py

@@ -112,6 +112,12 @@ def main(
         help='Whether to save extra debug logs along with the evaluation results.',
     ),
 ):
+    if cd.is_problem_package() and not package.is_cache_valid():
+        console.console.print(
+            '[warning]Cache is incompatible with the current version of [item]rbx[/item], so it will be cleared.[/warning]'
+        )
+        clear()
+
     state.STATE.run_through_cli = True
     state.STATE.sanitized = sanitized
     if sanitized:

rbx/box/code.py

@@ -155,6 +155,34 @@ def _ignore_warning_in_cxx_input(input: GradingFileInput):
     input.src = preprocessed_path
 
 
+def _maybe_rename_java_class(
+    compilable_path: pathlib.Path, file_mapping: FileMapping
+) -> pathlib.Path:
+    mapped_path = PosixPath(file_mapping.compilable)
+    if mapped_path.suffix != '.java':
+        return compilable_path
+    import re
+
+    cls_name = mapped_path.stem
+
+    java_content = compilable_path.read_text()
+    regex = re.compile(r'public\s+class\s+[A-Za-z0-9_$]+([^A-Za-z0-9_$])')
+    match = regex.search(java_content)
+    if match is None:
+        console.console.print(
+            f'[error]Java public class not found in file: [item]{compilable_path}[/item][/error]'
+        )
+        raise typer.Exit(1)
+
+    new_content = regex.sub(f'public class {cls_name}\\1', java_content)
+    if new_content == java_content:
+        return compilable_path
+
+    preprocessed_path = package.get_problem_preprocessed_path(compilable_path)
+    preprocessed_path.write_text(new_content)
+    return preprocessed_path
+
+
 def _format_stack_limit(limit: int) -> str:
     if limit == resource.RLIM_INFINITY:
         return 'unlimited'
@@ -372,11 +400,11 @@ def compile_item(
 ) -> str:
     _check_stack_limit()
 
-    generator_path = PosixPath(code.path)
+    compilable_path = PosixPath(code.path)
 
-    if not generator_path.is_file():
+    if not compilable_path.is_file():
         console.console.print(
-            f'[error]Compilation file not found: [item]{generator_path}[/item][/error]'
+            f'[error]Compilation file not found: [item]{compilable_path}[/item][/error]'
         )
         raise typer.Exit(1)
 
@@ -389,7 +417,7 @@ def compile_item(
 
     if not compilation_options.commands:
         # Language is not compiled.
-        return sandbox.file_cacher.put_file_from_path(generator_path)
+        return sandbox.file_cacher.put_file_from_path(compilable_path)
 
     commands = get_mapped_commands(compilation_options.commands, file_mapping)
     commands = add_warning_flags(commands, force_warnings)
@@ -417,8 +445,9 @@ def compile_item(
     download.maybe_add_testlib(code, artifacts)
     download.maybe_add_jngen(code, artifacts)
     download.maybe_add_rbx_header(code, artifacts)
+    compilable_path = _maybe_rename_java_class(compilable_path, file_mapping)
     artifacts.inputs.append(
-        GradingFileInput(src=generator_path, dest=PosixPath(file_mapping.compilable))
+        GradingFileInput(src=compilable_path, dest=PosixPath(file_mapping.compilable))
     )
 
     artifacts.outputs.append(

rbx/box/contest/main.py

@@ -63,8 +63,10 @@ def create(
         )
         raise typer.Exit(1)
 
-    if fetch_info.fetch_uri is not None:
+    if fetch_info.is_remote():
         preset = presets.install_from_remote(fetch_info)
+    elif fetch_info.is_local_dir():
+        preset = presets.install_from_local_dir(fetch_info)
 
     preset_cfg = presets.get_installed_preset(preset)
     preset_path = (
@@ -108,7 +110,9 @@ def create(
         lock.unlink(missing_ok=True)
 
     if local:
-        shutil.copytree(str(preset_path), str(dest_path / '.local.rbx'))
+        presets.copy_local_preset(
+            preset_path, dest_path, remote_uri=fetch_info.uri or preset_cfg.uri
+        )
 
     with cd.new_package_cd(dest_path):
         contest_utils.clear_all_caches()

rbx/box/git_utils.py

@@ -0,0 +1,28 @@
+import pathlib
+from typing import Optional
+
+import git
+
+
+def get_repo_or_nil(
+    root: pathlib.Path = pathlib.Path(), search_parent_directories: bool = False
+) -> Optional[git.Repo]:
+    try:
+        return git.Repo(root, search_parent_directories=search_parent_directories)
+    except git.InvalidGitRepositoryError:
+        return None
+
+
+def is_repo(path: pathlib.Path) -> bool:
+    return get_repo_or_nil(path, search_parent_directories=False) is not None
+
+
+def is_within_repo(path: pathlib.Path) -> bool:
+    return get_repo_or_nil(path, search_parent_directories=True) is not None
+
+
+def get_any_remote(repo: git.Repo) -> Optional[git.Remote]:
+    for remote in repo.remotes:
+        if remote.exists():
+            return remote
+    return None

rbx/box/package.py

@@ -33,6 +33,7 @@ from rbx.grading.judge.storage import FilesystemStorage, Storage
 YAML_NAME = 'problem.rbx.yml'
 _DEFAULT_CHECKER = 'wcmp.cpp'
 TEMP_DIR = None
+CACHE_STEP_VERSION = 1
 
 
 def warn_preset_deactivated(root: pathlib.Path = pathlib.Path()):
@@ -135,10 +136,17 @@ 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())
     return cache_dir
 
 
@@ -426,6 +434,21 @@ def get_merged_capture_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path
     return 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
+
+    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
+
+
 def clear_package_cache():
     pkgs = [sys.modules[__name__]]
 

rbx/box/packaging/boca/packager.py

@@ -67,7 +67,7 @@ class BocaPackager(BasePackager):
         return (
             f'basename={self._get_problem_basename()}\n'
             f'fullname={statement.title}\n'
-            f'descfile={self._get_problem_name()}.pdf\n'
+            f'descfile={self._get_problem_basename()}.pdf\n'
         )
 
     def _get_pkg_timelimit(self, language: BocaLanguage) -> int:
@@ -205,7 +205,7 @@ class BocaPackager(BasePackager):
             compile_text = compile_text.replace('{{rbxFlags}}', flags[language])
         return compile_text
 
-    def _copy_solutions(self, into_path: pathlib.Path, fix_java: bool = True):
+    def _copy_solutions(self, into_path: pathlib.Path):
         into_path = into_path / 'solutions'
         for solution in package.get_solutions():
             dest_path = (
@@ -218,21 +218,6 @@ class BocaPackager(BasePackager):
             dest_path.parent.mkdir(parents=True, exist_ok=True)
             shutil.copy(str(solution.path), dest_path)
 
-            if solution.path.suffix == '.java':
-                java_content = dest_path.read_text()
-                if (
-                    'class Main ' not in java_content
-                    and f'class {self._get_problem_name()} ' not in java_content
-                ):
-                    console.console.print(
-                        '[error]For BOCA packaging, Java solutions must be named `class Main` or `class <ProblemName>`.[/error]'
-                    )
-                dest_path.write_text(
-                    java_content.replace(
-                        'class Main ', f'class {self._get_problem_name()} '
-                    )
-                )
-
     @classmethod
     def name(cls) -> str:
         return 'boca'
@@ -297,7 +282,7 @@ class BocaPackager(BasePackager):
         (description_path / 'problem.info').write_text(self._get_problem_info())
         shutil.copyfile(
             self._get_main_built_statement(built_statements).path,
-            (description_path / self._get_problem_name()).with_suffix('.pdf'),
+            (description_path / self._get_problem_basename()).with_suffix('.pdf'),
         )
 
         # Copy solutions

rbx/box/packaging/moj/packager.py

@@ -215,7 +215,7 @@ class MojPackager(BocaPackager):
 
         # Copy solutions
         if self.for_boca:
-            self._copy_solutions(into_path, fix_java=False)
+            self._copy_solutions(into_path)
         else:
             self._copy_solutions_moj(into_path)
 

rbx/box/packaging/polygon/upload.py

@@ -307,11 +307,13 @@ def _upload_statement(problem: api.Problem):
         polygon_statement = api.Statement(
             encoding='utf-8',
             name=statement.title,
-            legend=blocks.blocks.get('legend'),
-            input=blocks.blocks.get('input'),
-            output=blocks.blocks.get('output'),
-            interaction=blocks.blocks.get('interaction'),
-            notes=_get_notes_with_explanations(blocks),
+            legend=blocks.blocks.get('legend') or '',
+            input=blocks.blocks.get('input') or '',
+            output=blocks.blocks.get('output') or '',
+            interaction=(blocks.blocks.get('interaction') or '')
+            if pkg.type == TaskType.COMMUNICATION
+            else None,
+            notes=_get_notes_with_explanations(blocks) or '',
         )
         problem.save_statement(
             lang=code_to_langs([language])[0], problem_statement=polygon_statement

rbx/box/presets/__init__.py

@@ -3,13 +3,14 @@ import shutil
 import tempfile
 from typing import Annotated, Iterable, List, Optional, Sequence, Union
 
+import questionary
 import rich
 import rich.prompt
 import typer
 from iso639.language import functools
 
 from rbx import console, utils
-from rbx.box import cd
+from rbx.box import cd, git_utils
 from rbx.box.environment import get_environment_path
 from rbx.box.presets.fetch import PresetFetchInfo, get_preset_fetch_info
 from rbx.box.presets.lock_schema import LockedAsset, PresetLock
@@ -363,11 +364,17 @@ def _install(root: pathlib.Path = pathlib.Path(), force: bool = False):
         if not res:
             raise typer.Exit(1)
     shutil.rmtree(str(installation_path), ignore_errors=True)
-    shutil.copytree(str(root), str(installation_path))
+    copy_tree_normalizing_gitdir(root, installation_path)
     shutil.rmtree(str(installation_path / 'build'), ignore_errors=True)
     shutil.rmtree(str(installation_path / '.box'), ignore_errors=True)
     shutil.rmtree(str(installation_path / '.local.rbx'), ignore_errors=True)
-    shutil.rmtree(str(installation_path / '.git'), ignore_errors=True)
+
+
+def install_from_local_dir(fetch_info: PresetFetchInfo, force: bool = False) -> str:
+    pd = pathlib.Path(fetch_info.inner_dir)
+    preset = get_preset_yaml(pd)
+    _install(pd, force=force)
+    return preset.name
 
 
 def install_from_remote(fetch_info: PresetFetchInfo, force: bool = False) -> str:
@@ -452,12 +459,75 @@ def _sync(try_update: bool = False):
     generate_lock(preset_lock.preset_name)
 
 
+def copy_tree_normalizing_gitdir(src_path: pathlib.Path, dst_path: pathlib.Path):
+    shutil.copytree(str(src_path), str(dst_path))
+    if not (src_path / '.git').is_file():
+        return
+
+    src_repo = git_utils.get_repo_or_nil(src_path)
+    if src_repo is None:
+        return
+
+    gitdir_dst = dst_path / '.git'
+    shutil.rmtree(str(gitdir_dst), ignore_errors=True)
+    gitdir_dst.unlink(missing_ok=True)
+
+    shutil.copytree(str(src_repo.git_dir), str(gitdir_dst))
+
+
+def copy_local_preset(
+    preset_path: pathlib.Path, dest_path: pathlib.Path, remote_uri: Optional[str] = None
+):
+    copy_tree_normalizing_gitdir(preset_path, dest_path / '.local.rbx')
+
+    from rbx.box import git_utils
+
+    preset_repo = git_utils.get_repo_or_nil(preset_path)
+    current_repo = git_utils.get_repo_or_nil(
+        pathlib.Path.cwd(), search_parent_directories=True
+    )
+
+    if preset_repo is None or current_repo is None:
+        return
+
+    fetch_info = get_preset_fetch_info(remote_uri)
+    remote_uri = fetch_info.fetch_uri if fetch_info is not None else None
+
+    preset_remote = git_utils.get_any_remote(preset_repo)
+    preset_remote_uri = preset_remote.url if preset_remote is not None else remote_uri
+    if preset_remote_uri is None:
+        return
+
+    add_submodule = questionary.confirm(
+        'The preset is installed from a remote Git repository. Do you want to add it as a submodule of your project?',
+        default=False,
+    ).ask()
+    if not add_submodule:
+        return
+
+    dest_path_rel = dest_path.resolve().relative_to(pathlib.Path.cwd().resolve())
+    path_str = str(dest_path_rel / '.local.rbx')
+    try:
+        current_repo.git.submodule('add', preset_remote_uri, path_str)
+    except Exception as e:
+        console.console.print('[error]Failed to add preset as a submodule.[/error]')
+        console.console.print(f'[error]Error:[/error] {e}')
+        console.console.print(
+            '[error]You might want to do this manually with the [item]git submodule add[/item] command.[/error]'
+        )
+        raise typer.Exit(1) from None
+    console.console.print(
+        f'[success]Preset [item]{preset_remote_uri}[/item] was added as a submodule to your project at [item]{path_str}[/item].[/success]'
+    )
+
+
 @app.command(
     'install', help='Install preset from current directory or from the given URI.'
 )
 def install(
     uri: Optional[str] = typer.Argument(
-        None, help='GitHub URI for the preset to install.'
+        None,
+        help='URI for the preset to install. Might be a Github repository, or even a local path.',
     ),
 ):
     if uri is None:
@@ -468,9 +538,13 @@ def install(
     if fetch_info is None:
         console.console.print(f'[error] Preset with URI {uri} not found.[/error]')
         raise typer.Exit(1)
-    if fetch_info.fetch_uri is None:
+    if not fetch_info.is_local_dir() and not fetch_info.is_remote():
         console.console.print(f'[error]URI {uri} is invalid.[/error]')
-    install_from_remote(fetch_info)
+        raise typer.Exit(1)
+    if fetch_info.is_remote():
+        install_from_remote(fetch_info)
+    else:
+        install_from_local_dir(fetch_info)
 
 
 @app.command('update', help='Update installed remote presets')

rbx/box/presets/fetch.py

@@ -1,3 +1,4 @@
+import pathlib
 import re
 from typing import Optional
 
@@ -17,6 +18,12 @@ class PresetFetchInfo(BaseModel):
     # Inner directory from where to pull the preset.
     inner_dir: str = ''
 
+    def is_remote(self) -> bool:
+        return self.fetch_uri is not None
+
+    def is_local_dir(self) -> bool:
+        return bool(self.inner_dir) and not self.is_remote()
+
 
 def get_preset_fetch_info(uri: Optional[str]) -> Optional[PresetFetchInfo]:
     if uri is None:
@@ -36,7 +43,7 @@ def get_preset_fetch_info(uri: Optional[str]) -> Optional[PresetFetchInfo]:
         )
 
     def get_short_github_fetch_info(s: str) -> Optional[PresetFetchInfo]:
-        pattern = r'([\w\-]+\/[\w\.\-]+)(?:\/(.*))?'
+        pattern = r'(?:\@gh/)?([\w\-]+\/[\w\.\-]+)(?:\/(.*))?'
         compiled = re.compile(pattern)
         match = compiled.match(s)
         if match is None:
@@ -48,6 +55,15 @@ def get_preset_fetch_info(uri: Optional[str]) -> Optional[PresetFetchInfo]:
             inner_dir=match.group(2) or '',
         )
 
+    def get_local_dir_fetch_info(s: str) -> Optional[PresetFetchInfo]:
+        try:
+            path = pathlib.Path(s)
+            if not path.exists():
+                return None
+        except Exception:
+            return None
+        return PresetFetchInfo(name=path.name, inner_dir=str(path))
+
     def get_local_fetch_info(s: str) -> Optional[PresetFetchInfo]:
         pattern = r'[\w\-]+'
         compiled = re.compile(pattern)
@@ -59,6 +75,7 @@ def get_preset_fetch_info(uri: Optional[str]) -> Optional[PresetFetchInfo]:
     extractors = [
         get_github_fetch_info,
         get_short_github_fetch_info,
+        get_local_dir_fetch_info,
         get_local_fetch_info,
     ]
 

rbx/box/retries.py

@@ -88,6 +88,8 @@ def _move_logs_to_temp_dir(
         recover.append(_move_to_temp_dir(eval.log.stderr_absolute_path, temp_dir))
     if eval.log.log_absolute_path is not None and eval.log.log_absolute_path.exists():
         recover.append(_move_to_temp_dir(eval.log.log_absolute_path, temp_dir))
+    if eval.log.eval_absolute_path is not None and eval.log.eval_absolute_path.exists():
+        recover.append(_move_to_temp_dir(eval.log.eval_absolute_path, temp_dir))
     return recover