qobuz-cli 0.0.2__tar.gz → 0.0.3__tar.gz

{qobuz_cli-0.0.2 → qobuz_cli-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qobuz-cli
-Version: 0.0.2
+Version: 0.0.3
 Summary:  Blazing fast Qobuz CLI downloader with modern UI
 Project-URL: Homepage, https://github.com/HongYue1/qobuz-cli
 Project-URL: Repository, https://github.com/HongYue1/qobuz-cli
@@ -15,15 +15,15 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 or later (G
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Topic :: Multimedia :: Sound/Audio
-Requires-Python: >=3.10
-Requires-Dist: aiofiles
-Requires-Dist: aiohttp
-Requires-Dist: beautifulsoup4
-Requires-Dist: mutagen
-Requires-Dist: pathvalidate
-Requires-Dist: pydantic
-Requires-Dist: rich
-Requires-Dist: typer
+Requires-Python: >=3.14
+Requires-Dist: aiofiles>=25.1.0
+Requires-Dist: aiohttp>=3.14.1
+Requires-Dist: beautifulsoup4>=4.15.0
+Requires-Dist: mutagen>=1.48.1
+Requires-Dist: pathvalidate>=3.3.1
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: rich>=15.0.0
+Requires-Dist: typer>=0.26.8
 Provides-Extra: dev
 Requires-Dist: jsonschema; extra == 'dev'
 Requires-Dist: ruff>=0.10.0; extra == 'dev'

{qobuz_cli-0.0.2 → qobuz_cli-0.0.3}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "qobuz-cli"
-version = "v0.0.2"
+version = "0.0.3"
 authors = [{ name = "HongYue1", email = "moonlord369@gmail.com" }]
 description = " Blazing fast Qobuz CLI downloader with modern UI"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.14"
 license = "GPL-3.0-or-later"
 license-files = ["LICEN[CS]E.*"]
 keywords = ["qobuz", "music", "downloader", "cli", "audio"]
@@ -24,14 +24,14 @@ classifiers = [
 ]
 
 dependencies = [
-    "aiofiles",
-    "aiohttp",
-    "beautifulsoup4",
-    "mutagen",
-    "pathvalidate",
-    "pydantic",
-    "rich",
-    "typer",
+    "aiofiles>=25.1.0",
+    "aiohttp>=3.14.1",
+    "beautifulsoup4>=4.15.0",
+    "mutagen>=1.48.1",
+    "pathvalidate>=3.3.1",
+    "pydantic>=2.13.4",
+    "rich>=15.0.0",
+    "typer>=0.26.8",
 ]
 
 [project.optional-dependencies]
@@ -48,7 +48,7 @@ qcli = "qobuz_cli.__main__:main"
 
 [tool.ruff]
 line-length = 88
-target-version = "py310"
+target-version = "py314"
 
 [tool.ruff.lint]
 preview = true

{qobuz_cli-0.0.2 → qobuz_cli-0.0.3}/qobuz_cli/__main__.py

@@ -22,7 +22,7 @@ def main() -> None:
         try:
             sys.stdout.reconfigure(encoding="utf-8")
             sys.stderr.reconfigure(encoding="utf-8")
-        except (TypeError, AttributeError):
+        except TypeError, AttributeError:
             pass
 
     log = logging.getLogger("qobuz_cli")
@@ -30,9 +30,9 @@ def main() -> None:
 
     try:
         app()
-    except (typer.Exit, typer.Abort):
+    except typer.Exit, typer.Abort:
         pass
-    except (KeyboardInterrupt, asyncio.CancelledError):
+    except KeyboardInterrupt, asyncio.CancelledError:
         console.print("\n[yellow]⚠️  Operation cancelled by user.[/yellow]")
         sys.exit(0)
     except QobuzCliError as e:

{qobuz_cli-0.0.2 → qobuz_cli-0.0.3}/qobuz_cli/api/auth.py

@@ -26,7 +26,7 @@ class QobuzAuthenticator:
     Manages the authentication flow for the Qobuz API client.
     """
 
-    def __init__(self, api_client: "QobuzAPIClient"):
+    def __init__(self, api_client: QobuzAPIClient):
         """
         Initializes the authenticator.
 
@@ -111,12 +111,14 @@ class QobuzAuthenticator:
 
         log.debug(f"Testing {len(self._api_client.secrets)} potential app secrets...")
 
-        test_tasks = [
-            self._test_secret(secret) for secret in self._api_client.secrets if secret
-        ]
-        results = await asyncio.gather(*test_tasks)
+        # Only test non-empty secrets, and keep the tested list aligned with the
+        # results so a falsy secret can never desynchronize the zip below.
+        valid_candidates = [s for s in self._api_client.secrets if s]
+        results = await asyncio.gather(
+            *(self._test_secret(secret) for secret in valid_candidates)
+        )
 
-        for secret, is_valid in zip(self._api_client.secrets, results, strict=True):
+        for secret, is_valid in zip(valid_candidates, results, strict=True):
             if is_valid:
                 self._api_client.app_secret = secret
                 log.debug(f"Valid secret found: {secret[:8]}...")

{qobuz_cli-0.0.2 → qobuz_cli-0.0.3}/qobuz_cli/api/client.py

@@ -2,6 +2,7 @@
 Enhanced API client with compression for metadata and circuit breaker protection.
 """
 
+import asyncio
 import hashlib
 import logging
 import time
@@ -24,6 +25,27 @@ from .rate_limiter import AdaptiveRateLimiter
 log = logging.getLogger(__name__)
 
 
+def _is_expected_client_error(exc: BaseException) -> bool:
+    """
+    Returns True for errors that mean the API responded but rejected the
+    request for client-side reasons (auth/quality/4xx). These must not count as
+    circuit-breaker failures -- the service itself is healthy.
+    """
+    if isinstance(
+        exc,
+        (
+            AuthenticationError,
+            InvalidAppIdError,
+            InvalidAppSecretError,
+            InvalidQualityError,
+        ),
+    ):
+        return True
+    if isinstance(exc, aiohttp.ClientResponseError):
+        return 400 <= exc.status < 500 and exc.status != 429
+    return False
+
+
 class QobuzAPIClient:
     """
     Optimized async client for the Qobuz JSON API (v0.2).
@@ -64,6 +86,7 @@ class QobuzAPIClient:
             failure_threshold=5,
             recovery_timeout=60,
             success_threshold=2,
+            ignore_predicate=_is_expected_client_error,
         )
 
     @property
@@ -129,6 +152,9 @@ class QobuzAPIClient:
             "intent": "stream",
         }
 
