rbx.cp 0.13.8__py3-none-any.whl → 0.16.0__py3-none-any.whl

rbx/box/presets/__init__.py

@@ -1,15 +1,23 @@
+import functools
 import os
 import pathlib
 import shutil
 import tempfile
 from typing import Annotated, Iterable, List, Optional, Sequence, Set, Tuple, Union
 
+import questionary
 import ruyaml
+import semver
 import typer
 
 from rbx import console, utils
 from rbx.box import cd
-from rbx.box.presets.fetch import PresetFetchInfo, get_preset_fetch_info
+from rbx.box.git_utils import latest_remote_tag
+from rbx.box.presets.fetch import (
+    PresetFetchInfo,
+    get_preset_fetch_info,
+    get_remote_uri_from_tool_preset,
+)
 from rbx.box.presets.lock_schema import LockedAsset, PresetLock, SymlinkInfo
 from rbx.box.presets.schema import Preset, TrackedAsset
 from rbx.config import get_default_app_path
@@ -17,24 +25,50 @@ from rbx.grading.judge.digester import digest_cooperatively
 
 app = typer.Typer(no_args_is_help=True)
 
-_FALLBACK_PRESET_URI = 'rsalesc/rbx/rbx/resources/presets/default'
+_FALLBACK_PRESET_NAME = 'default'
 
 
-def _find_preset_yaml(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Path]:
+def find_preset_yaml(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Path]:
     found = root / 'preset.rbx.yml'
     if found.exists():
         return found
     return None
 
 
+@functools.cache
+def _check_preset_compatibility(preset_name: str, preset_version: str) -> None:
+    compatibility = utils.check_version_compatibility(preset_version)
+    if compatibility == utils.SemVerCompatibility.OUTDATED:
+        console.console.print(
+            f'[error]Preset [item]{preset_name}[/item] requires rbx at version [item]{preset_version}[/item], but the current version is [item]{utils.get_version()}[/item].[/error]'
+        )
+        console.console.print(
+            f'[error]Please update rbx.cp to the latest compatible version using [item]{utils.get_upgrade_command(preset_version)}[/item].[/error]'
+        )
+        raise typer.Exit(1)
+    if compatibility == utils.SemVerCompatibility.BREAKING_CHANGE:
+        console.console.print(
+            f'[error]Preset [item]{preset_name}[/item] requires rbx at version [item]{preset_version}[/item], but the current version is [item]{utils.get_version()}[/item].[/error]'
+        )
+        console.console.print(
+            '[error]rbx version is newer, but is in a later major version, which might have introduced breaking changes.[/error]'
+        )
+        console.console.print(
+            '[error]If you are sure that the preset is compatible with the current rbx version, you can change the [item]min_version[/item] field in the preset file ([item].local.rbx/preset.rbx.yml)[/item] to the current version.[/error]'
+        )
+        raise typer.Exit(1)
+
+
 def get_preset_yaml(root: pathlib.Path = pathlib.Path()) -> Preset:
-    found = _find_preset_yaml(root)
+    found = find_preset_yaml(root)
     if not found:
         console.console.print(
             f'[error][item]preset.rbx.yml[/item] not found in [item]{root.absolute()}[/item][/error]'
         )
         raise typer.Exit(1)
-    return utils.model_from_yaml(Preset, found.read_text())
+    preset = utils.model_from_yaml(Preset, found.read_text())
+    _check_preset_compatibility(preset.name, preset.min_version)
+    return preset
 
 
 def _find_preset_lock(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.Path]:
