fdf

cmdnat/matrix.py

@@ -12,8 +12,16 @@ from SYS.cmdlet_spec import Cmdlet, CmdletArg
 from SYS.config import load_config, save_config
 from SYS.logger import log, debug
 from SYS.result_table import Table
+from SYS.item_accessors import get_sha256_hex
 from SYS.utils import extract_hydrus_hash_from_url
 from SYS import pipeline as ctx
+from cmdnat._parsing import (
+    extract_arg_value,
+    extract_piped_value as _extract_piped_value,
+    extract_value_arg as _extract_value_arg,
+    has_flag as _has_flag,
+    normalize_to_list as _normalize_to_list,
+)
 
 _MATRIX_PENDING_ITEMS_KEY = "matrix_pending_items"
 _MATRIX_PENDING_TEXT_KEY = "matrix_pending_text"
@@ -21,62 +29,9 @@ _MATRIX_MENU_STATE_KEY = "matrix_menu_state"
 _MATRIX_SELECTED_SETTING_KEY_KEY = "matrix_selected_setting_key"
 
 
-def _extract_piped_value(result: Any) -> Optional[str]:
-    """Extract the piped value from result (string, number, or dict with 'value' key)."""
-    if isinstance(result, str):
-        return result.strip() if result.strip() else None
-    if isinstance(result, (int, float)):
-        return str(result)
-    if isinstance(result, dict):
-        # Fallback to value field if it's a dict
-        val = result.get("value")
-        if val is not None:
-            return str(val).strip()
-    return None
-
-
-def _extract_value_arg(args: Sequence[str]) -> Optional[str]:
-    """Extract a fallback value from command-line args (value flag or positional)."""
-    if not args:
-        return None
-    tokens = [str(tok) for tok in args if tok is not None]
-    value_flags = {"-value", "--value", "-set-value", "--set-value"}
-    for idx, tok in enumerate(tokens):
-        low = tok.strip()
-        if not low:
-            continue
-        low_lower = low.lower()
-        if low_lower in value_flags and idx + 1 < len(tokens):
-            candidate = str(tokens[idx + 1]).strip()
-            if candidate:
-                return candidate
-        if "=" in low_lower:
-            head, val = low_lower.split("=", 1)
-            if head in value_flags and val:
-                return val.strip()
-    # Fallback to first non-flag token
-    for tok in tokens:
-        text = str(tok).strip()
-        if text and not text.startswith("-"):
-            return text
-    return None
-
-
 def _extract_set_value_arg(args: Sequence[str]) -> Optional[str]:
     """Extract the value from -set-value flag."""
-    if not args:
-        return None
-    try:
-        tokens = list(args)
-    except Exception:
-        return None
-    for i, tok in enumerate(tokens):
-        try:
-            if str(tok).lower() == "-set-value" and i + 1 < len(tokens):
-                return str(tokens[i + 1]).strip()
-        except Exception:
-            continue
-    return None
+    return extract_arg_value(args, flags={"-set-value"})
 
 
 def _update_matrix_config(config: Dict[str, Any], key: str, value: Any) -> bool:
@@ -122,16 +77,6 @@ def _update_matrix_config(config: Dict[str, Any], key: str, value: Any) -> bool:
         return False
 
 
-def _has_flag(args: Sequence[str], flag: str) -> bool:
-    try:
-        want = str(flag or "").strip().lower()
-        if not want:
-            return False
-        return any(str(a).strip().lower() == want for a in (args or []))
-    except Exception:
-        return False
-
-
 def _parse_config_room_filter_ids(config: Dict[str, Any]) -> List[str]:
     try:
         if not isinstance(config, dict):
@@ -426,14 +371,6 @@ def _extract_text_arg(args: Sequence[str]) -> str:
     return ""
 
 
-def _normalize_to_list(value: Any) -> List[Any]:
-    if value is None:
-        return []
-    if isinstance(value, list):
-        return value
-    return [value]
-
-
 def _extract_room_id(room_obj: Any) -> Optional[str]:
     try:
         # PipeObject stores unknown fields in .extra
@@ -525,22 +462,8 @@ def _extract_url(item: Any) -> Optional[str]:
     return None
 
 
-_SHA256_RE = re.compile(r"^[0-9a-fA-F]{64}$")
-
-
 def _extract_sha256_hex(item: Any) -> Optional[str]:
-    try:
-        if hasattr(item, "hash"):
-            h = getattr(item, "hash")
-            if isinstance(h, str) and _SHA256_RE.fullmatch(h.strip()):
-                return h.strip().lower()
-        if isinstance(item, dict):
-            h = item.get("hash")
-            if isinstance(h, str) and _SHA256_RE.fullmatch(h.strip()):
-                return h.strip().lower()
-    except Exception:
-        pass
-    return None
+    return get_sha256_hex(item, "hash")
 
 
 def _extract_hash_from_hydrus_file_url(url: str) -> Optional[str]: