Add handling for ChunkedEncodingError causes

Update save_file_with_progress to catch ChunkedEncodingError and mark downloads as failed when they are interrupted.
Handles IncompleteRead and ConnectionResetError (wrapped inside ChunkedEncodingError), allowing partial files to be retried during the final synchronous attempt.

Author: Lysagxra

helpers/config.py

@@ -72,8 +72,10 @@ class HTTPStatus(IntEnum):
 
     OK = 200
     FORBIDDEN = 403
+    TOO_MANY_REQUESTS = 429
     INTERNAL_ERROR = 500
     BAD_GATEWAY = 502
+    SERVICE_UNAVAILABLE = 503
     SERVER_DOWN = 521
 
 # Mapping of HTTP error codes to human-readable fetch error messages.

helpers/downloaders/album_downloader.py

@@ -48,7 +48,7 @@ async def execute_item_download(
 
             # Download item
             if item_download_link:
-                downloader = MediaDownloader(
+                media_downloader = MediaDownloader(
                     session_info=self.session_info,
                     download_info=DownloadInfo(
                         download_link=item_download_link,
@@ -58,52 +58,53 @@ async def execute_item_download(
                     live_manager=self.live_manager,
                 )
 
-                failed_download = await asyncio.to_thread(downloader.download)
+                failed_download = await asyncio.to_thread(media_downloader.download)
                 if failed_download:
                     self.failed_downloads.append(failed_download)
 
-    async def retry_failed_download(
+    async def download_album(self, max_workers: int = MAX_WORKERS) -> None:
+        """Handle the album download."""
+        num_tasks = len(self.album_info.item_pages)
+        self.live_manager.add_overall_task(
+            description=self.album_info.album_id,
+            num_tasks=num_tasks,
+        )
+
+        # Create tasks for downloading each item in the album
+        semaphore = asyncio.Semaphore(max_workers)
+        tasks = [
+            self.execute_item_download(item_page, current_task, semaphore)
+            for current_task, item_page in enumerate(self.album_info.item_pages)
+        ]
+        await asyncio.gather(*tasks)
+
+        # If there are failed downloads, process them after all downloads are complete
+        if self.failed_downloads:
+            await self._process_failed_downloads()
+
+    # Private methods
+    async def _retry_failed_download(
         self,
         task: int,
         filename: str,
         download_link: str,
     ) -> None:
         """Handle failed downloads and retries them."""
-        downloader = MediaDownloader(
+        media_downloader = MediaDownloader(
             session_info=self.session_info,
             download_info=DownloadInfo(download_link, filename, task),
             live_manager=self.live_manager,
             retries=1,  # Retry once for failed downloads
         )
         # Run the synchronous download function in a separate thread
-        await asyncio.to_thread(downloader.download)
+        await asyncio.to_thread(media_downloader.download)
 
-    async def process_failed_downloads(self) -> None:
+    async def _process_failed_downloads(self) -> None:
         """Process any failed downloads after the initial attempt."""
         for data in self.failed_downloads:
-            await self.retry_failed_download(
+            await self._retry_failed_download(
                 data["id"],
                 data["filename"],
                 data["download_link"],
             )
         self.failed_downloads.clear()
-
-    async def download_album(self, max_workers: int = MAX_WORKERS) -> None:
-        """Handle the album download."""
-        num_tasks = len(self.album_info.item_pages)
-        self.live_manager.add_overall_task(
-            description=self.album_info.album_id,
-            num_tasks=num_tasks,
-        )
-
-        # Create tasks for downloading each item in the album
-        semaphore = asyncio.Semaphore(max_workers)
-        tasks = [
-            self.execute_item_download(item_page, current_task, semaphore)
-            for current_task, item_page in enumerate(self.album_info.item_pages)
-        ]
-        await asyncio.gather(*tasks)
-
-        # If there are failed downloads, process them after all downloads are complete
-        if self.failed_downloads:
-            await self.process_failed_downloads()

helpers/downloaders/download_utils.py

@@ -5,6 +5,7 @@
 from pathlib import Path
 
 from requests import Response
+from requests.exceptions import ChunkedEncodingError
 
 from helpers.config import LARGE_FILE_CHUNK_SIZE, THRESHOLDS
 from helpers.managers.progress_manager import ProgressManager
@@ -28,29 +29,36 @@ def save_file_with_progress(
 ) -> bool:
     """Save the file from the response to the specified path.
 
-    Add a `.temp` extension if the download is partial.
+    Add a `.temp` extension if the download is partial. Handles network interruptions
+    such as IncompleteRead and ConnectionResetError (wrapped in ChunkedEncodingError)
+    by marking the download as incomplete.
     """
     file_size = int(response.headers.get("Content-Length", -1))
     if file_size == -1:
         logging.warning("Content length not provided in response headers.")
 
-    # Create a temporary download path with the .temp extension
+    # Initialize a temporary download path with the .temp extension
     temp_download_path = Path(download_path).with_suffix(".temp")
     chunk_size = get_chunk_size(file_size)
     total_downloaded = 0
 
-    with temp_download_path.open("wb") as file:
-        for chunk in response.iter_content(chunk_size=chunk_size):
-            if chunk is not None:
-                file.write(chunk)
-                total_downloaded += len(chunk)
-                completed = (total_downloaded / file_size) * 100
-                progress_manager.update_task(task, completed=completed)
+    try:
+        with temp_download_path.open("wb") as file:
+            for chunk in response.iter_content(chunk_size=chunk_size):
+                if chunk is not None:
+                    file.write(chunk)
+                    total_downloaded += len(chunk)
+                    completed = (total_downloaded / file_size) * 100
+                    progress_manager.update_task(task, completed=completed)
 
-    # After download is complete, rename the temp file to the original filename
+    # Handle partial downloads caused by network interruptions
+    except ChunkedEncodingError:
+        return True
+
+    # Rename temp file to final filename if fully downloaded
     if total_downloaded == file_size:
         shutil.move(temp_download_path, download_path)
         return False
 
-    # Return True if the download is incomplete
+    # Keep partial file and return True if incomplete
     return True