+    # Number of attempts for transient failures (429/5xx/network).
+    MAX_API_ATTEMPTS = 3
+
     async def api_call(self, endpoint: str, **kwargs: Any) -> dict[str, Any]:
         """
         Makes an authenticated API call with rate limiting, retry logic, and
@@ -142,53 +168,7 @@ class QobuzAPIClient:
         # Check circuit breaker before making request
         try:
             async with self._circuit_breaker:
-                await self._rate_limiter.acquire()
-
-                params = kwargs.copy()
-
-                if endpoint == "track/getFileUrl":
-                    params = self._prepare_get_file_url_params(
-                        track_id=params.pop("id"),
-                        format_id=params.pop("fmt_id"),
-                        secret_override=params.pop("sec", None),
-                    )
-
-                if self.user_auth_token:
-                    params["user_auth_token"] = self.user_auth_token
-
-                async with self._session.get(
-                    self.BASE_URL + endpoint, params=params
-                ) as r:
-                    # Check if response was compressed (for logging)
-                    was_compressed = r.headers.get("Content-Encoding") in (
-                        "gzip",
-                        "deflate",
-                        "br",
-                    )
-                    if was_compressed:
-                        log.debug(
-                            f"API response for {endpoint} was compressed "
-                            f"({r.headers.get('Content-Encoding')})"
-                        )
-
-                    if r.status == 429:
-                        await self._rate_limiter.on_429()
-                        r.raise_for_status()
-
-                    if endpoint == "user/login":
-                        if r.status == 401:
-                            raise AuthenticationError("Invalid email or password.")
-                        if r.status == 400 and "Invalid application" in await r.text():
-                            raise InvalidAppIdError("The provided App ID is invalid.")
-
-                    if endpoint == "track/getFileUrl" and r.status == 400:
-                        raise InvalidAppSecretError(
-                            "The app secret is invalid or has expired."
-                        )
-
-                    r.raise_for_status()
-                    return await r.json()
-
+                return await self._request_with_retry(endpoint, kwargs)
         except CircuitBreakerError as e:
             log.error(f"[red]Circuit breaker is open for API calls: {e}[/red]")
             raise
@@ -196,9 +176,96 @@ class QobuzAPIClient:
             log.debug(f"API call to {endpoint} failed: {e}")
             raise
 
+    async def _request_with_retry(
+        self, endpoint: str, params: dict[str, Any]
+    ) -> dict[str, Any]:
+        """
+        Executes a single API request, retrying transient failures (HTTP 429,
+        5xx, and network/timeout errors) with exponential backoff. Client-side
+        4xx errors are raised immediately without retrying.
+        """
+        delay = 1.0
+        last_exc: Exception | None = None
+        for attempt in range(1, self.MAX_API_ATTEMPTS + 1):
+            try:
+                return await self._do_request(endpoint, params)
+            except aiohttp.ClientResponseError as e:
+                last_exc = e
+                is_retryable = e.status == 429 or 500 <= e.status < 600
+                if not is_retryable or attempt == self.MAX_API_ATTEMPTS:
+                    raise
+                log.debug(
+                    f"Transient HTTP {e.status} on {endpoint} "
+                    f"(attempt {attempt}/{self.MAX_API_ATTEMPTS}); "
+                    f"retrying in {delay:.1f}s."
+                )
+            except (aiohttp.ClientError, TimeoutError) as e:
+                last_exc = e
+                if attempt == self.MAX_API_ATTEMPTS:
+                    raise
+                log.debug(
+                    f"Network error on {endpoint} "
+                    f"(attempt {attempt}/{self.MAX_API_ATTEMPTS}): {e}; "
+                    f"retrying in {delay:.1f}s."
+                )
+            await asyncio.sleep(delay)
+            delay *= 2
+
+        # Unreachable in practice: the final attempt always raises above.
+        if last_exc is not None:
+            raise last_exc
+        raise RuntimeError(f"API call to {endpoint} exhausted all retries.")
+
+    async def _do_request(
+        self, endpoint: str, kwargs: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Performs one rate-limited HTTP request and parses the JSON body."""
+        await self._rate_limiter.acquire()
+
+        params = kwargs.copy()
+
+        if endpoint == "track/getFileUrl":
+            params = self._prepare_get_file_url_params(
+                track_id=params.pop("id"),
+                format_id=params.pop("fmt_id"),
+                secret_override=params.pop("sec", None),
+            )
+
+        if self.user_auth_token:
+            params["user_auth_token"] = self.user_auth_token
+
+        async with self._session.get(self.BASE_URL + endpoint, params=params) as r:
+            # Check if response was compressed (for logging)
+            was_compressed = r.headers.get("Content-Encoding") in (
+                "gzip",
+                "deflate",
+                "br",
+            )
+            if was_compressed:
+                log.debug(
+                    f"API response for {endpoint} was compressed "
+                    f"({r.headers.get('Content-Encoding')})"
+                )
+
+            if r.status == 429:
+                await self._rate_limiter.on_429()
+                r.raise_for_status()
+
+            if endpoint == "user/login":
+                if r.status == 401:
+                    raise AuthenticationError("Invalid email or password.")
+                if r.status == 400 and "Invalid application" in await r.text():
+                    raise InvalidAppIdError("The provided App ID is invalid.")
+
+            if endpoint == "track/getFileUrl" and r.status == 400:
+                raise InvalidAppSecretError("The app secret is invalid or has expired.")
+
+            r.raise_for_status()
+            return await r.json()
+
     async def _yield_paginated(
         self, endpoint: str, item_key: str, **kwargs: Any
-    ) -> AsyncGenerator[dict[str, Any], None]:
+    ) -> AsyncGenerator[dict[str, Any]]:
         """
         Generator for handling paginated API endpoints.
         """