@@ -45,14 +79,14 @@ def _find_preset_lock(root: pathlib.Path = pathlib.Path()) -> Optional[pathlib.P
     return problem_yaml_path
 
 
-def _get_preset_lock(root: pathlib.Path = pathlib.Path()) -> Optional[PresetLock]:
+def get_preset_lock(root: pathlib.Path = pathlib.Path()) -> Optional[PresetLock]:
     found = _find_preset_lock(root)
     if not found:
         return None
     return utils.model_from_yaml(PresetLock, found.read_text())
 
 
-def _find_nested_preset(root: pathlib.Path) -> Optional[pathlib.Path]:
+def find_nested_preset(root: pathlib.Path) -> Optional[pathlib.Path]:
     root = utils.abspath(root)
     problem_yaml_path = root / 'preset.rbx.yml'
     while root != pathlib.PosixPath('/') and not problem_yaml_path.is_file():
@@ -63,7 +97,7 @@ def _find_nested_preset(root: pathlib.Path) -> Optional[pathlib.Path]:
     return problem_yaml_path.parent
 
 
-def _find_local_preset(root: pathlib.Path) -> Optional[pathlib.Path]:
+def find_local_preset(root: pathlib.Path) -> Optional[pathlib.Path]:
     original_root = root
     root = utils.abspath(root)
     problem_yaml_path = root / '.local.rbx' / 'preset.rbx.yml'
@@ -71,12 +105,12 @@ def _find_local_preset(root: pathlib.Path) -> Optional[pathlib.Path]:
         root = root.parent
         problem_yaml_path = root / '.local.rbx' / 'preset.rbx.yml'
     if not problem_yaml_path.is_file():
-        return _find_nested_preset(original_root)
+        return find_nested_preset(original_root)
     return problem_yaml_path.parent
 
 
 def _is_installed_preset(root: pathlib.Path = pathlib.Path()) -> bool:
-    preset_path = _find_local_preset(root)
+    preset_path = find_local_preset(root)
     if preset_path is None:
         return False
     resolved_path = utils.abspath(preset_path)
@@ -84,25 +118,25 @@ def _is_installed_preset(root: pathlib.Path = pathlib.Path()) -> bool:
 
 
 def _is_active_preset_nested(root: pathlib.Path = pathlib.Path()) -> bool:
-    preset_path = _find_local_preset(root)
+    preset_path = find_local_preset(root)
     if preset_path is None:
         return False
-    nested_preset_path = _find_nested_preset(root)
+    nested_preset_path = find_nested_preset(root)
     if nested_preset_path is None:
         return False
     return nested_preset_path == preset_path
 
 
-def _is_contest(root: pathlib.Path = pathlib.Path()) -> bool:
+def is_contest(root: pathlib.Path = pathlib.Path()) -> bool:
     return (root / 'contest.rbx.yml').is_file()
 
 
-def _is_problem(root: pathlib.Path = pathlib.Path()) -> bool:
+def is_problem(root: pathlib.Path = pathlib.Path()) -> bool:
     return (root / 'problem.rbx.yml').is_file()
 
 
-def _check_is_valid_package(root: pathlib.Path = pathlib.Path()):
-    if not _is_contest(root) and not _is_problem(root):
+def check_is_valid_package(root: pathlib.Path = pathlib.Path()):
+    if not is_contest(root) and not is_problem(root):
         console.console.print('[error]Not a valid rbx package directory.[/error]')
         raise typer.Exit(1)
 
@@ -110,7 +144,7 @@ def _check_is_valid_package(root: pathlib.Path = pathlib.Path()):
 def _glob_while_ignoring(
     dir: pathlib.Path,
     glb: str,
-    extra_gitignore: Optional[str] = '.box\nbuild\n',
+    extra_gitignore: Optional[str] = '.box\nbuild\n.limits/local.yml\n',
     recursive: bool = False,
 ) -> Iterable[pathlib.Path]:
     from gitignore_parser import parse_gitignore, parse_gitignore_str
@@ -133,7 +167,7 @@ def _glob_while_ignoring(
         yield file
 
 
-def _process_globbing(
+def process_globbing(
     assets: Iterable[TrackedAsset], preset_pkg_dir: pathlib.Path
 ) -> List[TrackedAsset]:
     res = []
@@ -156,7 +190,7 @@ def _process_globbing(
     return res
 
 
-def _dedup_tracked_assets(assets: List[TrackedAsset]) -> List[TrackedAsset]:
+def dedup_tracked_assets(assets: List[TrackedAsset]) -> List[TrackedAsset]:
     seen_paths = set()
     res = []
     for asset in assets:
@@ -167,11 +201,11 @@ def _dedup_tracked_assets(assets: List[TrackedAsset]) -> List[TrackedAsset]:
     return res
 
 
-def _get_preset_tracked_assets(
+def get_preset_tracked_assets(
     root: pathlib.Path, is_contest: bool, add_symlinks: bool = False
 ) -> List[TrackedAsset]:
     preset = get_active_preset(root)
-    preset_path = _find_local_preset(root)
+    preset_path = find_local_preset(root)
     assert preset_path is not None
 
     if is_contest:
@@ -179,13 +213,13 @@ def _get_preset_tracked_assets(
             preset.contest is not None
         ), 'Preset does not have a contest package definition.'
         preset_pkg_path = preset_path / preset.contest
-        res = _process_globbing(preset.tracking.contest, preset_pkg_path)
+        res = process_globbing(preset.tracking.contest, preset_pkg_path)
     else:
         assert (
             preset.problem is not None
         ), 'Preset does not have a problem package definition,'
         preset_pkg_path = preset_path / preset.problem
-        res = _process_globbing(preset.tracking.problem, preset_pkg_path)
+        res = process_globbing(preset.tracking.problem, preset_pkg_path)
 
     if add_symlinks:
         for file in _glob_while_ignoring(
@@ -199,7 +233,7 @@ def _get_preset_tracked_assets(
                 TrackedAsset(path=file.relative_to(preset_pkg_path), symlink=True)
             )
 
-    return _dedup_tracked_assets(res)
+    return dedup_tracked_assets(res)
 
 
 def _get_tracked_assets_symlinks(
@@ -212,7 +246,7 @@ def _get_tracked_assets_symlinks(
     return res
 
 
-def _get_symlink_info(
+def get_symlink_info(
     tracked_asset: Union[TrackedAsset, LockedAsset], root: pathlib.Path
 ) -> Optional[SymlinkInfo]:
     asset_path = root / tracked_asset.path
@@ -225,7 +259,7 @@ def _get_symlink_info(
     return SymlinkInfo(target=target, is_broken=is_broken, is_outside=is_outside)
 
 
-def _build_package_locked_assets(
+def build_package_locked_assets(
     tracked_assets: Sequence[Union[TrackedAsset, LockedAsset]],
     root: pathlib.Path = pathlib.Path(),
 ) -> List[LockedAsset]:
@@ -237,7 +271,7 @@ def _build_package_locked_assets(
                 LockedAsset(
                     path=tracked_asset.path,
                     hash=None,
-                    symlink_info=_get_symlink_info(tracked_asset, root),
+                    symlink_info=get_symlink_info(tracked_asset, root),
                 )
             )
             continue
@@ -246,13 +280,13 @@ def _build_package_locked_assets(
                 LockedAsset(
                     path=tracked_asset.path,
                     hash=digest_cooperatively(f),
-                    symlink_info=_get_symlink_info(tracked_asset, root),
+                    symlink_info=get_symlink_info(tracked_asset, root),
                 )
             )
     return res
 
 
-def _find_non_modified_assets(
+def find_non_modified_assets(
     reference: List[LockedAsset], current: List[LockedAsset]
 ) -> List[LockedAsset]:
     reference_by_path = {asset.path: asset for asset in reference}
@@ -273,7 +307,7 @@ def _find_non_modified_assets(
     return res
 
 
-def _find_modified_assets(
+def find_modified_assets(
     reference: List[LockedAsset],
     current: List[LockedAsset],
     seen_symlinks: Set[pathlib.Path],
@@ -297,7 +331,7 @@ def _find_modified_assets(
     return res
 
 
-def _copy_preset_file(
+def copy_preset_file(
     src: pathlib.Path,
     dst: pathlib.Path,
     preset_package_path: pathlib.Path,
@@ -358,19 +392,19 @@ def _copy_updated_assets(
     preset_path = get_active_preset_path(root)
     preset_package_path = _get_active_preset_package_path(root, is_contest)
 
-    preset_tracked_assets = _get_preset_tracked_assets(
+    preset_tracked_assets = get_preset_tracked_assets(
         preset_package_path, is_contest=is_contest, add_symlinks=symlinks
     )
-    current_preset_snapshot = _build_package_locked_assets(
+    current_preset_snapshot = build_package_locked_assets(
         preset_tracked_assets, preset_package_path
     )
 
     # Build current package snapshot based on the current preset snapshot.
-    current_package_snapshot = _build_package_locked_assets(current_preset_snapshot)
+    current_package_snapshot = build_package_locked_assets(current_preset_snapshot)
 
     non_modified_assets = current_package_snapshot
     if not force:
-        non_modified_assets = _find_non_modified_assets(
+        non_modified_assets = find_non_modified_assets(
             preset_lock.assets, current_package_snapshot
         )
 
@@ -386,7 +420,7 @@ def _copy_updated_assets(
 
     seen_symlinks = _get_tracked_assets_symlinks(preset_tracked_assets)
 
-    assets_to_copy = _find_modified_assets(
+    assets_to_copy = find_modified_assets(
         non_modified_assets, current_preset_snapshot, seen_symlinks
     )
 
@@ -402,7 +436,7 @@ def _copy_updated_assets(
     for asset in assets_to_copy:
         src_path = preset_package_path / asset.path
         dst_path = root / asset.path
-        _copy_preset_file(
+        copy_preset_file(
             src_path,
             dst_path,
             preset_package_path,
@@ -415,7 +449,7 @@ def _copy_updated_assets(
 
 
 def get_active_preset_or_null(root: pathlib.Path = pathlib.Path()) -> Optional[Preset]:
-    local_preset = _find_local_preset(root)
+    local_preset = find_local_preset(root)
     if local_preset is not None:
         return get_preset_yaml(local_preset)
     return None
@@ -430,7 +464,7 @@ def get_active_preset(root: pathlib.Path = pathlib.Path()) -> Preset:
 
 
 def get_active_preset_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
-    preset_path = _find_local_preset(root)
+    preset_path = find_local_preset(root)
     if preset_path is None:
         console.console.print('[error]No preset is active.[/error]')
         raise typer.Exit(1)
@@ -458,7 +492,7 @@ def _get_active_preset_package_path(
     is_contest: bool = False,
 ) -> pathlib.Path:
     preset = get_active_preset(root)
-    preset_path = _find_local_preset(root)
+    preset_path = find_local_preset(root)
     assert preset_path is not None
     if is_contest:
         assert (
@@ -478,7 +512,7 @@ def get_preset_fetch_info_with_fallback(
         # Use active preset if any, otherwise use the default preset.
         if get_active_preset_or_null() is not None:
             return None
-        default_preset = get_preset_fetch_info(_FALLBACK_PRESET_URI)
+        default_preset = get_preset_fetch_info(_FALLBACK_PRESET_NAME)
         if default_preset is None:
             console.console.print(
                 '[error]Internal error: could not find [item]default[/item] preset.[/error]'
@@ -488,26 +522,26 @@ def get_preset_fetch_info_with_fallback(
     return get_preset_fetch_info(uri)
 
 
-def _clean_copied_package_dir(dest: pathlib.Path):
+def clean_copied_package_dir(dest: pathlib.Path):
     for box_dir in dest.rglob('.box'):
         shutil.rmtree(str(box_dir), ignore_errors=True)
     for lock in dest.rglob('.preset-lock.yml'):
         lock.unlink(missing_ok=True)
 
 
-def _clean_copied_contest_dir(dest: pathlib.Path, delete_local_rbx: bool = True):
+def clean_copied_contest_dir(dest: pathlib.Path, delete_local_rbx: bool = True):
     shutil.rmtree(str(dest / 'build'), ignore_errors=True)
     if delete_local_rbx:
         shutil.rmtree(str(dest / '.local.rbx'), ignore_errors=True)
-    _clean_copied_package_dir(dest)
+    clean_copied_package_dir(dest)
 
 
-def _clean_copied_problem_dir(dest: pathlib.Path):
+def clean_copied_problem_dir(dest: pathlib.Path):
     shutil.rmtree(str(dest / 'build'), ignore_errors=True)
-    _clean_copied_package_dir(dest)
+    clean_copied_package_dir(dest)
 
 
-def _install_preset_from_dir(
+def install_preset_from_dir(
     src: pathlib.Path,
     dest: pathlib.Path,
     ensure_contest: bool = False,
@@ -527,6 +561,15 @@ def _install_preset_from_dir(
             f'[error]Preset [item]{preset.name}[/item] does not have a problem package definition.[/error]'
         )
         raise typer.Exit(1)
+
+    try:
+        _check_preset_compatibility(preset.name, preset.min_version)
+    except Exception:
+        console.console.print(
+            f'[error]Error updating preset [item]{preset.name}[/item] to its latest version.[/error]'
+        )
+        raise
+
     dest.parent.mkdir(parents=True, exist_ok=True)
     copy_tree_normalizing_gitdir(src, dest, update=update)
 
@@ -541,11 +584,11 @@ def _install_preset_from_dir(
     shutil.rmtree(str(dest / '.local.rbx'), ignore_errors=True)
 
     if preset.contest is not None:
-        _clean_copied_contest_dir(dest / preset.contest)
+        clean_copied_contest_dir(dest / preset.contest)
     if preset.problem is not None:
-        _clean_copied_problem_dir(dest / preset.problem)
+        clean_copied_problem_dir(dest / preset.problem)
 
-    _clean_copied_package_dir(dest)
+    clean_copied_package_dir(dest)
 
 
 def _install_preset_from_remote(
@@ -569,7 +612,7 @@ def _install_preset_from_remote(
                 f'Installing preset from [item]{fetch_info.inner_dir}[/item].'
             )
             pd = pd / fetch_info.inner_dir
-        _install_preset_from_dir(
+        install_preset_from_dir(
             pd,
             dest,
             ensure_contest,
@@ -591,7 +634,7 @@ def _install_preset_from_local_dir(
     console.console.print(
         f'Installing local preset [item]{preset.name}[/item] into [item]{dest}[/item]...'
     )
-    _install_preset_from_dir(
+    install_preset_from_dir(
         pd,
         dest,
         ensure_contest,
@@ -614,15 +657,38 @@ def _install_preset_from_resources(
     yaml_path = rsrc_preset_path / 'preset.rbx.yml'
     if not yaml_path.is_file():
         return False
+    preset_uri = get_remote_uri_from_tool_preset(fetch_info.name)
+    remote_fetch_info = get_preset_fetch_info(preset_uri)
+    if remote_fetch_info is None or remote_fetch_info.fetch_uri is None:
+        console.console.print(
+            f'[error]Preset [item]{fetch_info.name}[/item] not found.[/error]'
+        )
+        raise typer.Exit(1)
+
+    # Check if the latest release has breaking changes.
+    latest_tag = latest_remote_tag(remote_fetch_info.fetch_uri)
+    latest_version = semver.VersionInfo.parse(latest_tag)
+    if latest_version.major > utils.get_semver().major:
+        console.console.print(
+            f'[error]You are not in rbx.cp latest major version ({latest_version.major}), but are installing a built-in preset from rbx.cp.[/error]'
+        )
+        console.console.print(
+            f'[error]To allow for a better experience for users that clone your repository, please update rbx.cp to the latest major version using [item]{utils.get_upgrade_command(latest_version)}[/item].[/error]'
+        )
+        if not questionary.confirm(
+            'If you want to proceed anyway, press [y]', default=False
+        ).ask():
+            raise typer.Exit(1)
+
     console.console.print(
         f'Installing preset [item]{fetch_info.name}[/item] from resources...'
     )
-    _install_preset_from_dir(
+    install_preset_from_dir(
         rsrc_preset_path,
         dest,
         ensure_contest,
         ensure_problem,
-        override_uri=str(utils.abspath(rsrc_preset_path)),
+        override_uri=preset_uri,
         update=update,
     )
     return True
@@ -653,15 +719,14 @@ def _install_preset_from_fetch_info(
             update=update,
         )
         return
-    # NOTE: Disabled for now.
-    # if _install_preset_from_resources(
-    #     fetch_info,
-    #     dest,
-    #     ensure_contest=ensure_contest,
-    #     ensure_problem=ensure_problem,
-    #     update=update,
-    # ):
-    #     return
+    if _install_preset_from_resources(
+        fetch_info,
+        dest,
+        ensure_contest=ensure_contest,
+        ensure_problem=ensure_problem,
+        update=update,
+    ):
+        return
     console.console.print(
         f'[error]Preset [item]{fetch_info.name}[/item] not found.[/error]'
     )
@@ -692,7 +757,7 @@ def _install_package_from_preset(
     ):
         if not file.is_file():
             continue
-        _copy_preset_file(
+        copy_preset_file(
             file,
             dest_pkg / file.relative_to(preset_package_path),
             preset_package_path,
@@ -702,7 +767,7 @@ def _install_package_from_preset(
     for asset in tracked_assets:
         if not asset.symlink:
             continue
-        _copy_preset_file(
+        copy_preset_file(
             preset_package_path / asset.path,
             dest_pkg / asset.path,
             preset_package_path,
@@ -721,7 +786,7 @@ def install_contest(
             ensure_contest=True,
         )
     preset = get_active_preset(dest_pkg)
-    preset_path = _find_local_preset(dest_pkg)
+    preset_path = find_local_preset(dest_pkg)
     assert preset_path is not None
     if preset.contest is None:
         console.console.print(
@@ -735,7 +800,7 @@ def install_contest(
     _install_package_from_preset(
         preset_path, preset.contest, dest_pkg, preset.tracking.contest
     )
-    _clean_copied_contest_dir(dest_pkg, delete_local_rbx=False)
+    clean_copied_contest_dir(dest_pkg, delete_local_rbx=False)
 
 
 def install_problem(
@@ -748,7 +813,7 @@ def install_problem(
             ensure_problem=True,
         )
     preset = get_active_preset(dest_pkg)
-    preset_path = _find_local_preset(dest_pkg)
+    preset_path = find_local_preset(dest_pkg)
     assert preset_path is not None
     if preset.problem is None:
         console.console.print(
@@ -762,7 +827,7 @@ def install_problem(
     _install_package_from_preset(
         preset_path, preset.problem, dest_pkg, preset.tracking.problem
     )
-    _clean_copied_problem_dir(dest_pkg)
+    clean_copied_problem_dir(dest_pkg)
 
 
 def install_preset(
@@ -774,7 +839,7 @@ def install_preset(
         )
         raise typer.Exit(1)
     if fetch_info is None:
-        _install_preset_from_dir(get_active_preset_path(), dest_pkg)
+        install_preset_from_dir(get_active_preset_path(), dest_pkg)
     else:
         _install_preset_from_fetch_info(fetch_info, dest_pkg)
 
@@ -792,10 +857,10 @@ def get_ruyaml(root: pathlib.Path = pathlib.Path()) -> Tuple[ruyaml.YAML, ruyaml
 def generate_lock(root: pathlib.Path = pathlib.Path()):
     preset = get_active_preset(root)
 
-    tracked_assets = _get_preset_tracked_assets(root, is_contest=_is_contest(root))
+    tracked_assets = get_preset_tracked_assets(root, is_contest=is_contest(root))
     preset_lock = PresetLock(
         name=preset.name,
-        assets=_build_package_locked_assets(tracked_assets, root),
+        assets=build_package_locked_assets(tracked_assets, root),
     )
 
     (root / '.preset-lock.yml').write_text(utils.model_to_yaml(preset_lock))
@@ -805,7 +870,7 @@ def generate_lock(root: pathlib.Path = pathlib.Path()):
 
 
 def _sync(try_update: bool = False, force: bool = False, symlinks: bool = False):
-    preset_lock = _get_preset_lock()
+    preset_lock = get_preset_lock()
     if preset_lock is None:
         console.console.print(
             '[error]Package does not have a [item].preset.lock.yml[/item] file and thus cannot be synced.[/error]'
@@ -820,7 +885,7 @@ def _sync(try_update: bool = False, force: bool = False, symlinks: bool = False)
 
     _copy_updated_assets(
         preset_lock,
-        is_contest=_is_contest(),
+        is_contest=is_contest(),
         force=force,
         symlinks=symlinks,
     )
@@ -969,7 +1034,7 @@ def update():
     ).ask():
         return
 
-    preset_path = _find_local_preset(pathlib.Path.cwd())
+    preset_path = find_local_preset(pathlib.Path.cwd())
     assert preset_path is not None
     _install_preset_from_fetch_info(preset.fetch_info, dest=preset_path, update=True)
     console.console.print(
@@ -1008,7 +1073,7 @@ def sync(
         ),
     ] = False,
 ):
-    _check_is_valid_package()
+    check_is_valid_package()
     _sync(try_update=update, force=force, symlinks=symlinks)
 
 
@@ -1019,7 +1084,7 @@ def sync(
 )
 @cd.within_closest_package
 def lock():
-    _check_is_valid_package()
+    check_is_valid_package()
     generate_lock()
 
 
@@ -1027,7 +1092,7 @@ def lock():
 @cd.within_closest_package
 def ls():
     preset = get_active_preset()
-    preset_path = _find_local_preset(pathlib.Path.cwd())
+    preset_path = find_local_preset(pathlib.Path.cwd())
     console.console.print(f'Preset: [item]{preset.name}[/item]')
     console.console.print(f'Path: {preset_path}')
     console.console.print(f'URI: {preset.uri}')

rbx/box/presets/fetch.py

@@ -25,6 +25,14 @@ class PresetFetchInfo(BaseModel):
         return bool(self.inner_dir) and not self.is_remote()
 
 
+def get_inner_dir_from_tool_preset(tool_preset: str) -> str:
+    return f'rbx/resources/presets/{tool_preset}'
+
+
+def get_remote_uri_from_tool_preset(tool_preset: str) -> str:
+    return f'rsalesc/rbx/{get_inner_dir_from_tool_preset(tool_preset)}'
+
+
 def get_preset_fetch_info(uri: Optional[str]) -> Optional[PresetFetchInfo]:
     if uri is None:
         return None
@@ -64,7 +72,7 @@ def get_preset_fetch_info(uri: Optional[str]) -> Optional[PresetFetchInfo]:
             return None
         return PresetFetchInfo(name=path.name, inner_dir=str(path))
 
-    def get_local_fetch_info(s: str) -> Optional[PresetFetchInfo]:
+    def get_tool_fetch_info(s: str) -> Optional[PresetFetchInfo]:
         pattern = r'[\w\-]+'
         compiled = re.compile(pattern)
         match = compiled.match(s)
@@ -76,7 +84,7 @@ def get_preset_fetch_info(uri: Optional[str]) -> Optional[PresetFetchInfo]:
         get_github_fetch_info,
         get_short_github_fetch_info,
         get_local_dir_fetch_info,
-        get_local_fetch_info,
+        get_tool_fetch_info,
     ]
 
     for extract in extractors:

rbx/box/presets/schema.py

@@ -1,8 +1,9 @@
 import pathlib
 from typing import List, Optional
 
+import semver
 import typer
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 from rbx import console
 from rbx.box.presets.fetch import PresetFetchInfo, get_preset_fetch_info
@@ -42,6 +43,9 @@ class Preset(BaseModel):
     # Should usually be a GitHub repository.
     uri: str
 
+    # Minimum version of rbx.cp required to use this preset.
+    min_version: str = '0.14.0'
+
     # Path to the environment file that will be installed with this preset.
     # When copied to the box environment, the environment will be named `name`.
     env: Optional[pathlib.Path] = None
@@ -57,6 +61,17 @@ class Preset(BaseModel):
     # package changes in the preset, or when a latex template is changed.
     tracking: Tracking = Field(default_factory=Tracking)
 
+    @field_validator('min_version')
+    @classmethod
+    def validate_min_version(cls, value: str) -> str:
+        try:
+            semver.Version.parse(value)
+        except ValueError as err:
+            raise ValueError(
+                "min_version must be a valid SemVer string (e.g., '1.2.3' or '1.2.3-rc.1')"
+            ) from err
+        return value
+
     @property
     def fetch_info(self) -> PresetFetchInfo:
         res = get_preset_fetch_info(self.uri)