stashapp-cli 0.1.0__py3-none-any.whl

stashapp_cli/queries/backup.py

@@ -0,0 +1,20 @@
+"""Database backup."""
+
+from __future__ import annotations
+
+from .. import core
+
+_BACKUP_DATABASE_MUTATION = """
+mutation BackupDatabase($input: BackupDatabaseInput!) {
+  backupDatabase(input: $input)
+}
+"""
+
+
+def backup_database(download: bool) -> str | None:
+    """Back up the database; returns the download URL, or None without download.
+
+    Stash runs the backup before it answers; this is not a job.
+    """
+    data = core.call(_BACKUP_DATABASE_MUTATION, {"input": {"download": download}})
+    return data.get("backupDatabase")

stashapp_cli/queries/group.py

@@ -0,0 +1,117 @@
+"""Group lookups and writes."""
+
+from __future__ import annotations
+
+from .. import core
+from ._get import ObjectSpec, get_object
+from ._image_flags import add_page_image_flags
+
+_IMAGE_FLAGS = {
+    "front_image_path": "has_front_image",
+    "back_image_path": "has_back_image",
+}
+
+_GROUP_FIELDS = """
+      id
+      name
+      aliases
+      synopsis
+      date
+      director
+      front_image_path
+      back_image_path
+      urls
+      custom_fields
+      studio { id }
+      tags { id }
+"""
+
+GROUP = ObjectSpec("findGroup", _GROUP_FIELDS, _IMAGE_FLAGS)
+
+
+def get_group(group_id: str) -> dict | None:
+    """One group by id, in the shape find_groups returns, or `None`."""
+    return get_object(GROUP, group_id)
+
+
+_FIND_GROUPS_QUERY = f"""
+query FindGroups($group_filter: GroupFilterType!, $page: Int!, $per_page: Int!) {{
+  findGroups(
+    group_filter: $group_filter
+    filter: {{page: $page, per_page: $per_page, sort: "name", direction: ASC}}
+  ) {{
+    count
+    groups {{
+{_GROUP_FIELDS}
+    }}
+  }}
+}}
+"""
+
+
+def find_groups(group_filter: dict, page: int, per_page: int = 50) -> dict:
+    """One page of the groups matching a Stash group filter.
+
+    Each group also gets `has_front_image` and `has_back_image` flags; see
+    `_image_flags` for the rule.
+    """
+    result = core.call(
+        _FIND_GROUPS_QUERY,
+        {"group_filter": group_filter, "page": page, "per_page": per_page},
+    )["findGroups"]
+    return add_page_image_flags(result, "groups", _IMAGE_FLAGS)
+
+
+_CREATE_GROUP_MUTATION = """
+mutation CreateGroup($input: GroupCreateInput!) {
+  groupCreate(input: $input) {
+    id
+    name
+  }
+}
+"""
+
+
+def create_group(input_data: dict) -> str:
+    data = core.call(_CREATE_GROUP_MUTATION, {"input": input_data})
+    return data["groupCreate"]["id"]
+
+
+_UPDATE_GROUP_MUTATION = """
+mutation UpdateGroup($input: GroupUpdateInput!) {
+  groupUpdate(input: $input) {
+    id
+    name
+  }
+}
+"""
+
+
+def update_group(input_data: dict) -> str:
+    data = core.call(_UPDATE_GROUP_MUTATION, {"input": input_data})
+    return data["groupUpdate"]["id"]
+
+
+_BULK_UPDATE_GROUP_MUTATION = """
+mutation BulkUpdateGroup($input: BulkGroupUpdateInput!) {
+  bulkGroupUpdate(input: $input) {
+    id
+  }
+}
+"""
+
+# Stash's whole error message for a bulkGroupUpdate of a missing group. It is
+# generic, so it is matched exactly rather than as a substring.
+_BULK_GROUP_NOT_FOUND = f"{core.GRAPHQL_ERROR_PREFIX}not found"
+
+
+def bulk_update_group(input_data: dict) -> str:
+    """Send a one-group bulkGroupUpdate and return the group id."""
+    (group_id,) = input_data["ids"]
+    try:
+        data = core.call(_BULK_UPDATE_GROUP_MUTATION, {"input": input_data})
+    except core.CliError as error:
+        if error.code == "graphql_error" and str(error) == _BULK_GROUP_NOT_FOUND:
+            raise core.not_found_error("group", group_id) from error
+        raise
+    return core.returned_id("bulkGroupUpdate", data, group_id)

stashapp_cli/queries/job.py

