aw-cli 2.3.2__tar.gz → 2.3.3__tar.gz

{aw_cli-2.3.2 → aw_cli-2.3.3}/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,3 +1,11 @@
+---
+name: Bug report
+about: Segnala un problema con aw-cli
+title: "[Bug]: "
+labels: bug
+assignees: ""
+---
+
 ## Descrizione del problema
 
 Descrivi chiaramente il problema riscontrato.

{aw_cli-2.3.2 → aw_cli-2.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: aw-cli
-Version: 2.3.2
+Version: 2.3.3
 Summary: Guarda anime dal terminale e molto altro!
 Project-URL: Homepage, https://github.com/fexh10/aw-cli
 Project-URL: Repository, https://github.com/fexh10/aw-cli
@@ -9,6 +9,7 @@ License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: pip-system-certs>=5.2
+Requires-Dist: pip>=26.2.0
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: regex>=2025.9.18
 Requires-Dist: rich>=13.9.4

{aw_cli-2.3.2 → aw_cli-2.3.3}/pyproject.toml

@@ -7,6 +7,7 @@ license = "GPL-3.0"
 requires-python = ">=3.10"
 dependencies = [
     "httpx>=0.28.1",
+    "pip>=26.2.0",
     "pip-system-certs>=5.2",
     "pydantic>=2.12.5",
     "regex>=2025.9.18",

aw_cli-2.3.3/src/aw_cli/download.py

@@ -0,0 +1,188 @@
+import asyncio
+import re
+from pathlib import Path
+from httpx import AsyncClient
+from rich.progress import Progress, BarColumn, TextColumn, TaskID, DownloadColumn, TransferSpeedColumn
+from . import utilities as ut
+from .anime import Anime
+from .providers import Provider
+
+from functools import lru_cache
+
+# Numero di connessioni parallele usate di default per scaricare un singolo
+# episodio. Molti CDN limitano la banda per-connessione: scaricare lo stesso
+# file a segmenti con più connessioni aggira quel limite. Sovrascrivibile
+# tramite l'opzione "connections-per-download" nel file di configurazione.
+DEFAULT_CONNECTIONS = 4
+
+# Dimensione dei blocchi letti dallo stream. 1 MB riduce drasticamente
+# l'overhead rispetto a letture da 1 KB su file di centinaia di MB.
+CHUNK_SIZE = 1024 * 1024
+
+def _segment_ranges(total: int, connections: int) -> list[tuple[int, int]]:
+    """
+    Divide un download in intervalli byte inclusivi, evitando segmenti vuoti.
+    """
+    if total <= 0 or connections <= 0:
+        return []
+
+    connections = min(connections, total)
+    base_size, remainder = divmod(total, connections)
+    ranges = []
+    start = 0
+    for i in range(connections):
+        size = base_size + (1 if i < remainder else 0)
+        end = start + size - 1
+        ranges.append((start, end))
+        start = end + 1
+    return ranges
+
+def _valid_partial_response(response, start: int, end: int, total: int) -> bool:
+    """
+    Verifica che il server abbia rispettato il Range richiesto.
+    """
+    if response.status_code != 206:
+        return False
+
+    content_range = response.headers.get("content-range", "")
+    match = re.fullmatch(r"bytes (\d+)-(\d+)/(\d+|\*)", content_range)
+    if not match:
+        return False
+
+    actual_start = int(match.group(1))
+    actual_end = int(match.group(2))
+    actual_total = match.group(3)
+    return (
+        actual_start == start
+        and actual_end == end
+        and (actual_total == "*" or int(actual_total) == total)
+    )
+
+@lru_cache
+def path(create: bool = True) -> Path:
+    """
+    Restituisce il percorso di download dell'anime, a seconda del sistema operativo in uso.
+    Se create è True (valore predefinito) e il percorso non esiste, viene creato.
+
+    Args:
+        create (bool, optional): se impostato a True, crea il percorso se non esiste. Valore predefinito: True.
+
+    Returns:
+        Path: il percorso di download dell'anime.
+    """
+
+    if (ut.os_name == "Android"):
+        path = Path("/sdcard/Movies/Anime")
+    else:
+        path = Path.home() / "Videos/Anime"
+
+    if create:
+        path.mkdir(parents=True, exist_ok=True)
+    return path
+
+def episodes(anime: Anime, episodes: list[Anime.Episode], provider: Provider) -> None:
+    """
+    Scarica più episodi in modo concorrente (max concurrent_downloads).
+
+    Args:
+        anime (Anime): l'anime di cui scaricare gli episodi.
+        episodes (list[Anime.Episode]): la lista degli episodi da scaricare.
+        provider (Provider): il provider da cui scaricare gli episodi.
+    """
+    async def download_worker(ep: Anime.Episode, task_id: TaskID, progress: Progress, sem: asyncio.Semaphore):
+        async with sem:
+            filename = path() / anime.name / f"{ep}.mp4"
+            if filename.exists():
+                progress.update(task_id, completed=100, total=100, description=f"[green]Ep. {ep.num} (Esistente)")
+                return
+
+            filename.parent.mkdir(parents=True, exist_ok=True)
+            try:
+                url = provider.episode_link(anime, ep)
+            except Exception as e:
+                progress.console.print(f"[red]Errore link Ep. {ep.num}: {e}")
+                return
+
+            headers = provider.Client.headers
+            temp_filename = filename.with_name(f"{filename.name}.temp")
+            connections = max(1, ut.config_data["general"].get("connections-per-download", DEFAULT_CONNECTIONS))
+
+            async def single_stream(client: AsyncClient) -> None:
+                """Scarica l'episodio con un'unica connessione (fallback)."""
+                async with client.stream("GET", url, headers=headers) as response:
+                    response.raise_for_status()
+                    total = int(response.headers.get('content-length', 0))
+                    progress.update(task_id, total=total or None)
+                    with open(temp_filename, "wb") as f:
+                        async for chunk in response.aiter_bytes(CHUNK_SIZE):
+                            if chunk:
+                                progress.update(task_id, advance=f.write(chunk))
+
+            async def download_segment(client: AsyncClient, start: int, end: int) -> None:
+                """Scarica l'intervallo di byte [start, end] e lo scrive alla sua posizione nel file."""
+                seg_headers = {**headers, "Range": f"bytes={start}-{end}"}
+                async with client.stream("GET", url, headers=seg_headers) as response:
+                    if not _valid_partial_response(response, start, end, total):
+                        raise ValueError(
+                            f"Risposta Range non valida per bytes={start}-{end}"
+                        )
+                    with open(temp_filename, "r+b") as f:
+                        f.seek(start)
+                        async for chunk in response.aiter_bytes(CHUNK_SIZE):
+                            if chunk:
+                                progress.update(task_id, advance=f.write(chunk))
+
+            try:
+                async with AsyncClient(timeout=30.0, follow_redirects=True) as client:
+                    total = 0
+                    accept_ranges = False
+                    try:
+                        head = await client.head(url, headers=headers)
+                        head.raise_for_status()
+                        total = int(head.headers.get('content-length', 0))
+                        accept_ranges = head.headers.get('accept-ranges', '').lower() == 'bytes'
+                    except Exception:
+                        pass
+
+                    if connections > 1 and accept_ranges and total > 0:
+                        # Download segmentato: più connessioni in parallelo sullo stesso
+                        # file, per aggirare i limiti di banda per-connessione dei CDN.
+                        progress.update(task_id, total=total)
+                        with open(temp_filename, "wb") as f:
+                            f.truncate(total)
+                        segments = [
+                            download_segment(client, start, end)
+                            for start, end in _segment_ranges(total, connections)
+                        ]
+                        await asyncio.gather(*segments)
+                    else:
+                        # Server senza supporto ai range (o dimensione ignota): fallback.
+                        await single_stream(client)
+
+                temp_filename.rename(filename)
+                progress.update(task_id, description=f"[success]Ep. {ep.num} (Completato)[/]")
+            except Exception as e:
+                progress.console.print(f"[error]Errore download Ep. {ep.num}: {e}[/]")
+
+    async def _download_all():
+        concurrent_downloads = ut.config_data["general"].get("parallel-downloads", 3)
+        semaphore = asyncio.Semaphore(concurrent_downloads)
+        ordered_eps = sorted(episodes, key=lambda e: e.numeric())
+
+        with Progress(
+            TextColumn("[info]{task.description}[/]", style="info"),
+            BarColumn(bar_width=None),
+            "•",
+            DownloadColumn(),
+            "•",
+            TransferSpeedColumn(),
+            console=ut.console,
+        ) as progress:
+            tasks = []
+            for ep in ordered_eps:
+                task_id = progress.add_task(str(ep), total=None, start=True)
+                tasks.append(asyncio.create_task(download_worker(ep, task_id, progress, semaphore)))
+
+            await asyncio.gather(*tasks)
+
+    asyncio.run(_download_all())

aw_cli-2.3.3/tests/core/test_download.py

@@ -0,0 +1,53 @@
+from types import SimpleNamespace
+
+from aw_cli import download
+
+
+def response(status_code: int, content_range: str = ""):
+    return SimpleNamespace(
+        status_code=status_code,
+        headers={"content-range": content_range} if content_range else {},
+    )
+
+
+def test_segment_ranges_cover_file_without_gaps():
+    assert download._segment_ranges(total=10, connections=3) == [
+        (0, 3),
+        (4, 6),
+        (7, 9),
+    ]
+
+
+def test_segment_ranges_do_not_create_empty_ranges():
+    assert download._segment_ranges(total=3, connections=10) == [
+        (0, 0),
+        (1, 1),
+        (2, 2),
+    ]
+
+
+def test_valid_partial_response_accepts_matching_content_range():
+    assert download._valid_partial_response(
+        response(206, "bytes 4-6/10"),
+        start=4,
+        end=6,
+        total=10,
+    )
+
+
+def test_valid_partial_response_rejects_ignored_range():
+    assert not download._valid_partial_response(
+        response(200, "bytes 0-9/10"),
+        start=4,
+        end=6,
+        total=10,
+    )
+
+
+def test_valid_partial_response_rejects_wrong_content_range():
+    assert not download._valid_partial_response(
+        response(206, "bytes 0-6/10"),
+        start=4,
+        end=6,
+        total=10,
+    )

{aw_cli-2.3.2 → aw_cli-2.3.3}/tests/providers/test_animeworld.py

@@ -1,3 +1,4 @@
+import re
 import pytest
 from pathlib import Path
 from unittest.mock import patch, MagicMock
@@ -74,10 +75,13 @@ class TestAnimeworld:
         aw.Client.get.return_value = mock_response
 
         video_url = aw._episode_link(anime, episode)
-        assert (
-            video_url
-            == "https://srv23-abbaia.sweetpixel.org/DDL/ANIME/Naruto/Naruto_Ep_001_SUB_ITA.mp4"
-        )
+        # Il sottodominio del CDN (es. "srv23-masafi") ruota nel tempo e le
+        # fixtures si rigenerano dal vivo: verifichiamo la struttura stabile
+        # dell'URL (dominio + path) senza fissare l'host volatile.
+        assert re.fullmatch(
+            r"https://[\w.-]+\.sweetpixel\.org/DDL/ANIME/Naruto/Naruto_Ep_001_SUB_ITA\.mp4",
+            video_url,
+        ), f"URL video inatteso: {video_url}"
 
 
     def test_animeworld_info_anime(self, aw):

{aw_cli-2.3.2 → aw_cli-2.3.3}/uv.lock

@@ -30,6 +30,7 @@ name = "aw-cli"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },
+    { name = "pip" },
     { name = "pip-system-certs" },
     { name = "pydantic" },
     { name = "regex" },
@@ -47,6 +48,7 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "httpx", specifier = ">=0.28.1" },
+    { name = "pip", specifier = ">=26.2.0" },
     { name = "pip-system-certs", specifier = ">=5.2" },
     { name = "pydantic", specifier = ">=2.12.5" },
     { name = "regex", specifier = ">=2025.9.18" },
