modsmith-cli 0.1.1__py3-none-any.whl

modsmith_cli/commands/instance.py

@@ -0,0 +1,234 @@
+"""Commands that bring in, move and delete whole instances."""
+
+import shutil
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from modsmith import loaders
+from modsmith.errors import UnsupportedError
+from modsmith.instances import Instance
+from modsmith.launcher import Launcher, Profile
+from modsmith.loaders import Loader
+from modsmith.minecraft import GameDir
+
+from ..context import AppContext, get
+from ..core.config import Config
+from ..core.errors import AppError
+from ..core.install import check_launcher
+from ..core.names import check_name
+from ..core.records import Record, read_record, write_record
+from ..core.registry import (
+    list_instances,
+    locate,
+    remember_external,
+    resolve_instance,
+)
+from ..target import DryRun, InstanceName, Yes
+from ..ui import confirm, confirm_name
+from .contents import adopt_files
+from .install import loader_label
+
+
+def _profile(launcher: Launcher, text: str) -> Profile:
+    """Find a launcher installation by its key or, ignoring case, its name."""
+    profiles = launcher.profiles()
+    if text in profiles:
+        return profiles[text]
+    named = [item for item in profiles.values() if item.name.lower() == text.lower()]
+    if len(named) == 1:
+        return named[0]
+    listed = ", ".join(sorted(item.name or item.key for item in profiles.values()))
+    if named:
+        raise AppError(
+            f"Several installations are called {text!r}.",
+            hint="Use the key of one instead: " + ", ".join(item.key for item in named),
+        )
+    raise AppError(
+        f"The official launcher has no installation called {text!r}.",
+        hint=f"Its installations: {listed}." if listed else None,
+    )
+
+
+def _versions(game: GameDir, version_id: str) -> tuple[str, Loader | None]:
+    """Return the Minecraft version and the loader an installed version starts.
+
+    Raises:
+        AppError: The version, or one it inherits from, is not installed.
+    """
+    try:
+        loader = loaders.detect(game, version_id)
+        version = game.version(version_id)
+    except UnsupportedError as e:
+        raise AppError(
+            f"{e}.", hint="Start it once in the official launcher, then try again."
+        ) from e
+    if loader is not None:
+        return loader.minecraft, loader
+    return version.inherits_from or version.id, None
+
+
+def _inside(path: Path, folder: Path) -> bool:
+    return path.resolve().is_relative_to(folder.resolve())
+
+
+def _check_free_name(app: AppContext, path: Path, moving: Path | None = None) -> None:
+    """Refuse a folder name that another instance already has."""
+    others = {path.resolve(), moving.resolve() if moving else path.resolve()}
+    taken = [
+        entry
+        for entry in list_instances(app.config, app.paths)
+        if entry.name == path.name and entry.path.resolve() not in others
+    ]
+    if taken:
+        raise AppError(
+            f"An instance called {path.name} already exists.",
+            hint="Rename one of the two folders first.",
+        )
+
+
+def import_command(
+    ctx: typer.Context,
+    installation: Annotated[
+        str,
+        typer.Argument(
+            help="The installation's name in the official launcher.",
+            show_default=False,
+        ),
+    ],
+    yes: Yes = False,
+    dry_run: DryRun = False,
+) -> None:
+    """Manage an installation you made in the official launcher as an instance."""
+    app = get(ctx)
+    game = GameDir(app.config.game_dir)
+    profile = _profile(check_launcher(game, running=False), installation)
+    if not profile.game_dir:
+        raise AppError(
+            f"{profile.name} uses the game directory itself.",
+            hint="Give it its own game directory in the official launcher first.",
+        )
+    if not profile.version_id or profile.version_id.startswith("latest-"):
+        raise AppError(
+            f"{profile.name} starts the newest Minecraft, not one version.",
+            hint="Choose a version for it in the official launcher first.",
+        )
+    path = Path(profile.game_dir).resolve()
+    instance = Instance(path)
+    if instance.state is not None:
+        raise AppError(f"{path} is already an instance.")
+    _check_free_name(app, path)
+    minecraft, loader = _versions(game, profile.version_id)
+    kind, version = (loader.kind, loader.version) if loader else (None, None)
+    app.out.print(
+        f"Import {profile.name} as {path.name}: Minecraft {minecraft} "
+        f"with {loader_label(kind, version)}, in {path}."
+    )
+    if dry_run:
+        return
+    confirm(app, "Import it?", yes=yes)
+    path.mkdir(parents=True, exist_ok=True)
+    Instance.create(
+        path,
+        minecraft=minecraft,
+        loader=kind,
+        loader_version=version,
+    )
+    write_record(path, Record(profile=profile.key))
+    if not _inside(path, app.config.instances_dir):
+        remember_external(app.paths, path)
+    platforms = ["modrinth"] + (["curseforge"] if app.config.curseforge_api_key else [])
+    adopt_files(app, instance, platforms)
+    app.out.print(f"{path.name} is now an instance.")
+
+
+def _destination(text: str, config: Config, current: Path) -> Path:
+    """Return where an instance moves to: a new name, or a folder path.
+
+    A new name keeps the instance in the folder it is in now, so an imported
+    instance is renamed in place rather than moved into the instances folder.
+    """
+    path = locate(text, config)
+    if path.parent == config.instances_dir:
+        path = current.parent / check_name(path.name)
+    if path.exists():
+        raise AppError(
+            f"{path} already exists.",
+            hint="Name a folder that does not exist yet.",
+        )
+    return path
+
+
+def move_command(
+    ctx: typer.Context,
+    name: Annotated[
+        str, typer.Argument(help="The instance to move.", show_default=False)
+    ],
+    destination: Annotated[
+        str,
+        typer.Argument(help="A new name, or a folder path.", show_default=False),
+    ],
+) -> None:
+    """Rename an instance or move its folder, and update its launcher installation."""
+    app = get(ctx)
+    instance, _ = resolve_instance(name, app.config, app.paths)
+    old = instance.path.resolve()
+    new = _destination(destination, app.config, old)
+    _check_free_name(app, new, moving=old)
+    record = read_record(old)
+    game = GameDir(app.config.game_dir)
+    launcher = (
+        check_launcher(game, app.services.launcher_running())
+        if record.profile
+        else None
+    )
+    new.parent.mkdir(parents=True, exist_ok=True)
+    shutil.move(old, new)
+    remember_external(app.paths, old, keep=False)
+    if not _inside(new, app.config.instances_dir):
+        remember_external(app.paths, new)
+    if launcher is not None and record.profile:
+        profile = launcher.profiles().get(record.profile)
+        if profile and profile.version_id:
+            launcher.add_profile(
+                profile.name, profile.version_id, new, key=record.profile
+            )
+    where = new.name if new.parent == old.parent else str(new)
+    app.out.print(f"Moved {old.name} to {where}.")
+
+
+def _worlds(path: Path) -> int:
+    saves = path / "saves"
+    if not saves.is_dir():
+        return 0
+    return sum(1 for item in saves.iterdir() if (item / "level.dat").is_file())
+
+
+def delete_command(
+    ctx: typer.Context,
+    name: InstanceName = None,
+    yes: Yes = False,
+    force: Annotated[
+        bool, typer.Option("--force", help="Allow --yes for this command.")
+    ] = False,
+) -> None:
+    """Delete an instance's folder, worlds included, and its launcher installation."""
+    app = get(ctx)
+    instance, _ = resolve_instance(name, app.config, app.paths)
+    path = instance.path.resolve()
+    record = read_record(path)
+    game = GameDir(app.config.game_dir)
+    launcher = (
+        check_launcher(game, app.services.launcher_running())
+        if record.profile
+        else None
+    )
+    worlds = _worlds(path)
+    held = {0: "", 1: ", with its 1 world"}.get(worlds, f", with its {worlds} worlds")
+    app.out.print(f"Delete {path} and everything in it{held}. This cannot be undone.")
+    confirm_name(app, path.name, yes=yes, force=force)
+    instance.delete()
+    if launcher is not None and record.profile:
+        launcher.remove_profile(record.profile)
+    remember_external(app.paths, path, keep=False)
+    app.out.print(f"Deleted {path.name}.")

