evo-cli 0.22.0__tar.gz → 0.23.0__tar.gz

{evo_cli-0.22.0 → evo_cli-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.22.0
+Version: 0.23.0
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli
@@ -19,6 +19,9 @@ Requires-Dist: paramiko>=2.7.0
 Requires-Dist: PyYAML>=6.0
 Requires-Dist: rich>=13.0
 Requires-Dist: rich-click>=1.8
+Provides-Extra: image
+Requires-Dist: Pillow>=10.0; extra == "image"
+Requires-Dist: numpy>=1.24; extra == "image"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"

evo_cli-0.23.0/evo_cli/VERSION

@@ -0,0 +1 @@
+0.23.0

{evo_cli-0.22.0 → evo_cli-0.23.0}/evo_cli/cli.py

@@ -12,6 +12,7 @@ from evo_cli.commands.gh import setup_gh
 from evo_cli.commands.harness import harness_group
 from evo_cli.commands.hwid import hwid
 from evo_cli.commands.hwid_reset import hwid_reset
+from evo_cli.commands.image import image_group
 from evo_cli.commands.localproxy import localproxy
 from evo_cli.commands.mcp import mcp_group
 from evo_cli.commands.miniconda import miniconda
@@ -70,6 +71,7 @@ cli.add_command(gdrive)
 cli.add_command(harness_group)
 cli.add_command(hwid)
 cli.add_command(hwid_reset)
+cli.add_command(image_group)
 cli.add_command(site2s)
 cli.add_command(localproxy)
 cli.add_command(mcp_group)

{evo_cli-0.22.0 → evo_cli-0.23.0}/evo_cli/commands/gdrive.py

@@ -1,18 +1,30 @@
 import base64
+import html
+import http.cookiejar
 import json
 import mimetypes
 import re
+import shutil
 import sys
 import urllib.error
 import urllib.parse
 import urllib.request
+import zipfile
 from datetime import datetime, timezone
 from pathlib import Path
 
 import rich_click as click
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    TextColumn,
+    TimeRemainingColumn,
+    TransferSpeedColumn,
+)
 from rich.text import Text
 
-from evo_cli.console import error, info, step, success, warning
+from evo_cli.console import console, error, info, step, success, warning
 from evo_cli.credentials import google_oauth
 from evo_cli.credentials.registry import dig, load_entries
 from evo_cli.credentials.store import compile_flat
@@ -22,8 +34,15 @@ TOKEN_URL = "https://oauth2.googleapis.com/token"
 DOCS_API = "https://docs.googleapis.com/v1/documents/{doc_id}"
 DRIVE_FILE_API = "https://www.googleapis.com/drive/v3/files/{file_id}"
 DRIVE_EXPORT_API = "https://www.googleapis.com/drive/v3/files/{file_id}/export"
+DRIVE_UC_DOWNLOAD = "https://drive.google.com/uc?export=download&id={file_id}"
+DOWNLOAD_CHUNK = 1 << 20
 
 DOC_ID_RE = re.compile(r"/document/d/([a-zA-Z0-9_-]+)")
+FILE_ID_RE = re.compile(r"/file/d/([a-zA-Z0-9_-]+)")
+QUERY_ID_RE = re.compile(r"[?&]id=([a-zA-Z0-9_-]+)")
+CONFIRM_ACTION_RE = re.compile(r"<form[^>]*id=\"download-form\"[^>]*action=\"([^\"]+)\"", re.IGNORECASE)
+CONFIRM_FIELD_RE = re.compile(r"<input[^>]*type=\"hidden\"[^>]*name=\"([^\"]+)\"[^>]*value=\"([^\"]*)\"", re.IGNORECASE)
+UNSAFE_NAME_RE = re.compile(r"[\\/:*?\"<>|]+")
 RAW_ID_RE = re.compile(r"^[a-zA-Z0-9_-]{20,}$")
 MD_INLINE_IMAGE_RE = re.compile(r"!\[([^\]]*)\]\((https?://[^)\s]+)\)")
 MD_REF_IMAGE_RE = re.compile(r"!\[([^\]]*)\]\[([^\]]+)\]")
@@ -39,6 +58,16 @@ EPILOG = Text.from_markup(
     "  [cyan]evo gdrive doc-read <url> --raw[/cyan]         also dump the raw API response"
 )
 