@@ -102,7 +104,7 @@ name = "exceptiongroup"
 version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
 wheels = [
@@ -223,11 +225,11 @@ wheels = [
 
 [[package]]
 name = "pip"
-version = "26.1.1"
+version = "26.2.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b6/48/cb9b7a682f6fe01a4221e1728941dd4ac3cd9090a17db3779d6ff490b602/pip-26.1.1.tar.gz", hash = "sha256:d36762751d156a4ee895de8af39aa0abeeeb577f93a2eca6ab62467bbf0f8a78", size = 1840400, upload-time = "2026-05-04T19:02:21.248Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ae/15/4500e320e6b101ec3b719ae85b697d9940b6cda672bc555bd6016fc60c6f/pip-26.2.1.tar.gz", hash = "sha256:f6ad667e89a1fe78046c8f13232b247200f5258d7828f3f7883d660878e0813f", size = 1848877, upload-time = "2026-08-04T22:51:14.148Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3a/eb/fea4d1d51c49832120f7f285d07306db3960f423a2612c6057caf3e8196f/pip-26.1.1-py3-none-any.whl", hash = "sha256:99cb1c2899893b075ff56e4ed0af55669a955b49ad7fb8d8603ecdaf4ed653fb", size = 1812777, upload-time = "2026-05-04T19:02:18.9Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/6e/1736e5b4ae2b778ef2f81c47d797de9f891d4d8acb047a24ca37a60294dd/pip-26.2.1-py3-none-any.whl", hash = "sha256:71138adf1f4ca900cdb7d289c21b7494329f2332b6d85f0e1c42108c0384ed3e", size = 1816632, upload-time = "2026-08-04T22:51:12.472Z" },
 ]
 
 [[package]]