@@ -221,7 +288,12 @@ class QobuzAPIClient:
             yield response
 
             offset += items_in_response
-            if offset >= total_items:
+
+            # A short page reliably signals the end, regardless of whether the
+            # API returned a usable "<item>_count" total (it sometimes doesn't).
+            if items_in_response < limit:
+                break
+            if total_items and offset >= total_items:
                 break
 
     # Public API Methods
@@ -236,21 +308,17 @@ class QobuzAPIClient:
 
     def fetch_artist_discography(
         self, artist_id: str
-    ) -> AsyncGenerator[dict[str, Any], None]:
+    ) -> AsyncGenerator[dict[str, Any]]:
         return self._yield_paginated(
             "artist/get", item_key="albums", artist_id=artist_id, extra="albums"
         )
 
-    def fetch_playlist_tracks(
-        self, playlist_id: str
-    ) -> AsyncGenerator[dict[str, Any], None]:
+    def fetch_playlist_tracks(self, playlist_id: str) -> AsyncGenerator[dict[str, Any]]:
         return self._yield_paginated(
             "playlist/get", item_key="tracks", playlist_id=playlist_id, extra="tracks"
         )
 
-    def fetch_label_discography(
-        self, label_id: str
-    ) -> AsyncGenerator[dict[str, Any], None]:
+    def fetch_label_discography(self, label_id: str) -> AsyncGenerator[dict[str, Any]]:
         return self._yield_paginated(
             "label/get", item_key="albums", label_id=label_id, extra="albums"
         )