+GET_EPILOG = Text.from_markup(
+    "[bold]Examples[/bold]\n\n"
+    "  [cyan]evo gdrive get <url>[/cyan]                     save into the current directory\n"
+    "  [cyan]evo gdrive get <url> -o ./out[/cyan]            save into ./out\n"
+    "  [cyan]evo gdrive get <id> --unzip[/cyan]              extract the archive next to it\n"
+    "  [cyan]evo gdrive get <url> --name data.zip[/cyan]     override the name Drive sends\n\n"
+    "[dim]Large files get a virus-scan interstitial instead of bytes; this command\n"
+    "follows it with the confirm token, which is why `evo download` cannot fetch them.[/dim]"
+)
+
 
 def extract_doc_id(value):
     match = DOC_ID_RE.search(value)
@@ -49,6 +78,16 @@ def extract_doc_id(value):
     return None
 
 
+def extract_file_id(value):
+    for pattern in (FILE_ID_RE, DOC_ID_RE, QUERY_ID_RE):
+        match = pattern.search(value)
+        if match:
+            return match.group(1)
+    if RAW_ID_RE.match(value):
+        return value
+    return None
+
+
 def drive_entry():
     for path, entry in load_entries():
         if entry.get("id") == DRIVE_SERVICE_ID and entry.get("oauth"):
@@ -447,9 +486,168 @@ def run_doc_read(target, out_dir, no_images, raw, via_docs_api):
     success(f"Wrote [accent]{md_path}[/accent] ({len(markdown)} bytes)")
 
 
+def optional_access_token():
+    try:
+        return access_token()
+    except click.ClickException:
+        return None
+
+
+def drive_opener():
+    return urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+
+
+def open_drive_url(opener, url, token=None, timeout=120):
+    req = urllib.request.Request(url, method="GET")
+    req.add_header("User-Agent", "evo-cli")
+    if token:
+        req.add_header("Authorization", f"Bearer {token}")
+    return opener.open(req, timeout=timeout)
+
+
+def is_html_response(response):
+    return "text/html" in (response.headers.get("Content-Type") or "").lower()
+
+
+def parse_confirm_form(body):
+    match = CONFIRM_ACTION_RE.search(body)
+    if not match:
+        return None, {}
+    fields = {name: html.unescape(value) for name, value in CONFIRM_FIELD_RE.findall(body)}
+    return html.unescape(match.group(1)), fields
+
+
+def open_drive_download(file_id, token):
+    opener = drive_opener()
+    response = open_drive_url(opener, DRIVE_UC_DOWNLOAD.format(file_id=file_id), token=token)
+    if not is_html_response(response):
+        return response
+    body = response.read().decode("utf-8", "replace")
+    response.close()
+    action, fields = parse_confirm_form(body)
+    if not action:
+        return None
+    info("Virus-scan interstitial - re-issuing with the confirm token.")
+    response = open_drive_url(opener, action + "?" + urllib.parse.urlencode(fields), token=token)
+    if is_html_response(response):
+        response.close()
+        return None
+    return response
+
+
+def open_drive_file(file_id):
+    token = optional_access_token()
+    if token:
+        try:
+            response = open_drive_download(file_id, token)
+        except urllib.error.HTTPError as exc:
+            warning(f"Drive OAuth path failed: HTTP {exc.code}.")
+            response = None
+        if response is not None:
+            return response
+        info("Falling back to the anonymous public download path.")
+    try:
+        response = open_drive_download(file_id, None)
+    except urllib.error.HTTPError as exc:
+        raise click.ClickException(f"download failed: HTTP {exc.code} {exc.reason}") from exc
+    if response is None:
+        raise click.ClickException(
+            "Drive answered with HTML instead of file bytes. The file may be private, "
+            "over its download quota, or removed."
+        )
+    return response
+
+
+def safe_download_name(name):
+    cleaned = UNSAFE_NAME_RE.sub("_", name).strip().strip(".")
+    return cleaned or "download.bin"
+
+
+def stream_to_file(response, dest):
+    total = int(response.headers.get("Content-Length") or 0)
+    columns = [
+        TextColumn("[info]{task.description}[/info]"),
+        BarColumn(),
+        DownloadColumn(),
+        TransferSpeedColumn(),
+        TimeRemainingColumn(),
+    ]
+    with Progress(*columns, console=console) as progress:
+        task = progress.add_task(dest.name, total=total or None)
+        with open(dest, "wb") as handle:
+            while True:
+                chunk = response.read(DOWNLOAD_CHUNK)
+                if not chunk:
+                    break
+                handle.write(chunk)
+                progress.update(task, advance=len(chunk))
+    return dest
+
+
+def skip_archive_member(name):
+    parts = [part for part in name.replace("\\", "/").split("/") if part]
+    if not parts:
+        return True
+    return "__MACOSX" in parts or parts[-1] == ".DS_Store"
+
+
+def safe_member_path(dest_dir, name):
+    root = dest_dir.resolve()
+    target = (dest_dir / name).resolve()
+    if target != root and root not in target.parents:
+        return None
+    return target
+
+
+def extract_archive(archive, dest_dir):
+    if not zipfile.is_zipfile(archive):
+        warning(f"{archive.name} is not a zip archive - skipping --unzip.")
+        return 0
+    written = 0
+    with zipfile.ZipFile(archive) as bundle:
+        for member in bundle.infolist():
+            if member.is_dir() or skip_archive_member(member.filename):
+                continue
+            target = safe_member_path(dest_dir, member.filename)
+            if target is None:
+                warning(f"Skipping archive entry outside the output folder: {member.filename}")
+                continue
+            target.parent.mkdir(parents=True, exist_ok=True)
+            with bundle.open(member) as source, open(target, "wb") as handle:
+                shutil.copyfileobj(source, handle, DOWNLOAD_CHUNK)
+            written += 1
+    return written
+
+
+def run_get(target, out_dir, unzip, name):
+    file_id = extract_file_id(target)
+    if not file_id:
+        raise click.ClickException("could not extract a Google Drive file ID from input.")
+    info(f"File ID: [accent]{file_id}[/accent]")
+
+    dest_dir = Path(out_dir) if out_dir else Path.cwd()
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    response = open_drive_file(file_id)
+    try:
+        filename = name or parse_filename_from_disposition(dict(response.headers)) or f"{file_id}.bin"
+        dest = dest_dir / safe_download_name(filename)
+        info(f"Saving to [accent]{dest}[/accent]")
+        stream_to_file(response, dest)
+    finally:
+        response.close()
+    success(f"Downloaded [accent]{dest.name}[/accent] ({dest.stat().st_size} bytes)")
+
+    if unzip:
+        step("Extract archive")
+        written = extract_archive(dest, dest_dir)
+        if written:
+            success(f"Extracted [accent]{written}[/accent] files into [accent]{dest_dir}[/accent]")
+
+
 @click.group("gdrive")
 def gdrive():
