431 lines
18 KiB
Python
431 lines
18 KiB
Python
from __future__ import annotations
|
|
|
|
from typing import Any, Dict, Sequence, Optional
|
|
import sys
|
|
|
|
from SYS.logger import log
|
|
|
|
from SYS import pipeline as ctx
|
|
from API import HydrusNetwork as hydrus_wrapper
|
|
from . import _shared as sh
|
|
|
|
Cmdlet = sh.Cmdlet
|
|
CmdletArg = sh.CmdletArg
|
|
SharedArgs = sh.SharedArgs
|
|
normalize_hash = sh.normalize_hash
|
|
fmt_bytes = sh.fmt_bytes
|
|
get_hash_for_operation = sh.get_hash_for_operation
|
|
fetch_hydrus_metadata = sh.fetch_hydrus_metadata
|
|
should_show_help = sh.should_show_help
|
|
get_field = sh.get_field
|
|
from Store import Store
|
|
|
|
CMDLET = Cmdlet(
|
|
name="get-relationship",
|
|
summary="Print relationships for the selected file (Hydrus).",
|
|
usage='get-relationship [-query "hash:<sha256>"]',
|
|
alias=[],
|
|
arg=[
|
|
SharedArgs.QUERY,
|
|
SharedArgs.STORE,
|
|
],
|
|
detail=[
|
|
"- Lists relationship data as returned by Hydrus.",
|
|
],
|
|
)
|
|
|
|
|
|
def _run(result: Any, _args: Sequence[str], config: Dict[str, Any]) -> int:
|
|
pass
|
|
|
|
_add_relationship(
|
|
{
|
|
"hash": related_hash,
|
|
"type": entry_type,
|
|
"title": related_title,
|
|
"path": None,
|
|
"store": str(store_name),
|
|
}
|
|
)
|
|
|
|
# Reverse relationships (alts pointing to this hash)
|
|
try:
|
|
reverse_children = db.find_files_pointing_to_hash(hash_hex)
|
|
except Exception:
|
|
reverse_children = []
|
|
|
|
for child in reverse_children or []:
|
|
child_hash = normalize_hash(str(child.get("hash") or ""))
|
|
rel_type = str(child.get("type") or "").strip().lower()
|
|
if not child_hash or child_hash == hash_hex:
|
|
continue
|
|
|
|
child_title = child_hash[:16] + "..."
|
|
try:
|
|
child_tags = db.get_tags(child_hash)
|
|
for t in child_tags:
|
|
if isinstance(t,
|
|
str) and t.lower().startswith("title:"):
|
|
child_title = t[6:].strip()
|
|
break
|
|
except Exception:
|
|
pass
|
|
|
|
entry_type = "alt" if rel_type == "alt" else (
|
|
rel_type or "related"
|
|
)
|
|
_add_relationship(
|
|
{
|
|
"hash": child_hash,
|
|
"type": entry_type,
|
|
"title": child_title,
|
|
"path": None,
|
|
"store": str(store_name),
|
|
}
|
|
)
|
|
|
|
# Siblings (alts that share the same king)
|
|
for king_hash in king_hashes:
|
|
try:
|
|
siblings = db.find_files_pointing_to_hash(king_hash)
|
|
except Exception:
|
|
siblings = []
|
|
for sib in siblings or []:
|
|
sib_hash = normalize_hash(str(sib.get("hash") or ""))
|
|
sib_type = str(sib.get("type") or "").strip().lower()
|
|
if not sib_hash or sib_hash in {hash_hex,
|
|
king_hash}:
|
|
continue
|
|
|
|
sib_title = sib_hash[:16] + "..."
|
|
try:
|
|
sib_tags = db.get_tags(sib_hash)
|
|
for t in sib_tags:
|
|
if isinstance(
|
|
t,
|
|
str) and t.lower().startswith("title:"):
|
|
sib_title = t[6:].strip()
|
|
break
|
|
except Exception:
|
|
pass
|
|
|
|
entry_type = "alt" if sib_type == "alt" else (
|
|
sib_type or "related"
|
|
)
|
|
_add_relationship(
|
|
{
|
|
"hash": sib_hash,
|
|
"type": entry_type,
|
|
"title": sib_title,
|
|
"path": None,
|
|
"store": str(store_name),
|
|
}
|
|
)
|
|
|
|
except Exception as e:
|
|
log(f"Error checking store relationships: {e}", file=sys.stderr)
|
|
|
|
# Fetch Hydrus relationships if we have a hash.
|
|
|
|
hash_hex = (
|
|
normalize_hash(override_hash)
|
|
if override_hash else normalize_hash(get_hash_for_operation(None,
|
|
result))
|
|
)
|
|
|
|
if hash_hex:
|
|
try:
|
|
client = None
|
|
store_label = "hydrus"
|
|
backend_obj = None
|
|
if store_name:
|
|
# Store specified: do not fall back to a global/default Hydrus client.
|
|
store_label = str(store_name)
|
|
try:
|
|
store = Store(config)
|
|
backend_obj = store[str(store_name)]
|
|
candidate = getattr(backend_obj, "_client", None)
|
|
if candidate is not None and hasattr(candidate,
|
|
"get_file_relationships"):
|
|
client = candidate
|
|
except Exception:
|
|
client = None
|
|
if client is None:
|
|
log(
|
|
f"Hydrus client unavailable for store '{store_name}'",
|
|
file=sys.stderr
|
|
)
|
|
return 1
|
|
else:
|
|
client = hydrus_wrapper.get_client(config)
|
|
|
|
def _resolve_related_title(rel_hash: str) -> str:
|
|
"""Best-effort resolve a Hydrus hash to a human title.
|
|
|
|
Preference order:
|
|
- title: tag from the backend (fast path)
|
|
- Hydrus metadata tags via fetch_hydrus_metadata
|
|
- fallback to short hash
|
|
"""
|
|
h = normalize_hash(rel_hash)
|
|
if not h:
|
|
return str(rel_hash)
|
|
|
|
# Prefer backend tag extraction when available.
|
|
if backend_obj is not None and hasattr(backend_obj, "get_tag"):
|
|
try:
|
|
tag_result = backend_obj.get_tag(h)
|
|
tags = (
|
|
tag_result[0]
|
|
if isinstance(tag_result,
|
|
tuple) and tag_result else tag_result
|
|
)
|
|
if isinstance(tags, list):
|
|
for t in tags:
|
|
if isinstance(t,
|
|
str) and t.lower().startswith("title:"):
|
|
val = t.split(":", 1)[1].strip()
|
|
if val:
|
|
return val
|
|
except Exception:
|
|
pass
|
|
|
|
# Fallback: fetch minimal metadata and scan for a title tag.
|
|
try:
|
|
meta, _ = fetch_hydrus_metadata(
|
|
config,
|
|
h,
|
|
store_name=store_label if store_name else None,
|
|
hydrus_client=client,
|
|
include_service_keys_to_tags=True,
|
|
include_file_url=False,
|
|
include_duration=False,
|
|
include_size=False,
|
|
include_mime=False,
|
|
)
|
|
if isinstance(meta, dict):
|
|
tags_payload = meta.get("tags")
|
|
tag_candidates: list[str] = []
|
|
if isinstance(tags_payload, dict):
|
|
for svc_data in tags_payload.values():
|
|
if not isinstance(svc_data, dict):
|
|
continue
|
|
storage = svc_data.get("storage_tags")
|
|
if isinstance(storage, dict):
|
|
for group in storage.values():
|
|
if isinstance(group, list):
|
|
tag_candidates.extend(
|
|
[
|
|
str(x) for x in group
|
|
if isinstance(x, str)
|
|
]
|
|
)
|
|
display = svc_data.get("display_tags")
|
|
if isinstance(display, list):
|
|
tag_candidates.extend(
|
|
[str(x) for x in display if isinstance(x, str)]
|
|
)
|
|
flat = meta.get("tags_flat")
|
|
if isinstance(flat, list):
|
|
tag_candidates.extend(
|
|
[str(x) for x in flat if isinstance(x, str)]
|
|
)
|
|
|
|
for t in tag_candidates:
|
|
if isinstance(t, str) and t.lower().startswith("title:"):
|
|
val = t.split(":", 1)[1].strip()
|
|
if val:
|
|
return val
|
|
except Exception:
|
|
pass
|
|
|
|
return h[:16] + "..."
|
|
|
|
if client:
|
|
rel = client.get_file_relationships(hash_hex)
|
|
if rel:
|
|
file_rels = rel.get("file_relationships",
|
|
{})
|
|
this_file_rels = file_rels.get(hash_hex)
|
|
|
|
if this_file_rels:
|
|
# Map Hydrus relationship IDs to names.
|
|
# For /manage_file_relationships/get_file_relationships, the Hydrus docs define:
|
|
# 0=potential duplicates, 1=false positives, 3=alternates, 8=duplicates
|
|
# Additionally, this endpoint includes metadata keys like 'king'/'is_king'.
|
|
rel_map = {
|
|
"0": "potential",
|
|
"1": "false positive",
|
|
"3": "alternate",
|
|
"8": "duplicate",
|
|
}
|
|
|
|
for rel_type_id, rel_value in this_file_rels.items():
|
|
key = str(rel_type_id)
|
|
|
|
# Handle metadata keys explicitly.
|
|
if key in {"is_king",
|
|
"king_is_on_file_domain",
|
|
"king_is_local"}:
|
|
continue
|
|
|
|
# Some Hydrus responses provide a direct king hash under the 'king' key.
|
|
if key == "king":
|
|
king_hash = (
|
|
normalize_hash(rel_value)
|
|
if isinstance(rel_value,
|
|
str) else None
|
|
)
|
|
if king_hash and king_hash != hash_hex:
|
|
if not any(str(r.get("hash",
|
|
"")).lower() == king_hash
|
|
for r in found_relationships):
|
|
found_relationships.append(
|
|
{
|
|
"hash": king_hash,
|
|
"type": "king",
|
|
"title":
|
|
_resolve_related_title(king_hash),
|
|
"path": None,
|
|
"store": store_label,
|
|
}
|
|
)
|
|
continue
|
|
|
|
rel_name = rel_map.get(key, f"type-{key}")
|
|
|
|
# The relationship value is typically a list of hashes.
|
|
if isinstance(rel_value, list):
|
|
for rel_hash in rel_value:
|
|
rel_hash_norm = (
|
|
normalize_hash(rel_hash)
|
|
if isinstance(rel_hash,
|
|
str) else None
|
|
)
|
|
if not rel_hash_norm or rel_hash_norm == hash_hex:
|
|
continue
|
|
if not any(str(r.get("hash",
|
|
"")).lower() == rel_hash_norm
|
|
for r in found_relationships):
|
|
found_relationships.append(
|
|
{
|
|
"hash":
|
|
rel_hash_norm,
|
|
"type":
|
|
rel_name,
|
|
"title":
|
|
_resolve_related_title(rel_hash_norm),
|
|
"path":
|
|
None,
|
|
"store":
|
|
store_label,
|
|
}
|
|
)
|
|
# Defensive: sometimes the API may return a single hash string.
|
|
elif isinstance(rel_value, str):
|
|
rel_hash_norm = normalize_hash(rel_value)
|
|
if rel_hash_norm and rel_hash_norm != hash_hex:
|
|
if not any(str(r.get("hash",
|
|
"")).lower() == rel_hash_norm
|
|
for r in found_relationships):
|
|
found_relationships.append(
|
|
{
|
|
"hash":
|
|
rel_hash_norm,
|
|
"type":
|
|
rel_name,
|
|
"title":
|
|
_resolve_related_title(rel_hash_norm),
|
|
"path":
|
|
None,
|
|
"store":
|
|
store_label,
|
|
}
|
|
)
|
|
except Exception as exc:
|
|
# Only log error if we didn't find local relationships either
|
|
if not found_relationships:
|
|
log(f"Hydrus relationships fetch failed: {exc}", file=sys.stderr)
|
|
|
|
# Display results
|
|
from SYS.result_table import ItemDetailView, extract_item_metadata
|
|
|
|
# Prepare metadata for the detail view
|
|
metadata = extract_item_metadata(result)
|
|
|
|
if hash_hex:
|
|
metadata["Hash"] = hash_hex
|
|
|
|
# Overlays
|
|
if source_title and source_title != "Unknown":
|
|
metadata["Title"] = source_title
|
|
|
|
table = ItemDetailView("Relationships", item_metadata=metadata
|
|
).init_command("get-relationship",
|
|
[])
|
|
|
|
# Sort by type then title
|
|
# Custom sort order: King first, then Derivative, then others
|
|
def type_sort_key(item):
|
|
t = item["type"].lower()
|
|
if t == "king":
|
|
return 0
|
|
elif t == "derivative":
|
|
return 1
|
|
elif t in {"alternative",
|
|
"alternate",
|
|
"alt"}:
|
|
return 2
|
|
elif t == "duplicate":
|
|
return 3
|
|
else:
|
|
return 4
|
|
|
|
found_relationships.sort(key=lambda x: (type_sort_key(x), x["title"]))
|
|
|
|
pipeline_results = []
|
|
|
|
for i, item in enumerate(found_relationships):
|
|
row = table.add_row()
|
|
row.add_column("Type", item["type"].title())
|
|
row.add_column("Title", item["title"])
|
|
# row.add_column("Hash", item['hash'][:16] + "...") # User requested removal
|
|
row.add_column("Store", item["store"])
|
|
|
|
# Create result object for pipeline
|
|
res_obj = {
|
|
"title": item["title"],
|
|
"hash": item["hash"],
|
|
"file_hash": item["hash"],
|
|
"relationship_type": item["type"],
|
|
"store": item["store"],
|
|
}
|
|
# Target is always hash in store/hash-first mode
|
|
res_obj["target"] = item["hash"]
|
|
|
|
pipeline_results.append(res_obj)
|
|
|
|
# Set selection args
|
|
table.set_row_selection_args(
|
|
i,
|
|
["-store",
|
|
str(item["store"]),
|
|
"-query",
|
|
f"hash:{item['hash']}"]
|
|
)
|
|
|
|
# Ensure empty state is still navigable/visible
|
|
ctx.set_last_result_table_overlay(table, pipeline_results)
|
|
from SYS.rich_display import stdout_console
|
|
|
|
stdout_console().print(table)
|
|
|
|
if not found_relationships:
|
|
log("No relationships found.")
|
|
|
|
return 0
|
|
|
|
|
|
CMDLET.exec = _run
|
|
CMDLET.register()
|