{qobuz_cli-0.0.2 → qobuz_cli-0.0.3}/qobuz_cli/api/rate_limiter.py

@@ -47,19 +47,26 @@ class AdaptiveRateLimiter:
 
     async def acquire(self) -> None:
         """
-        Waits if necessary to respect the current rate limit before allowing a call
-        to proceed.
+        Waits if necessary to respect the current rate limit before allowing a
+        call to proceed.
+
+        The wait is computed while holding the lock but performed *after*
+        releasing it, so a slow caller's sleep does not serialize every other
+        concurrent caller. Each caller reserves its own slot by advancing
+        ``_last_call_time`` before sleeping.
         """
         async with self._lock:
+            now = time.monotonic()
+
             # Gradually recover the rate if no 429 errors have occurred recently
-            if time.monotonic() - self._last_429_time > 300:  # 5 minutes
+            if now - self._last_429_time > 300:  # 5 minutes
                 self._rate = min(self._max_rate, self._rate * 1.005)  # Slow recovery
                 self._min_interval = 1.0 / self._rate
 
-            now = asyncio.get_event_loop().time()
-            time_since_last = now - self._last_call_time
-
-            if time_since_last < self._min_interval:
-                await asyncio.sleep(self._min_interval - time_since_last)
+            # Reserve the next slot: the earliest time this call may proceed.
+            scheduled_time = max(now, self._last_call_time + self._min_interval)
+            self._last_call_time = scheduled_time
+            wait_time = scheduled_time - now
 
-            self._last_call_time = asyncio.get_event_loop().time()
+        if wait_time > 0:
+            await asyncio.sleep(wait_time)

{qobuz_cli-0.0.2 → qobuz_cli-0.0.3}/qobuz_cli/cli/app.py

@@ -178,7 +178,8 @@ def init(
             secrets = list(bundle.extract_secrets().values())
             console.print("[green]✓ Secrets fetched successfully.[/green]")
         except Exception as e:
-            console.print(f"[red]✗ Failed to fetch secrets: {e}[/red]")
+            detail = str(e) or type(e).__name__
+            console.print(f"[red]✗ Failed to fetch secrets: {detail}[/red]")
             raise typer.Exit(code=1) from e
         settings = {"app_id": app_id, "secrets": secrets}
         if len(credentials) == 1:

{qobuz_cli-0.0.2 → qobuz_cli-0.0.3}/qobuz_cli/cli/progress_manager.py

@@ -6,6 +6,7 @@ statistics.
 
 import asyncio
 import logging
+import time
 from datetime import datetime
 from typing import Any
 
@@ -85,6 +86,11 @@ class ProgressManager:
         self._overall_task_id: TaskID | None = None
         self._active_tasks: dict[TaskID, dict] = {}
 
+        # Throttle expensive full-layout rebuilds; the Live object still
+        # refreshes the last-built layout at its own refresh_per_second.
+        self._last_display_update = 0.0
+        self._display_min_interval = 0.1  # seconds (~10 rebuilds/sec)
+
     def log_message(self, message: str, level: str = "info"):
         """Unified logging respecting dry_run mode."""
         if self.dry_run:
@@ -293,13 +299,23 @@ class ProgressManager:
             border_style="green",
         )
 