-    """**Google Drive** helpers. Read Google Docs (text + images) from URL or ID."""
+    """**Google Drive** helpers. Read Google Docs and download files from URL or ID."""
 
 
 @gdrive.command("doc-read", epilog=EPILOG)
@@ -482,3 +680,41 @@ def doc_read(target, out_dir, no_images, raw, via_docs_api):
     except Exception as exc:
         error(str(exc))
         sys.exit(1)
+
+
+@gdrive.command(
+    "get",
+    epilog=GET_EPILOG,
+    context_settings={"help_option_names": ["-h", "--help"]},
+    help=(
+        "Download a Drive file from `TARGET` (share URL or raw file ID).\n\n"
+        "Google answers the download endpoint for a large file with an HTML "
+        "virus-scan interstitial instead of bytes; this command re-issues the "
+        "request with the confirm token and uuid that form carries, which is why "
+        "`evo download` cannot fetch these URLs. The stored `google_drive` OAuth "
+        "token is tried first, then the anonymous public path, so a private file "
+        "you do own still works.\n\n"
+        "With `--unzip` the archive is extracted next to it, skipping `__MACOSX/` "
+        "and `.DS_Store`."
+    ),
+)
+@click.argument("target")
+@click.option(
+    "-o",
+    "--output",
+    "out_dir",
+    type=click.Path(file_okay=False),
+    default=None,
+    help="Output folder. Default: the current directory.",
+)
+@click.option("--unzip", is_flag=True, help="Extract the downloaded archive into the output folder.")
+@click.option("--name", default=None, metavar="FILENAME", help="Save under this name instead of the one Drive sends.")
+def get_cmd(target, out_dir, unzip, name):
+    step("evo gdrive get")
+    try:
+        run_get(target, out_dir, unzip, name)
+    except click.ClickException:
+        raise
+    except Exception as exc:
+        error(str(exc))
+        sys.exit(1)

evo_cli-0.23.0/evo_cli/commands/image.py