@@ -0,0 +1,29 @@
+"""Background job state.
+
+Stash keeps only its most recent finished jobs, so a finished job can
+disappear. `subTasks` is not selected, to keep the result bounded.
+"""
+
+from __future__ import annotations
+
+from .. import core
+
+_FIND_JOB_QUERY = """
+query FindJob($input: FindJobInput!) {
+  findJob(input: $input) {
+    id
+    status
+    progress
+    description
+    error
+    addTime
+    startTime
+    endTime
+  }
+}
+"""
+
+
+def find_job(job_id: str) -> dict | None:
+    """Return the job with `job_id`, or None when Stash does not know it."""
+    return core.call(_FIND_JOB_QUERY, {"input": {"id": job_id}}).get("findJob")

stashapp_cli/queries/metadata.py

@@ -0,0 +1,42 @@
+"""Background metadata jobs: scan, generate, and identify.
+
+Each mutation starts a job in Stash and returns its id at once. Use
+`queries.job.find_job` to read the job's state.
+"""
+
+from __future__ import annotations
+
+from .. import core
+
+_SCAN_MUTATION = """
+mutation MetadataScan($input: ScanMetadataInput!) {
+  metadataScan(input: $input)
+}
+"""
+
+_GENERATE_MUTATION = """
+mutation MetadataGenerate($input: GenerateMetadataInput!) {
+  metadataGenerate(input: $input)
+}
+"""
+
+_IDENTIFY_MUTATION = """
+mutation MetadataIdentify($input: IdentifyMetadataInput!) {
+  metadataIdentify(input: $input)
+}
+"""
+
+
+def start_scan(input_data: dict) -> str:
+    """Start a scan job from a `ScanMetadataInput` and return the job id."""
+    return core.call(_SCAN_MUTATION, {"input": input_data})["metadataScan"]
+
+
+def start_generate(input_data: dict) -> str:
+    """Start a generate job from a `GenerateMetadataInput` and return the job id."""
+    return core.call(_GENERATE_MUTATION, {"input": input_data})["metadataGenerate"]
+
+
+def start_identify(input_data: dict) -> str:
+    """Start an identify job from an `IdentifyMetadataInput` and return the job id."""
+    return core.call(_IDENTIFY_MUTATION, {"input": input_data})["metadataIdentify"]

stashapp_cli/queries/performer.py