-    def _update_display(self):
+    def _update_display(self, force: bool = False):
         """
-        Updates all panels in the layout, letting the Live object handle refresh rate.
+        Rebuilds all panels in the layout, letting the Live object handle the
+        actual on-screen refresh rate.
+
+        Rebuilds are throttled to a few times per second because they are
+        expensive; callers that change structure (task added/removed) pass
+        ``force=True`` so those changes appear immediately.
         """
         if self.dry_run or not self._layout:
             return
 
+        now = time.monotonic()
+        if not force and (now - self._last_display_update) < self._display_min_interval:
+            return
+        self._last_display_update = now
+
         self._layout["header"].update(self._generate_header())
         self._layout["stats"].update(self._generate_stats_panel())
         self._layout["album_context"].update(self._generate_album_context_panel())
@@ -369,7 +385,7 @@ class ProgressManager:
         self._stats["peak_concurrent"] = max(
             self._stats["peak_concurrent"], self._stats["active_downloads"]
         )
-        self._update_display()
+        self._update_display(force=True)
         return task_id
 
     def update_task_progress(self, task_id: TaskID, completed: int):
@@ -402,7 +418,7 @@ class ProgressManager:
                         + self._stats["skipped"]
                     ),
                 )
-            self._update_display()
+            self._update_display(force=True)
         except KeyError:
             pass
 
@@ -417,7 +433,7 @@ class ProgressManager:
                     + self._stats["skipped"]
                 ),
             )
-        self._update_display()
+        self._update_display(force=True)
 
     def get_statistics(self) -> dict[str, Any]:
         return self._stats.copy()
@@ -426,7 +442,7 @@ class ProgressManager:
         if self.dry_run:
             return self
         self._layout = self._create_layout()
-        self._update_display()
+        self._update_display(force=True)
         self._live = Live(
             self._layout,
             console=self.console,

{qobuz_cli-0.0.2 → qobuz_cli-0.0.3}/qobuz_cli/core/download_manager.py

@@ -23,7 +23,6 @@ from qobuz_cli.models.config import DownloadConfig
 from qobuz_cli.models.stats import DownloadStats
 from qobuz_cli.storage.archive import TrackArchive
 from qobuz_cli.storage.cache import CacheManager
-from qobuz_cli.utils.batch_fetcher import BatchMetadataFetcher
 from qobuz_cli.utils.discography import smart_discography_filter
 from qobuz_cli.utils.formatting import extract_artist_name
 from qobuz_cli.utils.path import create_dir, parse_qobuz_url
@@ -58,7 +57,6 @@ class DownloadManager:
             Tagger(config.embed_art),
             progress_manager,
         )
-        self.batch_fetcher = BatchMetadataFetcher(api_client, max_concurrent=10)
 
         def cache_stats_callback(is_hit: bool):
             if is_hit:
@@ -303,7 +301,7 @@ class DownloadManager:
                 self.cache.set(cache_key, track_meta)
 
         archive_status = {}
-        if self.config.download_archive:
+        if self.config.download_archive and not self.config.dry_run:
             archive_status = await self.archive.check_if_tracks_exist([str(track_id)])
 
         if archive_status.get(str(track_id)):
@@ -421,11 +419,15 @@ class DownloadManager:
         )
         self.stats.albums_processed.add(f"playlist_{playlist_id}")
 