@@ -0,0 +1,293 @@
+import ctypes.util
+import importlib.metadata
+import os
+import sys
+from pathlib import Path
+
+import rich_click as click
+from rich.markup import escape
+from rich.table import Table
+from rich.text import Text
+
+from evo_cli.console import console, info, step, success, warning
+from evo_cli.imaging import core, load_numpy, load_pillow, ncnn
+from evo_cli.imaging.creds import has_gemini_credentials
+from evo_cli.imaging.errors import ImagingError
+
+OUTPUT_CHOICES = ("master", "ui", "both")
+PROVIDER_CHOICES = ("auto", "gemini", "ncnn")
+DEFAULT_OUT_DIR = "image-out"
+IMAGE_EXTRA_FIX = "run `pip install evo_cli[image]`"
+BINARY_FIX = "run `evo image install`"
+MODEL_FIX = f"`evo image install` fetches {ncnn.DEFAULT_MODEL}"
+VULKAN_FIX = "install the GPU driver / Vulkan runtime the local engine needs"
+GEMINI_FIX = "run `evo cred add gemini_api_key --from-stdin`"
+
+EPILOG = Text.from_markup(
+    "[bold]Examples[/bold]\n\n"
+    "  [cyan]evo image upscale hero.png[/cyan]                    one file into ./image-out\n"
+    "  [cyan]evo image upscale ./in -o ./out[/cyan]               master + ui + report.json\n"
+    "  [cyan]evo image upscale ./in -o ./out --dry-run[/cyan]     count what is cached\n"
+    "  [cyan]evo image upscale ./in --provider ncnn[/cyan]        force the local engine\n"
+    "  [cyan]evo image upscale ./in --only ui --scale 0.5[/cyan]  half-size UI set\n"
+    "  [cyan]evo image upscale ./in --force[/cyan]                ignore the cache\n"
+    "  [cyan]evo image check[/cyan]                               is every moving part there?\n"
+    "  [cyan]evo image install[/cyan]                             fetch upscayl-bin + model\n\n"
+    "[dim]Gemini renders when its key is stored, upscayl-ncnn otherwise.\n"
+    "Every render is cached by content hash, so a second run is free.[/dim]"
+)
+
+UPSCALE_EPILOG = Text.from_markup(
+    "[bold]Examples[/bold]\n\n"
+    "  [cyan]evo image upscale ./in -o ./out[/cyan]         master + ui + report.json\n"
+    "  [cyan]evo image upscale ./in -o ./out --dry-run[/cyan]  prints `cached: <n>`\n"
+    "  [cyan]evo image upscale ./in --model remacri-4x[/cyan]  pick the local model\n"
+    "  [cyan]evo image upscale card.png --only master[/cyan]   skip the UI set\n\n"
+    "[dim]`master` keeps the rendered resolution, `ui` lands on the size the\n"
+    "filename declares (`name_256x256.png`), or the preset ratio otherwise.[/dim]"
+)
+
+
+def pillow_version():
+    try:
+        load_pillow()
+    except ImagingError:
+        return None
+    try:
+        return importlib.metadata.version("pillow")
+    except importlib.metadata.PackageNotFoundError:
+        return "installed"
+
+
+def numpy_version():
+    try:
+        numpy = load_numpy()
+    except ImagingError:
+        return None
+    return getattr(numpy, "__version__", "installed")
+
+
+def vulkan_loader():
+    if os.name == "nt":
+        names = ("vulkan-1",)
+    elif sys.platform == "darwin":
+        names = ("vulkan", "MoltenVK")
+    else:
+        names = ("vulkan",)
+    for name in names:
+        found = ctypes.util.find_library(name)
+        if found:
+            return found
+    return None
+
+
+def installed_models():
+    root = ncnn.models_dir()
+    if not root.is_dir():
+        return []
+    return [name for name in ncnn.MODELS if all((root / f"{name}.{ext}").is_file() for ext in ncnn.MODEL_EXTS)]
+
+
+def environment_parts():
+    binary = ncnn.find_binary()
+    models = installed_models()
+    return [
+        ("Pillow", pillow_version(), IMAGE_EXTRA_FIX),
+        ("numpy", numpy_version(), IMAGE_EXTRA_FIX),
+        ("upscayl-bin", str(binary) if binary else None, BINARY_FIX),
+        ("Models", ", ".join(models) if ncnn.DEFAULT_MODEL in models else None, MODEL_FIX),
+        ("Vulkan", vulkan_loader(), VULKAN_FIX),
+        ("Gemini key", "gemini_api_key" if has_gemini_credentials() else None, GEMINI_FIX),
+    ]
+
+
+def report_environment():
+    console.print()
+    table = Table(show_header=True, header_style="accent", expand=False)
+    table.add_column("Component", style="info", no_wrap=True)
+    table.add_column("Status", no_wrap=True)
+    table.add_column("Detail", style="dim")
+    missing = []
+    for name, detail, fix in environment_parts():
+        if detail:
+            table.add_row(name, "[success]ok[/success]", escape(str(detail)))
+        else:
+            missing.append(name)
+            table.add_row(name, "[error]missing[/error]", fix)
+    table.add_row("Cache", "[info]-[/info]", escape(str(core.cache_root())))
+    console.print(table)
+    return missing
+
+
+def build_settings(preset_name, provider, model, scale, only):
+    return core.preset(
+        preset_name,
+        provider=core.resolve_provider(provider),
+        model=model,
+        master_scale=scale,
+        outputs=list(core.OUTPUT_SETS) if only == "both" else [only],
+    )
+
+
+@click.group(
+    "image",
+    epilog=EPILOG,
+    context_settings={"help_option_names": ["-h", "--help"]},
+    help=(
+        "Upscale images with **Gemini** or **upscayl-ncnn**.\n\n"
+        "`upscale` walks a file or a whole tree and writes two PNG sets - `master` at the "
+        "rendered resolution and `ui` at the size each filename declares - plus a "
+        "`report.json` recording which engine shipped every image. Renders are cached by "
+        "content hash, so re-running over the same tree is free.\n\n"
+        "`check` says which moving part is missing, `install` fetches the local engine."
+    ),
+)
+def image_group():
+    pass
+
+
+@image_group.command(
+    "upscale",
+    epilog=UPSCALE_EPILOG,
+    help=(
+        "Upscale `SOURCE` - one image or a directory tree.\n\n"
+        "The output tree mirrors the input under `<out>/master` and `<out>/ui`, keeping "
+        "alpha where the source had it, and `<out>/report.json` lists the engine, the "
+        "sizes and the timings per image."
+    ),
+)
+@click.argument("source", type=click.Path(exists=True))
+@click.option(
+    "-o",
+    "--output",
+    "out_dir",
+    type=click.Path(file_okay=False),
+    default=DEFAULT_OUT_DIR,
+    show_default=True,
+    help="Where `master/`, `ui/` and `report.json` land.",
+)
+@click.option(
+    "--preset",
+    "preset_name",
+    type=click.Choice(sorted(core.PRESETS)),
+    default=core.DEFAULT_PRESET,
+    show_default=True,
+    help="Measured defaults to start from.",
+)
+@click.option(
+    "--provider",
+    type=click.Choice(PROVIDER_CHOICES),
+    default="auto",
+    show_default=True,
+    help="`auto` picks Gemini when its key is stored, else the local engine.",
+)
+@click.option(
+    "--model",
+    type=click.Choice(ncnn.MODELS),
+    default=None,
+    help=f"Local upscayl model. Default: `{ncnn.DEFAULT_MODEL}`.",
+)
+@click.option("--scale", type=float, default=None, help="Master size relative to the source. Default: `1.0`.")
+@click.option(
+    "--only",
+    type=click.Choice(OUTPUT_CHOICES),
+    default="both",
+    show_default=True,
+    help="Write just one of the two output sets.",
+)
+@click.option("-j", "--jobs", type=int, default=4, show_default=True, help="Images in flight at once.")
+@click.option("--dry-run", is_flag=True, help="Report what the cache already covers and write nothing.")
+@click.option("--force", is_flag=True, help="Render again even when the cache has the image.")
+def upscale_cmd(source, out_dir, preset_name, provider, model, scale, only, jobs, dry_run, force):
+    step("evo image upscale")
+    try:
+        settings = build_settings(preset_name, provider, model, scale, only)
+        sources = core.find_sources(source)
+    except ImagingError as exc:
+        raise click.ClickException(str(exc)) from exc
+
+    info(
+        f"{len(sources)} image(s), engine [accent]{settings['provider']}[/accent], "
+        f"sets [accent]{', '.join(settings['outputs'])}[/accent]"
+    )
+
+    if dry_run:
+        results = core.process_many(
+            sources, out_dir, root=source, settings=settings, jobs=jobs, force=force, dry_run=True
+        )
+        ready = sum(1 for item in results if item.get("cached"))
+        info(f"Dry run: {len(results)} images, cached: {ready}, to render: {len(results) - ready}")
+        return
+
+    done = []
+
+    def on_item(entry):
+        done.append(entry)
+        state = entry.get("error") or ("cached" if entry.get("cached") else entry.get("engine") or "done")
+        info(f"{len(done)}/{len(sources)} {escape(str(entry.get('file')))} - {escape(str(state))}")
+
+    results = core.process_many(
+        sources, out_dir, root=source, settings=settings, jobs=jobs, force=force, on_item=on_item
+    )
+    failed = [item for item in results if item and item.get("error")]
+    cached = sum(1 for item in results if item and item.get("cached"))
+    for item in failed:
+        warning(f"{escape(str(item.get('file')))}: {escape(str(item['error']))}")
+    info(f"cached: {cached}, rendered: {len(results) - cached - len(failed)}, failed: {len(failed)}")
+    if failed:
+        raise click.ClickException(f"{len(failed)} of {len(results)} images failed.")
+    success(
+        f"Wrote {', '.join(settings['outputs'])} + {core.REPORT_NAME} "
+        f"under [accent]{escape(str(Path(out_dir)))}[/accent]"
+    )
+
+
+@image_group.command(
+    "check",
+    help=(
+        "Verify every moving part: Pillow, numpy, the upscayl binary, the model files, "
+        "a Vulkan device and the Gemini key. Exits non-zero when one is missing."
+    ),
+)
+def check_cmd():
+    step("evo image check")
+    missing = report_environment()
+    if missing:
+        raise click.ClickException(
+            f"missing: {', '.join(missing)}. "
+            "Run `evo image install` for the local engine, "
+            "`evo cred add gemini_api_key --from-stdin` for the hosted one."
+        )
+    success("Ready to upscale.")
+
+
+@image_group.command(
+    "install",
+    help=(
+        "Fetch **upscayl-bin** and the default model ahead of time.\n\n"
+        "Everything lands under `~/.evo/upscayl` (or `$EVO_UPSCAYL_DIR`), so the first "
+        "`evo image upscale` does not stop to download."
+    ),
+)
+@click.option(
+    "-m",
+    "--model",
+    "models",
+    type=click.Choice(ncnn.MODELS),
+    multiple=True,
+    help=f"Model to fetch; repeatable. Default: `{ncnn.DEFAULT_MODEL}`.",
+)
+@click.option("--all-models", is_flag=True, help="Fetch every model upscayl ships.")
+def install_cmd(models, all_models):
+    step("evo image install")
+    wanted = list(ncnn.MODELS) if all_models else list(models) or [ncnn.DEFAULT_MODEL]
+    try:
+        binary = ncnn.ensure_binary()
+        info(f"upscayl-bin at [accent]{escape(str(binary))}[/accent]")
+        for name in wanted:
+            ncnn.ensure_model(name)
+            info(f"model [accent]{name}[/accent] ready")
+    except ImagingError as exc:
+        raise click.ClickException(str(exc)) from exc
+    report_environment()
+    success("Local engine ready.")