@@ -0,0 +1,179 @@
+"""Performer lookups and writes."""
+
+from __future__ import annotations
+
+import re
+
+from .. import core
+from ._get import ObjectSpec, get_object
+from ._image_flags import add_page_image_flags
+
+_IMAGE_FLAGS = {"image_path": "has_image"}
+
+_PERFORMER_FIELDS = """
+      id
+      name
+      disambiguation
+      alias_list
+      details
+      urls
+      image_path
+      custom_fields
+      stash_ids { endpoint stash_id }
+"""
+
+PERFORMER = ObjectSpec("findPerformer", _PERFORMER_FIELDS, _IMAGE_FLAGS)
+
+
+def get_performer(performer_id: str) -> dict | None:
+    """One performer by id, in the shape find_performers returns, or `None`."""
+    return get_object(PERFORMER, performer_id)
+
+
+_FIND_PERFORMERS_QUERY = f"""
+query FindPerformers(
+  $performer_filter: PerformerFilterType!
+  $page: Int!
+  $per_page: Int!
+) {{
+  findPerformers(
+    performer_filter: $performer_filter
+    filter: {{page: $page, per_page: $per_page, sort: "name", direction: ASC}}
+  ) {{
+    count
+    performers {{
+{_PERFORMER_FIELDS}
+    }}
+  }}
+}}
+"""
+
+
+def find_performers(performer_filter: dict, page: int, per_page: int = 50) -> dict:
+    """One page of the performers matching a Stash performer filter.
+
+    Each performer also gets a `has_image` flag; see `_image_flags` for the rule.
+    """
+    result = core.call(
+        _FIND_PERFORMERS_QUERY,
+        {"performer_filter": performer_filter, "page": page, "per_page": per_page},
+    )["findPerformers"]
+    return add_page_image_flags(result, "performers", _IMAGE_FLAGS)
+
+
+_CREATE_PERFORMER_MUTATION = """
+mutation CreatePerformer($name: String!, $gender: GenderEnum, $urls: [String!]) {
+  performerCreate(input: {name: $name, gender: $gender, urls: $urls}) {
+    id
+  }
+}
+"""
+
+
+def create_performer(
+    name: str, gender: str | None = None, urls: list[str] | None = None
+) -> str:
+    data = core.call(
+        _CREATE_PERFORMER_MUTATION,
+        {"name": name, "gender": gender, "urls": urls or []},
+    )
+    return data["performerCreate"]["id"]
+
+
+_UPDATE_PERFORMER_MUTATION = """
+mutation UpdatePerformer($input: PerformerUpdateInput!) {
+  performerUpdate(input: $input) {
+    id
+  }
+}
+"""
+
+
+def update_performer(input_data: dict) -> str:
+    data = core.call(_UPDATE_PERFORMER_MUTATION, {"input": input_data})
+    return data["performerUpdate"]["id"]
+
+
+# Selects only what the merge loss report reads; never image fields.
+_FIND_PERFORMERS_BY_IDS_QUERY = """
+query FindPerformersByIds($ids: [ID!]) {
+  findPerformers(ids: $ids, filter: {per_page: -1}) {
+    performers {
+      id
+      name
+      alias_list
+      urls
+      stash_ids { endpoint stash_id }
+    }
+  }
+}
+"""
+
+_PERFORMER_NOT_FOUND = re.compile(r"\bperformer with id (\d+) not found\b")
+
+
+def _performer_not_found(missing_ids: list[str]) -> core.CliError:
+    return core.CliError(
+        f"Performer not found: {', '.join(missing_ids)}.",
+        2,
+        "performer_not_found",
+        {"missing_ids": missing_ids},
+    )
+
+
+def find_performers_by_ids(ids: list[str]) -> list[dict]:
+    """The performers with `ids`, in the order Stash returns them.
+
+    Stash fails the whole read at the first missing ID; that ID, or any
+    requested ID absent from the result, raises `performer_not_found`.
+    """
+    try:
+        data = core.call(_FIND_PERFORMERS_BY_IDS_QUERY, {"ids": ids})
+    except core.CliError as error:
+        match = _PERFORMER_NOT_FOUND.search(str(error))
+        if error.code == "graphql_error" and match:
+            raise _performer_not_found([match.group(1)]) from error
+        raise
+    performers = data.get("findPerformers", {}).get("performers", [])
+    found = {performer["id"] for performer in performers}
+    missing = [performer_id for performer_id in ids if performer_id not in found]
+    if missing:
+        raise _performer_not_found(missing)
+    return performers
+
+
+_BULK_UPDATE_PERFORMER_MUTATION = """
+mutation BulkUpdatePerformer($input: BulkPerformerUpdateInput!) {
+  bulkPerformerUpdate(input: $input) {
+    id
+  }
+}
+"""
+
+
+def bulk_update_performer(input_data: dict) -> str:
+    """Send a one-performer bulkPerformerUpdate and return the performer id."""
+    (performer_id,) = input_data["ids"]
+    try:
+        data = core.call(_BULK_UPDATE_PERFORMER_MUTATION, {"input": input_data})
+    except core.CliError as error:
+        # Stash's error for a bulkPerformerUpdate of a missing performer.
+        not_found = rf"\bperformer with id {re.escape(performer_id)} not found\b"
+        if error.code == "graphql_error" and re.search(not_found, str(error)):
+            raise core.not_found_error("performer", performer_id) from error
+        raise
+    return core.returned_id("bulkPerformerUpdate", data, performer_id)
+
+
+_MERGE_PERFORMERS_MUTATION = """
+mutation MergePerformers($input: PerformerMergeInput!) {
+  performerMerge(input: $input) {
+    id
+  }
+}
+"""
+
+
+def merge_performers(input_data: dict) -> str:
+    data = core.call(_MERGE_PERFORMERS_MUTATION, {"input": input_data})
+    return data["performerMerge"]["id"]

stashapp_cli/queries/scene.py

