Add safe TV and Anime library migration

Preserve tracked history across TV/Anime identity moves, improve provider search ranking, and keep lock/provider failures recoverable.

Fixes #922

Author: dannyvfilms

src/app/credits.py

@@ -59,6 +59,11 @@ def _as_int(value):
         return None
 
 
+def _as_text(value):
+    """Normalize provider text fields that may arrive as non-string values."""
+    return str(value or "").strip()
+
+
 def is_regular_show_cast_credit(source, sort_order):
     """Return whether a show-level cast credit should count as series-regular fallback."""
     if source != Sources.TMDB.value:
@@ -236,14 +241,14 @@ def _normalize_credit_rows(rows):
         normalized.append(
             {
                 "person_id": str(person_id),
-                "name": (row.get("name") or "").strip(),
-                "image": (row.get("image") or "").strip(),
-                "known_for_department": (row.get("known_for_department") or "").strip(),
+                "name": _as_text(row.get("name")),
+                "image": _as_text(row.get("image")),
+                "known_for_department": _as_text(row.get("known_for_department")),
                 "gender": _coerce_gender(row.get("gender")),
-                "role": (
+                "role": _as_text(
                     row.get("role") or row.get("character") or row.get("job") or ""
-                ).strip(),
-                "department": (row.get("department") or "").strip(),
+                ),
+                "department": _as_text(row.get("department")),
                 "sort_order": _as_int(
                     row["order"]
                     if "order" in row and row["order"] is not None
@@ -263,8 +268,8 @@ def _normalize_studio_rows(rows):
         normalized.append(
             {
                 "studio_id": str(studio_id),
-                "name": (row.get("name") or "").strip(),
-                "logo": (row.get("logo") or "").strip(),
+                "name": _as_text(row.get("name")),
+                "logo": _as_text(row.get("logo")),
                 "sort_order": _as_int(
                     row["order"]
                     if "order" in row and row["order"] is not None
@@ -394,14 +399,14 @@ def _normalize_author_rows(rows):
         normalized.append(
             {
                 "person_id": str(person_id),
-                "name": (row.get("name") or "").strip(),
-                "image": (row.get("image") or "").strip(),
-                "known_for_department": (
+                "name": _as_text(row.get("name")),
+                "image": _as_text(row.get("image")),
+                "known_for_department": _as_text(
                     row.get("known_for_department") or row.get("department") or "Author"
-                ).strip(),
+                ),
                 "gender": _coerce_gender(row.get("gender")),
-                "role": (row.get("role") or "").strip(),
-                "department": (row.get("department") or "").strip(),
+                "role": _as_text(row.get("role")),
+                "department": _as_text(row.get("department")),
                 "sort_order": _as_int(
                     row["order"]
                     if "order" in row and row["order"] is not None
@@ -475,16 +480,14 @@ def upsert_person_profile(source, source_person_id, metadata):
         source=source,
         source_person_id=str(source_person_id),
         defaults={
-            "name": (metadata.get("name") or "").strip() or "Unknown Person",
-            "image": (metadata.get("image") or "").strip(),
-            "known_for_department": (
-                metadata.get("known_for_department") or ""
-            ).strip(),
-            "biography": (metadata.get("biography") or "").strip(),
+            "name": _as_text(metadata.get("name")) or "Unknown Person",
+            "image": _as_text(metadata.get("image")),
+            "known_for_department": _as_text(metadata.get("known_for_department")),
+            "biography": _as_text(metadata.get("biography")),
             "gender": _coerce_gender(metadata.get("gender")),
             "birth_date": _coerce_iso_date(metadata.get("birth_date")),
             "death_date": _coerce_iso_date(metadata.get("death_date")),
-            "place_of_birth": (metadata.get("place_of_birth") or "").strip(),
+            "place_of_birth": _as_text(metadata.get("place_of_birth")),
         },
     )
     return person

src/app/metadata_sync_views.py

@@ -8,8 +8,10 @@
 from django.contrib.auth.decorators import login_required
 from django.core.cache import cache
 from django.db.models import Max, Min
+from django.db.utils import OperationalError
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404, redirect, render
+from django.urls import reverse
 from django.utils import timezone
 from django.utils.http import url_has_allowed_host_and_scheme
 from django.views.decorators.http import require_GET, require_POST
@@ -21,6 +23,7 @@
     metadata_utils,
     view_constants,
 )
+from app.db_retry import is_retryable_error, run_retryable_db_operation
 from app.log_safety import exception_summary, safe_url
 from app.models import (
     CollectionEntry,
@@ -35,6 +38,7 @@
 from app.services import (
     anime_migration,
     bulk_episode_tracking,
+    library_migration,
     metadata_resolution,
 )
 from app.services import game_lengths as game_length_services
@@ -174,6 +178,126 @@ def search_remap_candidates(request, source, media_type, media_id):
     )
 
 
+@login_required
+@require_GET
+def search_library_move_candidates(request, item_id):
+    """Search the configured destination provider for a library move."""
+    item = get_object_or_404(Item, id=item_id)
+    move_context = library_migration.get_move_context(request.user, item)
+    query = (request.GET.get("q") or "").strip()
+    results = []
+    if move_context and query:
+        try:
+            response = services.search(
+                move_context["target_media_type"],
+                query,
+                page=1,
+                source=move_context["target_source"],
+                user=request.user,
+                language=metadata_resolution.metadata_language_default(
+                    request.user,
+                ),
+            )
+            results = (response or {}).get("results") or []
+        except services.ProviderAPIError:
+            logger.warning(
+                "Destination library search failed for item %s",
+                item_id,
+                exc_info=True,
+            )
+
+    return render(
+        request,
+        "app/components/library_move_results.html",
+        {
+            "results": results,
+            "item_id": item.id,
+            "query": query,
+            "return_url": helpers.normalize_navigation_url(
+                request.GET.get("return_url"),
+            ),
+            **(move_context or {}),
+        },
+    )
+
+
+@login_required
+@require_POST
+def move_library_item(request, item_id):
+    """Move one owned TV/Anime show into an explicit destination identity."""
+    item = get_object_or_404(Item, id=item_id)
+    return_url = helpers.normalize_navigation_url(request.POST.get("return_url"))
+    target_media_type = request.POST.get("target_media_type")
+    target_source = request.POST.get("target_source")
+    target_media_id = request.POST.get("target_media_id")
+    is_htmx = request.headers.get("HX-Request") == "true"
+    try:
+        target_item = run_retryable_db_operation(
+            lambda: library_migration.migrate_library_item(
+                request.user,
+                item,
+                target_media_type,
+                target_source,
+                target_media_id,
+            ),
+            operation_name="TV/Anime library migration",
+        ).value
+    except OperationalError as error:
+        if not is_retryable_error(error):
+            raise
+        if is_htmx:
+            return render(
+                request,
+                "app/components/library_move_results.html",
+                {
+                    "error": (
+                        "The database is busy with another operation. "
+                        "Nothing was changed; please try Move again."
+                    ),
+                },
+            )
+        raise
+    except library_migration.LibraryMigrationError as error:
+        if is_htmx:
+            return render(
+                request,
+                "app/components/library_move_results.html",
+                {"error": str(error)},
+            )
+        messages.error(request, str(error))
+        if return_url and url_has_allowed_host_and_scheme(
+            return_url,
+            allowed_hosts=None,
+        ):
+            return redirect(return_url)
+        return redirect(
+            "media_details",
+            source=item.source,
+            media_type=library_migration.library_bucket(item),
+            media_id=item.media_id,
+            title=item.get_display_title(request.user) or "item",
+        )
+
+    messages.success(
+        request,
+        f"Moved tracking to {target_item.get_display_title(request.user) or 'the selected title'}.",
+    )
+    destination_url = reverse(
+        "media_details",
+        kwargs={
+            "source": target_item.source,
+            "media_type": library_migration.library_bucket(target_item),
+            "media_id": target_item.media_id,
+            "title": target_item.get_display_title(request.user) or "item",
+        },
+    )
+    if is_htmx:
+        response = HttpResponse(status=204)
+        response["HX-Redirect"] = destination_url
+        return response
+    return redirect(destination_url)
+
+
 @login_required
 @require_POST
 def remap_metadata_provider(request, source, media_type, media_id):

src/app/providers/tvdb.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+import re
 from datetime import datetime
 from typing import Any
 
@@ -531,6 +532,31 @@ def _get_title_fields(row: dict | None, language: str | None = None):
     }
 
 
+def _search_title_key(value) -> str:
+    """Normalize a title for provider-search relevance comparisons."""
+    return re.sub(r"\s+", " ", re.sub(r"[^\w]+", " ", str(value or "").casefold())).strip()
+
+
+def _search_result_rank(result: dict, query: str) -> tuple[int, int]:
+    """Rank direct title matches ahead of TVDB's broader search matches."""
+    normalized_query = _search_title_key(query)
+    if not normalized_query:
+        return (0, 0)
+
+    titles = {
+        _search_title_key(result.get(field))
+        for field in ("title", "localized_title", "original_title")
+    }
+    titles.discard("")
+    if normalized_query in titles:
+        return (0, 0)
+    if any(title.startswith(normalized_query) for title in titles):
+        return (1, 0)
+    if any(normalized_query in title for title in titles):
+        return (2, 0)
+    return (3, 0)
+
+
 def _artwork_image(artwork: dict) -> str | None:
     """Return the image URL from a single TVDB artwork entry."""
     for key in ("image", "thumbnail", "url"):
@@ -1197,7 +1223,7 @@ def search_remote_id(remote_id: str):
 def search(media_type, query, page, language=None):
     """Search TVDB for TV or grouped anime titles."""
     cache_key = _cache_key(
-        "search", media_type, query, page, _preferred_language_code(language)
+        "search_v2", media_type, query, page, _preferred_language_code(language)
     )
     data = cache.get(cache_key)
     if data is not None:
@@ -1240,6 +1266,8 @@ def search(media_type, query, page, language=None):
         if result["media_id"]:
             normalized_results.append(result)
 
+    normalized_results.sort(key=lambda result: _search_result_rank(result, query))
+
     data = helpers.format_search_response(
         page, 20, len(normalized_results), normalized_results
     )