stashapp-cli 0.1.0__py3-none-any.whl

stashapp_cli/commands/stashbox.py

@@ -0,0 +1,173 @@
+"""stashbox commands."""
+
+from __future__ import annotations
+
+import argparse
+
+from .. import core, queries, sources
+from ._common import CommandKind, add_leaf
+
+OPERATION = "submitStashBoxFingerprints"
+
+# Skip reasons, checked in this order.
+NO_STASH_ID_FOR_ENDPOINT = "no_stash_id_for_endpoint"
+NO_FILE_DURATION = "no_file_duration"
+NO_FINGERPRINTS = "no_fingerprints"
+
+# The fingerprint types that Stash sends, in report order.
+SUBMITTED_TYPES = ("md5", "oshash", "phash")
+
+
+def plan_submission(scenes: list[dict], endpoint: str) -> tuple[list[dict], list[dict]]:
+    """Split `scenes` into the ones Stash will submit and the ones it skips.
+
+    Mirrors `SubmitFingerprints` in Stash's `pkg/stashbox/scene.go`: a scene
+    needs a stash ID whose endpoint equals `endpoint` exactly, only files with
+    a duration above 0 are sent, and only MD5, OSHASH, and PHASH fingerprints
+    are sent. Recheck that function when Stash changes it.
+    """
+    submit: list[dict] = []
+    skip: list[dict] = []
+    for scene in scenes:
+        scene_id = str(scene["id"])
+        stash_ids = scene.get("stash_ids") or []
+        if not any(stash_id.get("endpoint") == endpoint for stash_id in stash_ids):
+            skip.append({"scene_id": scene_id, "reason": NO_STASH_ID_FOR_ENDPOINT})
+            continue
+        files = [
+            file for file in scene.get("files") or [] if (file.get("duration") or 0) > 0
+        ]
+        if not files:
+            skip.append({"scene_id": scene_id, "reason": NO_FILE_DURATION})
+            continue
+        found = {
+            str(fingerprint.get("type", "")).lower()
+            for file in files
+            for fingerprint in file.get("fingerprints") or []
+        }
+        fingerprints = [kind for kind in SUBMITTED_TYPES if kind in found]
+        if not fingerprints:
+            skip.append({"scene_id": scene_id, "reason": NO_FINGERPRINTS})
+            continue
+        submit.append(
+            {
+                "scene_id": scene_id,
+                "fingerprints": fingerprints,
+                "missing": [] if "phash" in fingerprints else ["phash"],
+            }
+        )
+    return submit, skip
+
+
+def _scene_ids(values: list[str]) -> list[str]:
+    for value in values:
+        if not (value.isascii() and value.isdigit()) or int(value) <= 0:
+            raise core.CliError(
+                f"--scene-id must be a positive integer, got {value!r}.",
+                2,
+                "usage_error",
+            )
+    return list(dict.fromkeys(values))
+
+
+def _submission_failed(endpoint: str, scene_ids: list[str], cause: str, reason: str):
+    return core.CliError(
+        f"Fingerprint submission to {endpoint} failed: {reason}. Some "
+        "fingerprints may already have been sent; Stash does not report which.",
+        1,
+        "fingerprint_submission_failed",
+        details={"endpoint": endpoint, "scene_ids": scene_ids, "cause": cause},
+    )
+
+
+def cmd_stashbox_submit_fingerprints(args: argparse.Namespace) -> object:
+    scene_ids = _scene_ids(args.scene_id)
+    endpoint = sources.resolve_stash_box(args.endpoint)["endpoint"]
+    scenes = queries.stashbox.get_scene_fingerprints(scene_ids)
+    by_id = {str(scene["id"]): scene for scene in scenes}
+    ordered = [by_id[scene_id] for scene_id in scene_ids]
+    submit, skip = plan_submission(ordered, endpoint)
+    input_data = {
+        "scene_ids": [entry["scene_id"] for entry in submit],
+        "stash_box_endpoint": endpoint,
+    }
+
+    applied = False
+    if args.apply and submit:
+        try:
+            result = queries.stashbox.submit_fingerprints(input_data)
+        except core.CliError as error:
+            if error.exit_code != 1:
+                raise
+            raise _submission_failed(
+                endpoint, input_data["scene_ids"], error.code, str(error)
+            ) from error
+        if result is not True:
+            raise _submission_failed(
+                endpoint,
+                input_data["scene_ids"],
+                "false_result",
+                "Stash returned false",
+            )
+        applied = True
+
+    return {
+        "applied": applied,
+        "operation": OPERATION,
+        "endpoint": endpoint,
+        "input": input_data,
+        "submit": submit,
+        "skip": skip,
+    }
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    stashbox = subparsers.add_parser(
+        "stashbox", help="Send data to a configured stash-box through Stash."
+    )
+    stashbox_sub = stashbox.add_subparsers(dest="stashbox_command", required=True)
+
+    submit = add_leaf(
+        stashbox_sub,
+        "submit-fingerprints",
+        kind=CommandKind.WRITE,
+        func=cmd_stashbox_submit_fingerprints,
+        help="Submit the fingerprints of matched scenes to a stash-box.",
+        examples=(
+            (
+                "stashapp-cli stashbox submit-fingerprints --endpoint ExampleBox "
+                "--scene-id 812"
+            ),
+            (
+                "stashapp-cli stashbox submit-fingerprints --endpoint "
+                "https://box.example/graphql --scene-id 812 --scene-id 813 --apply"
+            ),
+        ),
+    )
+    submit.description = (
+        "Report which scenes Stash would submit to the stash-box and which it\n"
+        "would skip, then, with --apply, submit only the eligible scenes.\n"
+        "\n"
+        "A scene needs a stash ID for the endpoint before it can be submitted;\n"
+        "add one with `scene update --add-stash-id`. A scene without a phash is\n"
+        "still submitted and lists phash in `missing`; `generate run --phashes`\n"
+        "adds it.\n"
+        "\n"
+        "Skip reasons:\n"
+        f"  {NO_STASH_ID_FOR_ENDPOINT}  the scene has no stash ID for the endpoint\n"
+        f"  {NO_FILE_DURATION}          no file has a duration above 0\n"
+        f"  {NO_FINGERPRINTS}           no such file has an md5, oshash, or phash"
+    )
+    submit.add_argument(
+        "--scene-id",
+        action="append",
+        required=True,
+        metavar="ID",
+        help="Scene to submit; repeat for more scenes.",
+    )
+    submit.add_argument(
+        "--endpoint",
+        required=True,
+        metavar="VALUE",
+        help="Configured stash-box endpoint URL or name (always required).",
+    )

