fix: 🐛 "Future attached to a different loop" Fehler bei async_list_backups behoben

Response-Body-Streams von aiobotocore sind an den Worker-Thread-Event-Loop
gebunden und können nicht im Home Assistant Event-Loop gelesen werden.

- get_object_body(): Liest Body vollständig im Worker-Thread (Metadaten)
- get_object_stream(): Streamt Body über thread-sichere Queue (Backups)
- Behebt auch latenten Fehler in async_download_backup()

Fixes #3

Author: karlspace

CHANGELOG.md

@@ -5,6 +5,18 @@ Alle wichtigen Änderungen an diesem Projekt werden in dieser Datei dokumentiert
 Das Format basiert auf [Keep a Changelog](https://keepachangelog.com/de/1.0.0/),
 und dieses Projekt folgt [Semantic Versioning](https://semver.org/lang/de/).
 
+## [0.1.6] - 2026-03-03
+
+### 🐛 Fixed
+
+- **"Future attached to a different loop" Fehler behoben** ([#3](https://github.com/bauer-group/IP-HomeassistantS3CompatibleBackup/issues/3))
+  - `async_list_backups()` schlug fehl, weil der aiohttp-Response-Body-Stream an den Worker-Thread-Event-Loop gebunden war, aber im Home Assistant Event-Loop gelesen wurde
+  - Neue Methode `get_object_body()` liest den gesamten Body im Worker-Thread (für kleine Objekte wie Metadaten-JSON)
+  - Neue Methode `get_object_stream()` streamt Body-Chunks über eine thread-sichere Queue zwischen Worker- und Main-Event-Loop (für große Backup-Dateien)
+  - Behebt auch einen latenten Fehler in `async_download_backup()`, der beim Wiederherstellen von Backups aufgetreten wäre
+
+---
+
 ## [0.1.5] - 2026-01-13
 
 ### 🐛 Fixed

custom_components/bauergroup_s3compatiblebackup/__init__.py

@@ -4,6 +4,8 @@
 
 import asyncio
 import logging
+from collections.abc import AsyncIterator
+from queue import Queue
 from threading import Thread
 from typing import Any, cast
 
@@ -140,6 +142,52 @@ async def get_object(self, **kwargs: Any) -> dict[str, Any]:
         """Get an object from a bucket."""
         return await self._dispatch(self._client.get_object(**kwargs))
 
+    async def get_object_body(self, **kwargs: Any) -> bytes:
+        """Get an object and read its full body in the worker thread.
+
+        This avoids the 'Future attached to a different loop' error that occurs
+        when trying to read a response body stream from a different event loop.
+        Use this for small objects (e.g., metadata JSON files).
+        """
+
+        async def _get_and_read() -> bytes:
+            response = await self._client.get_object(**kwargs)
+            return await response["Body"].read()
+
+        return await self._dispatch(_get_and_read())
+
+    async def get_object_stream(self, **kwargs: Any) -> AsyncIterator[bytes]:
+        """Get an object and stream its body from the worker thread.
+
+        Uses a thread-safe queue to bridge the worker thread's event loop
+        and the caller's event loop for streaming large objects (e.g., backups).
+        """
+        data_queue: Queue[bytes | None] = Queue()
+        error_holder: list[BaseException | None] = [None]
+
+        async def _stream_body() -> None:
+            try:
+                response = await self._client.get_object(**kwargs)
+                async for chunk in response["Body"].iter_chunks():
+                    data_queue.put(chunk)
+            except BaseException as exc:
+                error_holder[0] = exc
+            finally:
+                data_queue.put(None)  # Sentinel to signal completion
+
+        if self._loop is None:
+            raise RuntimeError("Worker loop not started")
+        asyncio.run_coroutine_threadsafe(_stream_body(), self._loop)
+
+        loop = asyncio.get_running_loop()
+        while True:
+            chunk = await loop.run_in_executor(None, data_queue.get)
+            if chunk is None:
+                if error_holder[0] is not None:
+                    raise error_holder[0]
+                break
+            yield chunk
+
     async def put_object(self, **kwargs: Any) -> dict[str, Any]:
         """Put an object into a bucket."""
         return await self._dispatch(self._client.put_object(**kwargs))

custom_components/bauergroup_s3compatiblebackup/backup.py

@@ -148,10 +148,9 @@ async def async_download_backup(
         backup = await self._find_backup_by_id(backup_id)
         tar_filename, _ = suggested_filenames(backup)
 
-        response = await self._client.get_object(
+        return self._client.get_object_stream(
             Bucket=self._bucket, Key=self._get_key(tar_filename)
         )
-        return response["Body"].iter_chunks()
 
     async def async_upload_backup(
         self,
@@ -363,10 +362,11 @@ async def _list_backups(self) -> dict[str, AgentBackup]:
             for metadata_file in metadata_files:
                 try:
                     # Download and parse metadata file
-                    metadata_response = await self._client.get_object(
+                    # Use get_object_body to read entirely in the worker thread,
+                    # avoiding 'Future attached to a different loop' errors
+                    metadata_content = await self._client.get_object_body(
                         Bucket=self._bucket, Key=metadata_file["Key"]
                     )
-                    metadata_content = await metadata_response["Body"].read()
                     metadata_json = json.loads(metadata_content)
                 except (BotoCoreError, json.JSONDecodeError) as err:
                     _LOGGER.warning(

custom_components/bauergroup_s3compatiblebackup/manifest.json

@@ -16,5 +16,5 @@
   "requirements": [
     "aiobotocore>=2.6.0,<3.0.0"
   ],
-  "version": "0.1.5"
+  "version": "0.1.6"
 }