aw_cli-2.3.2/src/aw_cli/download.py

@@ -1,97 +0,0 @@
-import asyncio
-from pathlib import Path
-from httpx import AsyncClient
-from rich.progress import Progress, BarColumn, TextColumn, TaskID, DownloadColumn, TransferSpeedColumn
-from . import utilities as ut
-from .anime import Anime
-from .providers import Provider
-
-from functools import lru_cache
-
-@lru_cache
-def path(create: bool = True) -> Path:
-    """
-    Restituisce il percorso di download dell'anime, a seconda del sistema operativo in uso.
-    Se create è True (valore predefinito) e il percorso non esiste, viene creato.
-
-    Args:
-        create (bool, optional): se impostato a True, crea il percorso se non esiste. Valore predefinito: True.
-
-    Returns:
-        Path: il percorso di download dell'anime.
-    """
-
-    if (ut.os_name == "Android"):
-        path = Path("/sdcard/Movies/Anime")
-    else:
-        path = Path.home() / "Videos/Anime"
-
-    if create:
-        path.mkdir(parents=True, exist_ok=True)
-    return path
-
-def episodes(anime: Anime, episodes: list[Anime.Episode], provider: Provider) -> None:
-    """
-    Scarica più episodi in modo concorrente (max concurrent_downloads).
-
-    Args:
-        anime (Anime): l'anime di cui scaricare gli episodi.
-        episodes (list[Anime.Episode]): la lista degli episodi da scaricare.
-        provider (Provider): il provider da cui scaricare gli episodi.
-    """
-    async def download_worker(ep: Anime.Episode, task_id: TaskID, progress: Progress, sem: asyncio.Semaphore):
-        async with sem:
-            filename = path() / anime.name / f"{ep}.mp4"
-            if filename.exists():
-                progress.update(task_id, completed=100, total=100, description=f"[green]Ep. {ep.num} (Esistente)")
-                return
-
-            filename.parent.mkdir(parents=True, exist_ok=True)
-            try:
-                url = provider.episode_link(anime, ep)
-            except Exception as e:
-                progress.console.print(f"[red]Errore link Ep. {ep.num}: {e}")
-                return
-
-            try:
-                async with AsyncClient() as client:
-                    async with client.stream("GET", url, headers=provider.Client.headers) as response:
-                        total = int(response.headers.get('content-length', 0))
-                        progress.update(task_id, total=total)
-
-                        downloaded = 0
-                        temp_filename = filename.with_name(f"{filename.name}.temp")
-                        with open(temp_filename, "wb") as f:
-                            async for chunk in response.aiter_bytes(1024):
-                                if chunk:
-                                    n = f.write(chunk)
-                                    downloaded += n
-                                    progress.update(task_id, advance=n)
-
-                temp_filename.rename(filename)
-                progress.update(task_id, description=f"[success]Ep. {ep.num} (Completato)[/]")
-            except Exception as e:
-                progress.console.print(f"[error]Errore download Ep. {ep.num}: {e}[/]")
-
-    async def _download_all():
-        concurrent_downloads = ut.config_data["general"].get("parallel-downloads", 3)
-        semaphore = asyncio.Semaphore(concurrent_downloads)
-        ordered_eps = sorted(episodes, key=lambda e: e.numeric())
-
-        with Progress(
-            TextColumn("[info]{task.description}[/]", style="info"),
-            BarColumn(bar_width=None),
-            "•",
-            DownloadColumn(),
-            "•",
-            TransferSpeedColumn(),
-            console=ut.console,
-        ) as progress:
-            tasks = []
-            for ep in ordered_eps:
-                task_id = progress.add_task(str(ep), total=None, start=True)
-                tasks.append(asyncio.create_task(download_worker(ep, task_id, progress, semaphore)))
-
-            await asyncio.gather(*tasks)
-
-    asyncio.run(_download_all())