Support multiple Radarr/Sonarr instances (fixes #954)

- Rename RadarrAccount/SonarrAccount to RadarrInstance/SonarrInstance,
  changing the OneToOne singleton to a ForeignKey so a user can connect
  more than one server per service (e.g. a 4K instance and an anime one).
- Scope CollectionSourceState, Celery Beat scheduling, and the
  Radarr/Sonarr importers to a specific instance instead of the user,
  so two instances no longer clobber each other's sync schedule or
  quality/ownership metadata.
- Redo the Import Sources modal to list connected instances as compact
  rows with sync/disconnect icon buttons, plus an always-visible
  "connect another instance" form.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: dannyvfilms

src/integrations/imports/radarr.py

@@ -16,7 +16,7 @@
     decrypt_or_raise,
     find_item_across_buckets,
 )
-from integrations.models import RadarrAccount
+from integrations.models import RadarrInstance
 from integrations.source_sync import upsert_collection_source_state
 
 logger = logging.getLogger(__name__)
@@ -57,34 +57,39 @@ def movies(self):
         return self._request("/api/v3/movie")
 
 
-def importer(identifier, user, mode):
+def importer(identifier, user, mode, instance_id=None):
     """Import Radarr collection ownership."""
-    return RadarrImporter(user).import_data()
+    instance = (
+        RadarrInstance.objects.get(pk=instance_id, user=user) if instance_id else None
+    )
+    return RadarrImporter(user, instance=instance).import_data()
 
 
 class RadarrImporter:
     """Import collection data from Radarr."""
 
-    def __init__(self, user):
-        """Store the extra keyword arguments this form needs."""
+    def __init__(self, user, instance=None):
+        """Bind the importer to a user with a connected Radarr instance."""
         self.user = user
-        try:
-            self.account = user.radarr_account
-        except RadarrAccount.DoesNotExist as error:
+        if instance is not None:
+            self.instance = instance
+        else:
+            self.instance = user.radarr_instances.first()
+        if self.instance is None:
             msg = "Connect Radarr before importing"
-            raise MediaImportError(msg) from error
+            raise MediaImportError(msg)
 
         try:
-            api_key = decrypt_or_raise(self.account.api_key)
+            api_key = decrypt_or_raise(self.instance.api_key)
         except MediaImportError as error:
-            self.account.connection_broken = True
-            self.account.last_error_message = str(error)
-            self.account.save(
+            self.instance.connection_broken = True
+            self.instance.last_error_message = str(error)
+            self.instance.save(
                 update_fields=["connection_broken", "last_error_message", "updated_at"],
             )
             raise
 
-        self.client = RadarrClient(self.account.base_url, api_key)
+        self.client = RadarrClient(self.instance.base_url, api_key)
         self.warnings = []
 
     def import_data(self):
@@ -94,9 +99,9 @@ def import_data(self):
         try:
             movies = self.client.movies()
         except MediaImportError as error:
-            self.account.connection_broken = True
-            self.account.last_error_message = str(error)
-            self.account.save(
+            self.instance.connection_broken = True
+            self.instance.last_error_message = str(error)
+            self.instance.save(
                 update_fields=["connection_broken", "last_error_message", "updated_at"]
             )
             raise
@@ -120,16 +125,17 @@ def import_data(self):
                 user=self.user,
                 item=item,
                 source="radarr",
+                source_instance_id=self.instance.pk,
                 quality_label=quality_label,
                 source_updated_at=updated_at,
             )
             imported_counts[item.media_type] += 1
             imported_counts["updated"] += 1
 
-        self.account.last_sync_at = timezone.now()
-        self.account.connection_broken = False
-        self.account.last_error_message = ""
-        self.account.save(
+        self.instance.last_sync_at = timezone.now()
+        self.instance.connection_broken = False
+        self.instance.last_error_message = ""
+        self.instance.save(
             update_fields=[
                 "last_sync_at",
                 "connection_broken",

src/integrations/imports/sonarr.py

@@ -16,7 +16,7 @@
     find_item_across_buckets,
     retry_on_lock,
 )
-from integrations.models import SonarrAccount
+from integrations.models import SonarrInstance
 from integrations.source_sync import (
     remove_collection_source_state,
     upsert_collection_source_state,
@@ -67,34 +67,39 @@ def episodes(self, series_id):
         return self._request("/api/v3/episode", params={"seriesId": series_id})
 
 
-def importer(identifier, user, mode):
+def importer(identifier, user, mode, instance_id=None):
     """Import Sonarr collection ownership."""
-    return SonarrImporter(user).import_data()
+    instance = (
+        SonarrInstance.objects.get(pk=instance_id, user=user) if instance_id else None
+    )
+    return SonarrImporter(user, instance=instance).import_data()
 
 
 class SonarrImporter:
     """Import collection data from Sonarr."""
 
-    def __init__(self, user):
-        """Bind the importer to a user with a connected Sonarr account."""
+    def __init__(self, user, instance=None):
+        """Bind the importer to a user with a connected Sonarr instance."""
         self.user = user
-        try:
-            self.account = user.sonarr_account
-        except SonarrAccount.DoesNotExist as error:
+        if instance is not None:
+            self.instance = instance
+        else:
+            self.instance = user.sonarr_instances.first()
+        if self.instance is None:
             msg = "Connect Sonarr before importing"
-            raise MediaImportError(msg) from error
+            raise MediaImportError(msg)
 
         try:
-            api_key = decrypt_or_raise(self.account.api_key)
+            api_key = decrypt_or_raise(self.instance.api_key)
         except MediaImportError as error:
-            self.account.connection_broken = True
-            self.account.last_error_message = str(error)
-            self.account.save(
+            self.instance.connection_broken = True
+            self.instance.last_error_message = str(error)
+            self.instance.save(
                 update_fields=["connection_broken", "last_error_message", "updated_at"],
             )
             raise
 
-        self.client = SonarrClient(self.account.base_url, api_key)
+        self.client = SonarrClient(self.instance.base_url, api_key)
         self.warnings = []
 
     def import_data(self):
@@ -104,9 +109,9 @@ def import_data(self):
         try:
             series_rows = self.client.series()
         except MediaImportError as error:
-            self.account.connection_broken = True
-            self.account.last_error_message = str(error)
-            self.account.save(
+            self.instance.connection_broken = True
+            self.instance.last_error_message = str(error)
+            self.instance.save(
                 update_fields=["connection_broken", "last_error_message", "updated_at"],
             )
             raise
@@ -132,10 +137,10 @@ def import_data(self):
             imported_counts[item.media_type] += 1
             imported_counts["updated"] += 1
 
-        self.account.last_sync_at = timezone.now()
-        self.account.connection_broken = False
-        self.account.last_error_message = ""
-        self.account.save(
+        self.instance.last_sync_at = timezone.now()
+        self.instance.connection_broken = False
+        self.instance.last_error_message = ""
+        self.instance.save(
             update_fields=[
                 "last_sync_at",
                 "connection_broken",
@@ -233,6 +238,7 @@ def _sync_series_episode_collection(self, show_item, row):
                 user=self.user,
                 item=show_item,
                 source="sonarr",
+                source_instance_id=self.instance.pk,
                 quality_label="",
                 source_updated_at=self._parse_source_timestamp(row),
             )
@@ -260,6 +266,7 @@ def _sync_series_episode_collection(self, show_item, row):
                 user=self.user,
                 item=episode_item,
                 source="sonarr",
+                source_instance_id=self.instance.pk,
                 quality_label=self._extract_episode_quality_label(episode_row),
                 source_updated_at=self._parse_source_timestamp(episode_row),
             )
@@ -456,7 +463,11 @@ def _prune_series_collection_state(self, show_item, *, keep_episode_item_ids=Non
                 media_type=MediaTypes.EPISODE.value,
             )
             .exclude(id__in=keep_episode_item_ids)
-            .filter(source_states__user=self.user, source_states__source="sonarr")
+            .filter(
+                source_states__user=self.user,
+                source_states__source="sonarr",
+                source_states__source_instance_id=self.instance.pk,
+            )
             .values_list("id", flat=True)
             .distinct()
         )
@@ -466,6 +477,7 @@ def _prune_series_collection_state(self, show_item, *, keep_episode_item_ids=Non
                 user=self.user,
                 item=episode_item,
                 source="sonarr",
+                source_instance_id=self.instance.pk,
             )
 
         if keep_episode_item_ids:
@@ -475,13 +487,15 @@ def _prune_series_collection_state(self, show_item, *, keep_episode_item_ids=Non
             user=self.user,
             item=show_item,
             source="sonarr",
+            source_instance_id=self.instance.pk,
         )
 
     def _retire_legacy_series_collection_entry(self, show_item):
         """Delete the legacy show-level Sonarr row once episode rows exist."""
         if not show_item.source_states.filter(
             user=self.user,
             source="sonarr",
+            source_instance_id=self.instance.pk,
         ).exists():
             return