@@ -0,0 +1,139 @@
+"""Scene lookups and writes."""
+
+from __future__ import annotations
+
+import re
+
+from .. import core
+
+_SCENE_FIELDS = """
+      id
+      title
+      code
+      details
+      date
+      director
+      urls
+      custom_fields
+      studio { id }
+      tags { id }
+      performers { id }
+      groups { group { id } }
+      files { path }
+"""
+
+_FIND_SCENES_QUERY = f"""
+query FindScenes($scene_filter: SceneFilterType!, $page: Int!, $per_page: Int!) {{
+  findScenes(
+    scene_filter: $scene_filter
+    filter: {{page: $page, per_page: $per_page, sort: "path", direction: ASC}}
+  ) {{
+    count
+    scenes {{
+{_SCENE_FIELDS}
+    }}
+  }}
+}}
+"""
+
+
+_GET_SCENE_QUERY = f"""
+query GetScene($scene_ids: [Int!]) {{
+  findScenes(scene_filter: {{}}, filter: {{per_page: 1}}, scene_ids: $scene_ids) {{
+    scenes {{
+{_SCENE_FIELDS}
+    }}
+  }}
+}}
+"""
+
+
+def get_scene(scene_id: str) -> dict | None:
+    """Fetch a single scene by id, in the same shape find_scenes returns."""
+    try:
+        data = core.call(_GET_SCENE_QUERY, {"scene_ids": [int(scene_id)]})
+    except core.CliError as error:
+        if re.search(r"\bscene with id\b.*\bnot found\b", str(error), re.IGNORECASE):
+            return None
+        raise
+    scenes = data.get("findScenes", {}).get("scenes", [])
+    return scenes[0] if scenes else None
+
+
+def find_scenes(scene_filter: dict, page: int, per_page: int = 50) -> dict:
+    """List scenes matching an arbitrary Stash scene filter, as-is."""
+    return core.call(
+        _FIND_SCENES_QUERY,
+        {"scene_filter": scene_filter, "page": page, "per_page": per_page},
+    )["findScenes"]
+
+
+_UPDATE_SCENE_MUTATION = """
+mutation UpdateScene($input: SceneUpdateInput!) {
+  sceneUpdate(input: $input) {
+    id
+  }
+}
+"""
+
+
+def update_scene(input_data: dict) -> str:
+    data = core.call(_UPDATE_SCENE_MUTATION, {"input": input_data})
+    return data["sceneUpdate"]["id"]
+
+
+_BULK_UPDATE_SCENE_MUTATION = """
+mutation BulkUpdateScene($input: BulkSceneUpdateInput!) {
+  bulkSceneUpdate(input: $input) {
+    id
+  }
+}
+"""
+
+# Stash's error for a bulkSceneUpdate of a scene that does not exist, when no
+# list row is written (an empty list).
+_BULK_SCENE_NOT_FOUND = "sql: no rows in result set"
+# Stash's error when a list row names a scene or a list value that does not
+# exist. The message does not say which, so the scene is read to tell them apart.
+_BULK_SCENE_FOREIGN_KEY = "FOREIGN KEY constraint failed"
+
+
+def bulk_update_scene(input_data: dict) -> str:
+    """Send a one-scene bulkSceneUpdate and return the scene id."""
+    (scene_id,) = input_data["ids"]
+    try:
+        data = core.call(_BULK_UPDATE_SCENE_MUTATION, {"input": input_data})
+    except core.CliError as error:
+        if error.code != "graphql_error":
+            raise
+        if _BULK_SCENE_NOT_FOUND in str(error) or (
+            _BULK_SCENE_FOREIGN_KEY in str(error) and get_scene_lists(scene_id) is None
+        ):
+            raise core.not_found_error("scene", scene_id) from error
+        raise
+    return core.returned_id("bulkSceneUpdate", data, scene_id)
+
+
+_GET_SCENE_LISTS_QUERY = """
+query GetSceneLists($scene_ids: [Int!]) {
+  findScenes(scene_filter: {}, filter: {per_page: 1}, scene_ids: $scene_ids) {
+    scenes {
+      id
+      groups { group { id } scene_index }
+      stash_ids { endpoint stash_id updated_at }
+    }
+  }
+}
+"""
+
+
+def get_scene_lists(scene_id: str) -> dict | None:
+    """A scene's groups with scene_index and its stash_ids; None if missing."""
+    try:
+        data = core.call(_GET_SCENE_LISTS_QUERY, {"scene_ids": [int(scene_id)]})
+    except core.CliError as error:
+        if re.search(r"\bscene with id\b.*\bnot found\b", str(error), re.IGNORECASE):
+            return None
+        raise
+    scenes = data.get("findScenes", {}).get("scenes", [])
+    return scenes[0] if scenes else None

stashapp_cli/queries/scrape.py