{evo_cli-0.22.0 → evo_cli-0.23.0}/evo_cli/credentials/registry.py

@@ -78,7 +78,7 @@ SPECS = [
         "category": "ai",
         "type": "api_key",
         "lifetime": "stable",
-        "description": "Gemini API key (evo tts gemini provider, generateContent)",
+        "description": "Gemini API key (evo tts gemini provider, evo image upscale, generateContent)",
         "rotate": "https://aistudio.google.com/apikey -> create or rotate the key",
         "keys": ["gemini_api_key"],
     },

evo_cli-0.23.0/evo_cli/imaging/__init__.py

@@ -0,0 +1,28 @@
+from evo_cli.imaging.errors import ImagingError
+
+IMAGE_EXTRA_HINT = "Pillow and numpy are required for image work.\nInstall them with:\n  pip install evo_cli[image]"
+
+
+def load_pillow():
+    try:
+        from PIL import Image
+    except ImportError as exc:
+        raise ImagingError(IMAGE_EXTRA_HINT) from exc
+    Image.MAX_IMAGE_PIXELS = None
+    return Image
+
+
+def load_numpy():
+    try:
+        import numpy
+    except ImportError as exc:
+        raise ImagingError(IMAGE_EXTRA_HINT) from exc
+    return numpy
+
+
+__all__ = [
+    "IMAGE_EXTRA_HINT",
+    "ImagingError",
+    "load_numpy",
+    "load_pillow",
+]