stashapp_cli/commands/studio.py

@@ -0,0 +1,227 @@
+"""studio commands."""
+
+from __future__ import annotations
+
+import argparse
+
+from .. import core, queries
+from ._common import (
+    STUDIO_ALIASES,
+    TAG_IDS,
+    URLS,
+    CommandKind,
+    FindSpec,
+    add_find_options,
+    add_get_command,
+    add_leaf,
+    add_list_options,
+    add_update_target,
+    bulk_update_input,
+    find_filter,
+    mutation_result,
+    read_json_arg,
+    require_list_target,
+    resolve_update_input,
+    unique,
+)
+
+FIND = FindSpec("studios", "name", match_aliases=True, sort="name")
+
+
+def cmd_studio_find(args: argparse.Namespace) -> object:
+    return queries.studio.find_studios(
+        find_filter(args, FIND), args.page, args.per_page
+    )
+
+
+def cmd_studio_create(args: argparse.Namespace) -> object:
+    input_data = read_json_arg(args.input) if args.input is not None else {}
+    if not isinstance(input_data, dict):
+        raise core.CliError(
+            "--input must be a StudioCreateInput JSON object.", 2, "usage_error"
+        )
+    if args.name is not None:
+        input_data["name"] = args.name
+    if args.url is not None:
+        input_data["urls"] = args.url
+    if args.parent_id is not None:
+        input_data["parent_id"] = args.parent_id
+    if not input_data.get("name"):
+        raise core.CliError(
+            "Pass a studio NAME or a name in --input.", 2, "usage_error"
+        )
+    return mutation_result(
+        "studioCreate",
+        args.apply,
+        input_data,
+        lambda: queries.studio.create_studio(input_data),
+    )
+
+
+LIST_FIELDS = (TAG_IDS, URLS)
+
+
+def _usage_error(message: str) -> core.CliError:
+    return core.CliError(message, 2, "usage_error")
+
+
+def apply_alias_changes(
+    current: list[str], add: list[str], remove: list[str]
+) -> list[str]:
+    """The alias list after removing and then adding values.
+
+    Kept aliases keep their order, and new ones follow in the order first given.
+    Values are compared exactly.
+    """
+    aliases = [alias for alias in current if alias not in remove]
+    for alias in unique(add):
+        if alias not in aliases:
+            aliases.append(alias)
+    return aliases
+
+
+def _update_studio_aliases(args: argparse.Namespace, fields: dict) -> object:
+    """Read the studio, change its aliases, and send one studioUpdate."""
+    add, remove = args.add_alias or [], args.remove_alias or []
+    if "" in add + remove:
+        raise _usage_error("--add-alias and --remove-alias need a non-empty value.")
+    current = queries.studio.get_studio_aliases(args.id)
+    if current is None:
+        raise core.not_found_error("studio", args.id)
+    input_data = {
+        "id": args.id,
+        **fields,
+        "aliases": apply_alias_changes(current, add, remove),
+    }
+    return mutation_result(
+        "studioUpdate",
+        args.apply,
+        input_data,
+        lambda: queries.studio.update_studio(input_data),
+    )
+
+
+def cmd_studio_update(args: argparse.Namespace) -> object:
+    fields = {
+        field: value
+        for field, value in (
+            ("name", args.name),
+            ("parent_id", args.parent_id),
+            ("details", args.details),
+        )
+        if value is not None
+    }
+    bulk_input = bulk_update_input(args, LIST_FIELDS)
+    alias = bool(args.add_alias or args.remove_alias)
+    if bulk_input is not None or alias:
+        require_list_target(args)
+        if bulk_input is not None and (fields or alias):
+            raise _usage_error(
+                "The tag and URL options cannot be combined with --name, "
+                "--parent-id, --details, or the alias options; run two commands."
+            )
+    if bulk_input is not None:
+        return mutation_result(
+            "bulkStudioUpdate",
+            args.apply,
+            bulk_input,
+            lambda: queries.studio.bulk_update_studio(bulk_input),
+        )
+    if alias:
+        return _update_studio_aliases(args, fields)
+    input_data = resolve_update_input(args, fields)
+    return mutation_result(
+        "studioUpdate",
+        args.apply,
+        input_data,
+        lambda: queries.studio.update_studio(input_data),
+    )
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    studio = subparsers.add_parser("studio", help="Studio lookups and writes.")
+    studio_sub = studio.add_subparsers(dest="studio_command", required=True)
+
+    add_get_command(studio_sub, "studio", queries.studio.get_studio, example_id=13)
+
+    find = add_leaf(
+        studio_sub,
+        "find",
+        kind=CommandKind.READ,
+        func=cmd_studio_find,
+        help="Find studios by exact name or alias, or by a StudioFilterType.",
+        examples=(
+            "stashapp-cli studio find --name ExampleStudio",
+            "stashapp-cli studio find --name 'example studio online' | jq -r '.studios[0].id'",
+            "stashapp-cli studio find --filter-json '{\"favorite\": true}' --per-page 100",
+            "stashapp-cli studio find --name ExampleStudio --filter-json @studio-filter.json",
+        ),
+    )
+    add_find_options(find, FIND)
+
+    create = add_leaf(
+        studio_sub,
+        "create",
+        kind=CommandKind.WRITE,
+        func=cmd_studio_create,
+        help="Create a studio (dry-run by default; see global --apply).",
+        examples=(
+            "stashapp-cli studio create ExampleStudio --url https://example-studio.com",
+            "stashapp-cli studio create 'ExampleStudio Online' --parent-id 4",
+            "stashapp-cli studio create --input @studio.json",
+            "stashapp-cli studio create ExampleStudio --input @studio.json --apply",
+        ),
+    )
+    create.add_argument(
+        "name",
+        nargs="?",
+        default=None,
+        metavar="NAME",
+        help="Studio name; overrides name in --input.",
+    )
+    create.add_argument(
+        "--url",
+        action="append",
+        default=None,
+        help="May be given more than once; replaces urls in --input.",
+    )
+    create.add_argument(
+        "--parent-id",
+        default=None,
+        metavar="ID",
+        help="Parent studio; overrides parent_id.",
+    )
+    create.add_argument(
+        "--input",
+        default=None,
+        help="StudioCreateInput as JSON, @file, or @- (options override its fields).",
+    )
+
+    update = add_leaf(
+        studio_sub,
+        "update",
+        kind=CommandKind.WRITE,
+        func=cmd_studio_update,
+        help="Update a studio (dry-run by default; see global --apply).",
+        examples=(
+            "stashapp-cli studio update 13 --name 'Example Studio Online'",
+            "stashapp-cli studio update 13 --parent-id 4 --details 'Film studio' --apply",
+            "stashapp-cli studio update 13 --add-alias 'Example Studio'",
+            "stashapp-cli studio update 13 --add-tag-id 55 --remove-url https://old.example --apply",
+            "stashapp-cli studio update 13 --input @studio.json --apply",
+        ),
+    )
+    add_update_target(update, "StudioUpdateInput")
+    update.add_argument(
+        "--name", default=None, help="Studio name; overrides name in --input."
+    )
+    update.add_argument(
+        "--parent-id",
+        default=None,
+        metavar="ID",
+        help="Parent studio; overrides parent_id in --input.",
+    )
+    update.add_argument(
+        "--details", default=None, help="Description; overrides details in --input."
+    )
+    add_list_options(update, (TAG_IDS, URLS, STUDIO_ALIASES))