calkit-python 0.50.2__py3-none-any.whl → 0.50.4__py3-none-any.whl

calkit/cli/check.py

@@ -16,7 +16,7 @@ import dotenv
 import typer
 
 import calkit
-from calkit.cli import AliasGroup, raise_error, warn
+from calkit.cli import AliasGroup, raise_error, warn, warn_app_control
 from calkit.core import get_md5
 
 
@@ -605,6 +605,7 @@ def check_environment(
         try:
             subprocess.check_call(cmd)
         except subprocess.CalledProcessError:
+            warn_app_control(maybe=True)
             raise_error("Failed to check pixi environment")
     elif env["kind"] == "uv":
         cmd = ["uv", "sync"]
@@ -616,6 +617,7 @@ def check_environment(
         try:
             subprocess.check_call(cmd)
         except subprocess.CalledProcessError:
+            warn_app_control(maybe=True)
             raise_error("Failed to check uv environment")
     elif (kind := env["kind"]) in ["uv-venv", "venv"]:
         if "path" not in env:
@@ -1835,6 +1837,7 @@ def check_conda_env(
             verbose=not quiet,
         )
     except Exception as e:
+        warn_app_control(output=str(e), maybe=True)
         raise_error(f"Failed to check conda environment: {e}")
 
 
@@ -1917,6 +1920,7 @@ def check_venv(
         try:
             subprocess.check_call(create_cmd + [prefix], cwd=wdir)
         except subprocess.CalledProcessError:
+            warn_app_control(maybe=True)
             raise_error(f"Failed to create {kind} at {prefix}")
         # Put a gitignore file in the env dir if one doesn't exist
         gitignore_fpath = os.path.join(prefix_full_path, ".gitignore")
@@ -2117,6 +2121,7 @@ def check_venv(
             pip_install_and_freeze(dep_file_txt)
         except (subprocess.CalledProcessError, OSError):
             if lock_is_current:
+                warn_app_control(maybe=True)
                 raise_error(
                     f"Failed to create {kind} at {prefix} from its lock file "
                     f"({lock_fpath}), which matches the spec ({path}). "
@@ -2132,6 +2137,7 @@ def check_venv(
             try:
                 pip_install_and_freeze(f"-r {path}")
             except subprocess.CalledProcessError:
+                warn_app_control(maybe=True)
                 raise_error(f"Failed to check {kind} from input file {path}")
 
 

calkit/cli/core.py

@@ -184,3 +184,35 @@ def warn(txt: str, prefix: str = "Warning: ", err: bool = False):
     text = typer.style(prefix + encode_safe(str(txt), err=err), fg="yellow")
     if not _echo_above_spinner(text, err=err):
         typer.echo(text, err=err)
+
+
+def warn_app_control(
+    output: str = "", returncode: int | None = None, maybe: bool = False
+) -> None:
+    """Explain a failure Windows App Control may have caused.
+
+    Smart App Control blocks unsigned executables and DLLs it doesn't trust,
+    which environments are full of, and the failure reads as unrelated.
+    Pass ``maybe`` for a failure whose output went straight to the terminal,
+    to warn whenever Smart App Control is on.
+    """
+    from calkit.windows import (
+        SMART_APP_CONTROL_DOCS_URL,
+        app_control_blocked,
+        smart_app_control_on,
+    )
+
+    if app_control_blocked(output=output, returncode=returncode):
+        warn(
+            "Windows blocked a file from running, which Smart App Control "
+            "does to unsigned files it doesn't trust; see "
+            f"{SMART_APP_CONTROL_DOCS_URL}",
+            err=True,
+        )
+    elif maybe and smart_app_control_on():
+        warn(
+            "Smart App Control is on, which can block files in environments "
+            "from running; if the output above says a file was blocked, see "
+            f"{SMART_APP_CONTROL_DOCS_URL}",
+            err=True,
+        )

calkit/cli/export.py

@@ -0,0 +1,139 @@
+"""CLI for exporting data and artifacts from various apps, e.g., a PNG
+from an Inkscape SVG.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+import typer
+from typing_extensions import Annotated
+
+from calkit.cli import raise_error
+
+if TYPE_CHECKING:
+    from calkit.export import Exporter
+
+export_app = typer.Typer(no_args_is_help=True)
+
+
+def _prepare(exporter: Exporter, source: str, output: str) -> str:
+    """Get ready to export, returning the executable to run."""
+    exporter.check(source, output)
+    if not os.path.isfile(source):
+        raise ValueError(f"'{source}' doesn't exist")
+    os.makedirs(os.path.dirname(output) or ".", exist_ok=True)
+    # What was there is from before, so it can't pass for a new export
+    if os.path.exists(output):
+        os.remove(output)
+    exe = exporter.find_executable()
+    if exe is None:
+        raise ValueError(
+            f"Exporting '{source}' needs {exporter.app} installed"
+        )
+    return exe
+
+
+def inkscape(source: str, output: str, dpi: int | None = None) -> None:
+    """Export a drawing to the format ``output``'s extension names,
+    raising ``ValueError`` if it can't be.
+    """
+    import subprocess
+
+    from calkit.export import INKSCAPE
+
+    exe = _prepare(INKSCAPE, source, output)
+    cmd = [exe, source, f"--export-filename={output}"]
+    if dpi is not None:
+        cmd.append(f"--export-dpi={dpi}")
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if not os.path.isfile(output):
+        detail = (result.stderr or result.stdout or "").strip()
+        raise ValueError(
+            f"Inkscape didn't export '{output}' from '{source}'"
+            + (f": {detail.splitlines()[-1]}" if detail else "")
+        )
+
+
+def gimp(source: str, output: str) -> None:
+    """Flatten a GIMP document into the format ``output``'s extension
+    names, raising ``ValueError`` if it can't be.
+
+    Runs GIMP 3's batch dialect, then GIMP 2's, which differ in their file
+    procedures. Neither reports a failed script in its exit code, so the
+    written file is what says it worked.
+    """
+    import subprocess
+
+    from calkit.export import GIMP
+
+    exe = _prepare(GIMP, source, output)
+    src = os.path.abspath(source).replace("\\", "\\\\").replace('"', '\\"')
+    dst = os.path.abspath(output).replace("\\", "\\\\").replace('"', '\\"')
+    v3 = (
+        f'(let* ((image (car (gimp-file-load RUN-NONINTERACTIVE "{src}"))))'
+        "  (gimp-image-flatten image)"
+        f'  (gimp-file-save RUN-NONINTERACTIVE image "{dst}" "{dst}")'
+        "  (gimp-image-delete image)"
+        "  (gimp-quit 0))"
+    )
+    v2 = (
+        "(let* ((image (car (gimp-file-load RUN-NONINTERACTIVE "
+        f'"{src}" "{src}")))'
+        "       (drawable (car (gimp-image-flatten image))))"
+        f'  (gimp-file-save RUN-NONINTERACTIVE image drawable "{dst}" '
+        f'"{dst}")'
+        "  (gimp-image-delete image)"
+        "  (gimp-quit 0))"
+    )
+    detail = ""
+    for cmd in [
+        [exe, "-i", "--batch-interpreter=plug-in-script-fu-eval", "-b", v3],
+        [exe, "-i", "-b", v2],
+    ]:
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if os.path.isfile(output):
+            return
+        detail = (result.stderr or result.stdout or "").strip()
+    raise ValueError(
+        f"GIMP didn't export '{output}' from '{source}'"
+        + (f": {detail.splitlines()[-1]}" if detail else "")
+    )
+
+
+@export_app.command(name="inkscape", help="Export a figure from an SVG.")
+def export_inkscape(
+    source: Annotated[str, typer.Argument(help="SVG to export from.")],
+    output: Annotated[
+        str,
+        typer.Option(
+            "--output", "-o", help="File to export to, e.g., a PNG or PDF."
+        ),
+    ],
+    dpi: Annotated[
+        int | None, typer.Option("--dpi", help="Resolution of a PNG.")
+    ] = None,
+) -> None:
+    try:
+        inkscape(source, output, dpi=dpi)
+    except ValueError as e:
+        raise_error(str(e))
+
+
+@export_app.command(
+    name="gimp", help="Export a flattened figure from an XCF file."
+)
+def export_gimp(
+    source: Annotated[str, typer.Argument(help="XCF file to export from.")],
+    output: Annotated[
+        str,
+        typer.Option(
+            "--output", "-o", help="File to export to, e.g., a PNG or TIFF."
+        ),
+    ],
+) -> None:
+    try:
+        gimp(source, output)
+    except ValueError as e:
+        raise_error(str(e))