modsmith_cli/commands/list.py

@@ -0,0 +1,48 @@
+"""``modsmith list``: list the player's instances."""
+
+import typer
+from modsmith.instances import InstanceState
+from rich.table import Table
+from rich.text import Text
+
+from ..context import get
+from ..core.registry import list_instances
+from .install import loader_label
+
+
+def _loader(state: InstanceState) -> str:
+    if not state.loader_kind:
+        return "vanilla"
+    return loader_label(state.loader_kind, state.loader_version)
+
+
+def _pack(state: InstanceState) -> str:
+    if not state.pack_name:
+        return "-"
+    return " ".join(part for part in (state.pack_name, state.pack_version) if part)
+
+
+def list_command(ctx: typer.Context) -> None:
+    """List your instances."""
+    app = get(ctx)
+    entries = list_instances(app.config, app.paths)
+    if not entries:
+        app.out.print("No instances yet.")
+        app.out.print(
+            "Install a pack with modsmith install, or start one with modsmith create.",
+            style="dim",
+        )
+        return
+    table = Table(box=None, pad_edge=False)
+    for column in ("Name", "Minecraft", "Loader", "Pack"):
+        table.add_column(column)
+    table.add_column("Folder", overflow="fold")
+    for entry in entries:
+        folder = str(entry.path) if entry.external else ""
+        if entry.state is None:
+            problem = Text(entry.problem or "", style="red")
+            table.add_row(entry.name, "", "", problem, folder)
+            continue
+        state = entry.state
+        table.add_row(entry.name, state.minecraft, _loader(state), _pack(state), folder)
+    app.out.print(table)