-        for track in all_tracks:
-            album_meta = track.get("album", {})
-            await self._get_and_process_track(
-                track, album_meta, output_dir_override=playlist_dir
+        playlist_tasks = [
+            self._get_and_process_track(
+                track,
+                track.get("album", {}),
+                output_dir_override=playlist_dir,
             )
+            for track in all_tracks
+        ]
+        await asyncio.gather(*playlist_tasks)
 
         if not self.config.no_m3u and not self.config.dry_run:
             generate_m3u(playlist_dir)
@@ -514,7 +516,7 @@ class DownloadManager:
                     if self.config.download_archive:
                         await self.archive.add_tracks([processed_meta])
                     return processed_meta
-            except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+            except (TimeoutError, aiohttp.ClientError) as e:
                 self.stats.tracks_failed += 1
                 log.error(
                     "[red]  ✗ Network error for track "
@@ -567,7 +569,7 @@ class DownloadManager:
             ):
                 response.raise_for_status()
                 html = await response.text()
-        except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+        except (TimeoutError, aiohttp.ClientError) as e:
             log.error(f"[red]Failed to fetch Last.fm playlist: {e}[/red]")
             return
 
@@ -583,8 +585,14 @@ class DownloadManager:
             log.warning("[yellow]No tracks found on Last.fm page.[/yellow]")
             return
 
+        if len(artists) != len(titles):
+            log.warning(
+                "[yellow]Last.fm page returned mismatched artist/title counts "
+                f"({len(artists)} artists, {len(titles)} titles); pairing up to "
+                "the shorter list.[/yellow]"
+            )
         search_queries = [
-            f"{artist} {title}" for artist, title in zip(artists, titles, strict=True)
+            f"{artist} {title}" for artist, title in zip(artists, titles, strict=False)
         ]
         log.info(f"Found {len(search_queries)} tracks. Searching for them on Qobuz...")
 

{qobuz_cli-0.0.2 → qobuz_cli-0.0.3}/qobuz_cli/core/track_processor.py

@@ -13,7 +13,7 @@ from typing import Any
 from rich.markup import escape
 
 from qobuz_cli.cli.progress_manager import ProgressManager
-from qobuz_cli.exceptions import FileIntegrityError
+from qobuz_cli.exceptions import FileIntegrityError, QobuzCliError
 from qobuz_cli.media import Downloader, FileIntegrityChecker, Tagger
 from qobuz_cli.models.config import DownloadConfig, get_quality_info
 from qobuz_cli.models.stats import DownloadStats
@@ -125,8 +125,9 @@ class TrackProcessor:
 
         # Download cover art if needed (optimized double-checked locking)
         if not self.config.no_cover:
-            album_id_str = str(album_meta.get("id"))
-            if album_id_str:
+            album_id_val = album_meta.get("id")
+            if album_id_val:
+                album_id_str = str(album_id_val)
                 cover_path = final_dir / "cover.jpg"
                 # First check (outside lock) for performance
                 path_exists = await asyncio.to_thread(cover_path.exists)
@@ -195,7 +196,7 @@ class TrackProcessor:
                 max_workers=self.config.max_workers,
             )
 
-            await asyncio.to_thread(
+            tag_success = await asyncio.to_thread(
                 self.tagger.tag_file,
                 str(temp_path),
                 str(final_path),
@@ -203,6 +204,10 @@ class TrackProcessor:
                 album_meta,
                 is_mp3,
             )
+            if not tag_success:
+                raise QobuzCliError(
+                    "Failed to write metadata tags to the downloaded file."
+                )
 
             is_valid = await (
                 FileIntegrityChecker.check_mp3_async(str(final_path))

{qobuz_cli-0.0.2 → qobuz_cli-0.0.3}/qobuz_cli/media/downloader.py

@@ -125,15 +125,23 @@ class Downloader:
                         bytes_downloaded = 0
                         last_speed_check = asyncio.get_event_loop().time()
                         chunk_size = self._shared_chunk_size
-
-                        async for chunk in response.content.iter_chunked(chunk_size):
+                        stream = response.content
+
+                        # Manual read loop (instead of iter_chunked) so an
+                        # adapted chunk size actually takes effect mid-download.
+                        while True:
+                            chunk = await stream.read(chunk_size)
+                            if not chunk:
+                                break
                             await f.write(chunk)
                             bytes_downloaded += len(chunk)
 
                             if stats:
-                                await stats.update_speed_stats(
-                                    stats.total_size_downloaded + bytes_downloaded,
-                                    progress_manager,
+                                # Report only this chunk's bytes; DownloadStats
+                                # aggregates them into a session-wide counter for
+                                # accurate concurrent speed measurement.
+                                await stats.record_progress(
+                                    len(chunk), progress_manager
                                 )
                                 now = asyncio.get_event_loop().time()
                                 if now - last_speed_check > 2.0:
@@ -147,7 +155,7 @@ class Downloader:
                                     task_id, completed=bytes_downloaded
                                 )
                 return
-            except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+            except (TimeoutError, aiohttp.ClientError) as e:
                 last_exception = e
                 log.debug(
                     f"Download attempt {attempt}/{self.max_attempts} for "