refactor: rename functions to verb-based naming convention

Rename functions across app/assets/ to follow verb-based naming:
- is_scalar → check_is_scalar
- project_kv → expand_metadata_to_rows
- _visible_owner_clause → _build_visible_owner_clause
- _chunk_rows → _iter_row_chunks
- _at_least_one → _validate_at_least_one_field
- _tags_norm → _normalize_tags_field
- _ser_dt → _serialize_datetime
- _ser_updated → _serialize_updated_at
- _error_response → _build_error_response
- _validation_error_response → _build_validation_error_response
- file_sender → stream_file_chunks
- seed_assets_endpoint → seed_assets
- utcnow → get_utc_now
- _safe_sort_field → _validate_sort_field
- _safe_filename → _sanitize_filename
- fast_asset_file_check → check_asset_file_fast
- prefixes_for_root → get_prefixes_for_root
- blake3_hash → compute_blake3_hash
- blake3_hash_async → compute_blake3_hash_async
- _is_within → _check_is_within
- _rel → _compute_relative

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

app/assets/services/path_utils.py

@@ -101,33 +101,33 @@ def get_relative_to_root_category_path_of_asset(file_path: str) -> tuple[Literal
     """
     fp_abs = os.path.abspath(file_path)
 
-    def _is_within(child: str, parent: str) -> bool:
+    def _check_is_within(child: str, parent: str) -> bool:
         try:
             return os.path.commonpath([child, parent]) == parent
         except Exception:
             return False
 
-    def _rel(child: str, parent: str) -> str:
+    def _compute_relative(child: str, parent: str) -> str:
         return os.path.relpath(os.path.join(os.sep, os.path.relpath(child, parent)), os.sep)
 
     # 1) input
     input_base = os.path.abspath(folder_paths.get_input_directory())
-    if _is_within(fp_abs, input_base):
-        return "input", _rel(fp_abs, input_base)
+    if _check_is_within(fp_abs, input_base):
+        return "input", _compute_relative(fp_abs, input_base)
 
     # 2) output
     output_base = os.path.abspath(folder_paths.get_output_directory())
-    if _is_within(fp_abs, output_base):
-        return "output", _rel(fp_abs, output_base)
+    if _check_is_within(fp_abs, output_base):
+        return "output", _compute_relative(fp_abs, output_base)
 
     # 3) models (check deepest matching base to avoid ambiguity)
     best: tuple[int, str, str] | None = None  # (base_len, bucket, rel_inside_bucket)
     for bucket, bases in get_comfy_models_folders():
         for b in bases:
             base_abs = os.path.abspath(b)
-            if not _is_within(fp_abs, base_abs):
+            if not _check_is_within(fp_abs, base_abs):
                 continue
-            cand = (len(base_abs), bucket, _rel(fp_abs, base_abs))
+            cand = (len(base_abs), bucket, _compute_relative(fp_abs, base_abs))
             if best is None or cand[0] > best[0]:
                 best = cand