modsmith_cli/commands/search.py

@@ -0,0 +1,205 @@
+"""``modsmith search``: find projects on Modrinth and CurseForge."""
+
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Annotated
+
+import typer
+from modsmith.errors import ModsmithError
+from modsmith.platforms import ProjectType, SearchResults, SearchSort
+from rich.table import Table
+from rich.text import Text
+
+from ..context import AppContext, get
+from ..core.config import PLATFORMS
+from ..core.errors import AppError
+from ..core.platforms import explained, platform_title
+from ..errors import report
+
+
+class Kind(StrEnum):
+    """The kinds of projects to search for."""
+
+    MOD = "mod"
+    MODPACK = "modpack"
+    RESOURCEPACK = "resourcepack"
+    SHADER = "shader"
+
+
+KINDS: dict[Kind, ProjectType] = {
+    Kind.MOD: "mod",
+    Kind.MODPACK: "modpack",
+    Kind.RESOURCEPACK: "resourcepack",
+    Kind.SHADER: "shader",
+}
+
+
+@dataclass(frozen=True)
+class Query:
+    """One search, as the player asked for it."""
+
+    text: str
+    kind: ProjectType
+    minecraft: str | None
+    loader: str | None
+    sort: SearchSort
+    limit: int
+
+
+# Narrower than this, the summary is left out.
+MIN_SUMMARY = 12
+
+
+class Order(StrEnum):
+    """How to order search results."""
+
+    RELEVANCE = "relevance"
+    DOWNLOADS = "downloads"
+    POPULARITY = "popularity"
+    NEWEST = "newest"
+    UPDATED = "updated"
+
+
+ORDERS: dict[Order, SearchSort] = {
+    Order.RELEVANCE: "relevance",
+    Order.DOWNLOADS: "downloads",
+    Order.POPULARITY: "popularity",
+    Order.NEWEST: "newest",
+    Order.UPDATED: "updated",
+}
+
+
+class Where(StrEnum):
+    """The platforms to search."""
+
+    MODRINTH = "modrinth"
+    CURSEFORGE = "curseforge"
+    ALL = "all"
+
+
+def _count(value: int) -> str:
+    """Shorten a download count, such as 1.2M."""
+    for size, suffix in ((1_000_000_000, "B"), (1_000_000, "M"), (1_000, "K")):
+        if value >= size:
+            return f"{value / size:.1f}".rstrip("0").rstrip(".") + suffix
+    return str(value)
+
+
+def _table(results: SearchResults, title: str | None, width: int) -> Table | None:
+    """Lay out results so the name to copy fits, and the summary takes the rest.
+
+    Returns None if the terminal is too narrow for the columns that must fit.
+    """
+    rows = [
+        (
+            project.name,
+            f"{project.platform}:{project.slug}",
+            _count(project.downloads),
+            _one_line(project.summary),
+        )
+        for project in results.projects
+    ]
+    headers = ("Name", "Use as", "Downloads")
+    widths = [
+        max(len(header), *(len(row[index]) for row in rows))
+        for index, header in enumerate(headers)
+    ]
+    # Rich squeezes every column to fit a long line, so the summary gets a cap.
+    room = width - sum(widths) - 2 * len(widths)
+    if room < 0:
+        return None
+    table = Table(title=title, title_justify="left", box=None, pad_edge=False)
+    table.add_column("Name", no_wrap=True)
+    table.add_column("Use as", no_wrap=True)
+    table.add_column("Downloads", justify="right", no_wrap=True)
+    if room >= MIN_SUMMARY:
+        table.add_column("Summary", no_wrap=True, overflow="ellipsis", max_width=room)
+    for row in rows:
+        table.add_row(*row[: len(table.columns)])
+    return table
+
+
+def _one_line(text: str) -> str:
+    """Join a text's lines, because some summaries hold line breaks."""
+    return " ".join(text.split())
+
+
+def _lines(results: SearchResults, title: str | None) -> Text:
+    """List results one per pair of lines, for narrow terminals."""
+    text = Text()
+    if title:
+        text.append(f"{title}\n", style="italic")
+    for project in results.projects:
+        text.append(project.name, style="bold")
+        text.append(f"  {_count(project.downloads)} downloads\n", style="dim")
+        text.append(f"  {project.platform}:{project.slug}\n")
+    text.rstrip()
+    return text
+
+
+def _search_one(app: AppContext, name: str, query: Query, title: str | None) -> None:
+    with explained(name), app.platform(name) as platform:
+        results = platform.search(
+            query.text,
+            project_type=query.kind,
+            game_version=query.minecraft,
+            loader=query.loader,
+            sort=query.sort,
+            limit=query.limit,
+        )
+    if results.projects:
+        table = _table(results, title, app.out.width)
+        if table is None:
+            app.out.print(_lines(results, title), soft_wrap=True)
+        else:
+            app.out.print(table)
+        shown = len(results.projects)
+        if results.total > shown:
+            app.err.print(f"Showing {shown} of {results.total}.", style="dim")
+    else:
+        app.out.print(Text(f"Nothing found on {platform_title(name)}.", style="dim"))
+
+
+def search_command(
+    ctx: typer.Context,
+    query: Annotated[str, typer.Argument(help="What to look for.", show_default=False)],
+    kind: Annotated[
+        Kind, typer.Option("--type", "-t", help="The kind of project.")
+    ] = Kind.MOD,
+    where: Annotated[
+        Where | None,
+        typer.Option(
+            "--platform", "-p", help="Where to search. Defaults to the setting."
+        ),
+    ] = None,
+    minecraft: Annotated[
+        str | None, typer.Option("--minecraft", "-m", help="Only this game version.")
+    ] = None,
+    loader: Annotated[
+        str | None, typer.Option("--loader", "-l", help="Only this mod loader.")
+    ] = None,
+    sort: Annotated[
+        Order, typer.Option("--sort", "-s", help="How to order the results.")
+    ] = Order.RELEVANCE,
+    limit: Annotated[int, typer.Option("--limit", "-n", min=1, max=100)] = 10,
+) -> None:
+    """Search for mods, modpacks, resource packs or shaders."""
+    app = get(ctx)
+    search = Query(query, KINDS[kind], minecraft, loader, ORDERS[sort], limit)
+    names = (
+        list(PLATFORMS)
+        if where == Where.ALL
+        else [(where or app.config.default_platform)]
+    )
+    failed = 0
+    for name in names:
+        heading = platform_title(name) if len(names) > 1 else None
+        try:
+            _search_one(app, str(name), search, heading)
+        except (AppError, ModsmithError) as e:
+            if len(names) == 1:
+                raise
+            failed += 1
+            report(e, app.err, prefix=f"Skipped {name}: ")
+    if failed == len(names):
+        raise typer.Exit(1)