@@ -0,0 +1,183 @@
+"""Scraping (delegates to the scrapers installed in Stash)."""
+
+from __future__ import annotations
+
+from .. import core
+
+ScrapedTagFields = """
+fragment ScrapedTagFields on ScrapedTag {
+  stored_id
+  name
+  remote_site_id
+}
+"""
+
+ScrapedStudioFields = """
+fragment ScrapedStudioFields on ScrapedStudio {
+  stored_id
+  name
+  urls
+  details
+  aliases
+  remote_site_id
+  image
+  parent { stored_id name }
+}
+"""
+
+ScrapedPerformerFields = """
+fragment ScrapedPerformerFields on ScrapedPerformer {
+  stored_id
+  name
+  disambiguation
+  gender
+  urls
+  aliases
+  birthdate
+  death_date
+  country
+  ethnicity
+  hair_color
+  eye_color
+  height
+  weight
+  measurements
+  fake_tits
+  penis_length
+  circumcised
+  career_start
+  career_end
+  tattoos
+  piercings
+  details
+  remote_site_id
+  tags { ...ScrapedTagFields }
+  images
+}
+"""
+
+ScrapedGroupFields = """
+fragment ScrapedGroupFields on ScrapedGroup {
+  stored_id
+  name
+  aliases
+  date
+  duration
+  rating
+  director
+  synopsis
+  urls
+  studio { ...ScrapedStudioFields }
+  tags { ...ScrapedTagFields }
+  front_image
+  back_image
+}
+"""
+
+ScrapedSceneFields = """
+fragment ScrapedSceneFields on ScrapedScene {
+  title
+  code
+  details
+  director
+  urls
+  date
+  duration
+  remote_site_id
+  image
+  studio { ...ScrapedStudioFields }
+  tags { ...ScrapedTagFields }
+  performers { ...ScrapedPerformerFields }
+  groups { ...ScrapedGroupFields }
+}
+"""
+
+_FRAGMENTS = {
+    "ScrapedTagFields": ScrapedTagFields,
+    "ScrapedStudioFields": ScrapedStudioFields,
+    "ScrapedPerformerFields": ScrapedPerformerFields,
+    "ScrapedGroupFields": ScrapedGroupFields,
+    "ScrapedSceneFields": ScrapedSceneFields,
+}
+_FRAGMENT_DEPENDENCIES = {
+    "ScrapedTagFields": (),
+    "ScrapedStudioFields": (),
+    "ScrapedPerformerFields": ("ScrapedTagFields",),
+    "ScrapedGroupFields": ("ScrapedStudioFields", "ScrapedTagFields"),
+    "ScrapedSceneFields": (
+        "ScrapedStudioFields",
+        "ScrapedTagFields",
+        "ScrapedPerformerFields",
+        "ScrapedGroupFields",
+    ),
+}
+
+
+def _fragments(*names: str) -> str:
+    """Return requested fragments and their dependencies exactly once."""
+    included: set[str] = set()
+    ordered: list[str] = []
+
+    def add(name: str) -> None:
+        if name in included:
+            return
+        for dependency in _FRAGMENT_DEPENDENCIES[name]:
+            add(dependency)
+        included.add(name)
+        ordered.append(name)
+
+    for name in names:
+        add(name)
+    return "\n".join(_FRAGMENTS[name] for name in ordered)
+
+
+_SCRAPE_GROUP_URL_QUERY = """
+query ScrapeGroupURL($url: String!) {
+  scrapeGroupURL(url: $url) { ...ScrapedGroupFields }
+}
+""" + _fragments("ScrapedGroupFields")
+
+
+def scrape_group_url(url: str) -> dict | None:
+    return core.call(_SCRAPE_GROUP_URL_QUERY, {"url": url}).get("scrapeGroupURL")
+
+
+_SCRAPE_SCENE_URL_QUERY = """
+query ScrapeSceneURL($url: String!) {
+  scrapeSceneURL(url: $url) { ...ScrapedSceneFields }
+}
+""" + _fragments("ScrapedSceneFields")
+
+
+def scrape_scene_url(url: str) -> dict | None:
+    """Scrape a URL and return the full scraped scene, if one is found."""
+    return core.call(_SCRAPE_SCENE_URL_QUERY, {"url": url}).get("scrapeSceneURL")
+
+
+_SCRAPE_PERFORMER_URL_QUERY = """
+query ScrapePerformerURL($url: String!) {
+  scrapePerformerURL(url: $url) { ...ScrapedPerformerFields }
+}
+""" + _fragments("ScrapedPerformerFields")
+
+
+def scrape_performer_url(url: str) -> dict | None:
+    return core.call(_SCRAPE_PERFORMER_URL_QUERY, {"url": url}).get(
+        "scrapePerformerURL"
+    )
+
+
+_SCRAPE_SINGLE_SCENE_QUERY = """
+query ScrapeSingleScene($source: ScraperSourceInput!, $input: ScrapeSingleSceneInput!) {
+  scrapeSingleScene(source: $source, input: $input) { ...ScrapedSceneFields }
+}
+""" + _fragments("ScrapedSceneFields")
+
+
+def scrape_single_scene(source: dict, input: dict) -> list[dict]:
+    return (
+        core.call(_SCRAPE_SINGLE_SCENE_QUERY, {"source": source, "input": input}).get(
+            "scrapeSingleScene"
+        )
+        or []
+    )