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

aw_cli-2.3.3/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,73 @@
+---
+name: Bug report
+about: Segnala un problema con aw-cli
+title: "[Bug]: "
+labels: bug
+assignees: ""
+---
+
+## Descrizione del problema
+
+Descrivi chiaramente il problema riscontrato.
+
+## Passi per riprodurre
+
+Esempio:
+
+1. Esegui `aw-cli ...`
+2. Seleziona ...
+3. Il problema si verifica quando ...
+
+## Informazioni sull'ambiente
+
+### Versione di aw-cli
+
+Esegui:
+
+```bash
+aw-cli -v
+```
+
+Output:
+
+```text
+...
+```
+
+### Sistema operativo
+
+Esempio: Fedora 40, Ubuntu 24.04, Arch Linux, macOS, Android, Windows WSL, ecc.
+
+```text
+...
+```
+
+### Metodo di installazione
+
+- [ ] `uv`
+- [ ] `pipx`
+- [ ] `pip`
+- [ ] Installazione manuale / da sorgente
+- [ ] Altro (specifica qui)
+
+### Provider
+
+- [ ] AnimeWorld
+- [ ] AnimeUnity
+
+### Player
+
+- [ ] mpv
+- [ ] vlc
+
+## Log / output del terminale
+
+Incolla qui l'output completo dell'errore, se presente.
+
+```
+...
+```
+
+## Informazioni aggiuntive
+
+Aggiungi qualsiasi altro dettaglio utile, screenshot o contesto.

{aw_cli-2.3.1 → aw_cli-2.3.3}/.gitignore

@@ -88,3 +88,6 @@ pyrightconfig.json
 history.json
 config.toml
 aw-cronologia.csv
+
+# Fixtures for tests
+tests/fixtures/

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

@@ -1,17 +1,19 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: aw-cli
-Version: 2.3.1
+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
 License-Expression: GPL-3.0
 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
 Requires-Dist: toml>=0.10.2
-Requires-Dist: wheel>=0.45.1
 Description-Content-Type: text/markdown
 
 # aw-cli

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

@@ -7,14 +7,18 @@ 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",
     "rich>=13.9.4",
     "toml>=0.10.2",
-    "wheel>=0.45.1",
 ]
 
+[project.urls]
+Homepage = "https://github.com/fexh10/aw-cli"
+Repository = "https://github.com/fexh10/aw-cli"
+
 [project.scripts]
 aw-cli = "aw_cli.run:main"
 
@@ -31,3 +35,7 @@ dev = [
     "pyright>=1.1.406",
     "pytest>=8.4.2",
 ]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"

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.1/src/aw_cli/fzf → aw_cli-2.3.3/src/aw_cli/interface}/fzf.py

@@ -1,11 +1,11 @@
 import subprocess
 import sys
 import re
+import socket
+import json
 import argparse
 import urllib.request
 
-import aw_cli.utilities as ut
-
 
 class Fzf:
     """
@@ -20,7 +20,7 @@ class Fzf:
     }
 
     def __init__(self):
-        self._port: int = ut.config_data.get("fzf", {}).get("port", 4321)
+        self._port: int = 0
 
     def run(
         self,
@@ -38,7 +38,10 @@ class Fzf:
             multi:    se True abilita la selezione multipla (Ctrl+A = toggle all).
             filter:   se True abilita il filtro per range (formato: inizio-fine).
         """
-        cmd = self._build_cmd(elements=elements, prompt=prompt, multi=multi, filter=filter)
+        self._port = self._find_free_port()
+        cmd = self._build_cmd(
+            elements=elements, prompt=prompt, multi=multi, filter=filter
+        )
 
         try:
             while True:
@@ -82,6 +85,16 @@ class Fzf:
         except OSError:
             pass
 
+    @staticmethod
+    def _find_free_port() -> int:
+        """
+        Restituisce una porta TCP libera assegnata dal sistema operativo.
+        Usare questa porta per --listen evita conflitti e TIME_WAIT tra riavvii di fzf.
+        """
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("", 0))
+            return s.getsockname()[1]
+
     def _build_cmd(
         self,
         elements: list[str],
@@ -109,11 +122,12 @@ class Fzf:
             cmd += ["--multi", "--bind", "ctrl-a:toggle-all"]
 
         if filter:
-            reload_cmd = f"{sys.executable} -m aw_cli.fzf.fzf --filter {{q}} --episodes \"{elements}\""
+            reload_cmd = f"{sys.executable} -m aw_cli.interface.fzf --filter {{q}} --episodes '{json.dumps(elements)}'"
             cmd += [
                 "--phony",
-                "--bind", f"change:reload({reload_cmd})",
-                "--header=Range: inizio-fine. crtl+A seleziona tutto, tab/shift+tab selezione singola"
+                "--bind",
+                f"change:reload({reload_cmd})",
+                "--header=Range: inizio-fine. crtl+A seleziona tutto, tab/shift+tab selezione singola",
             ]
 
         return cmd
@@ -132,7 +146,10 @@ def _filter_episodes(query: str, episodes_raw: str) -> None:
     ha successo se i due intervalli si intersecano.
     """
 
-    episodes: list[str] = eval(episodes_raw)
+    try:
+        episodes: list[str] = json.loads(episodes_raw)
+    except (json.JSONDecodeError, ValueError):
+        return
 
     if not query:
         print("\n".join(episodes))
@@ -185,8 +202,12 @@ def _filter_episodes(query: str, episodes_raw: str) -> None:
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
-    parser.add_argument("--filter", type=str, default="", help="Query per filtrare gli episodi")
-    parser.add_argument("--episodes", type=str, required=True, help="Lista episodi JSON")
+    parser.add_argument(
+        "--filter", type=str, default="", help="Query per filtrare gli episodi"
+    )
+    parser.add_argument(
+        "--episodes", type=str, required=True, help="Lista episodi JSON"
+    )
     args = parser.parse_args()
 
     _filter_episodes(args.filter, args.episodes)

aw_cli-2.3.3/src/aw_cli/providers/__init__.py

@@ -0,0 +1,36 @@
+# pyright: reportUnusedImport=false
+from .provider import Provider
+
+PROVIDERS_AVAILABLE = {
+    "animeunity": ("aw_cli.providers.animeunity", "Animeunity"),
+    "animeworld": ("aw_cli.providers.animeworld", "Animeworld"),
+    # "animeworld-api": ("aw_cli.providers.animeworld_api", "AnimeWorldAPI"),
+}
+
+def create_provider(name: str) -> Provider:
+    """
+    Crea un'istanza del provider in base al nome.
+    Usa importazione lazy per caricare solo il modulo necessario.
+
+    Args:
+        name (str): il nome del provider (es. 'animeunity', 'animeworld').
+
+    Returns:
+        Provider: l'istanza del provider creato.
+
+    Raises:
+        ValueError: se il nome del provider non è disponibile.
+    """
+    if name not in PROVIDERS_AVAILABLE:
+        raise ValueError(f"Provider '{name}' non disponibile. Scegli tra: {list(PROVIDERS_AVAILABLE.keys())}")
+
+    module_name, class_name = PROVIDERS_AVAILABLE[name]
+    import importlib
+    module = importlib.import_module(module_name)
+    provider_class = getattr(module, class_name)
+    return provider_class()
+
+__all__ = [
+    "Provider",
+    "create_provider",
+]

{aw_cli-2.3.1 → aw_cli-2.3.3}/src/aw_cli/providers/animeunity.py

@@ -1,38 +1,38 @@
 import re
 import json
 from html import unescape
+from functools import cached_property
 from ..anime import Anime, AnimeStatus
 from .provider import Provider, HTTPError
 
 class Animeunity(Provider):
     """
     Classe che gestisce il collegamento con Animeworld.
-    
+
     Attributes:
         _url (str): l'url del sito di Animeworld.
         _headers (dict): gli headers da utilizzare per le richieste HTTP.
         _cookies (dict): i cookies da utilizzare per le richieste HTTP.
         _visited (dict): le pagine già visitate.
     """
-    def __init__(self):
-        super().__init__("https://www.animeunity.so")
-        self._get_token()  # Assicura che i token/cookie siano aggiornati
+    def __init__(self, client=None):
+        super().__init__("https://www.animeunity.so", client=client)
 
-    
-    def _get_token(self) -> None:
-        # Send a GET request to the specified URL
+    @cached_property
+    def _session(self) -> str:
+        """Inizializza la sessione (token CSRF + cookies) al primo accesso. Ritorna l'HTML."""
         response = self.Client.get(self.BASE_URL)
-        self.html = response.text
-        # Regex to find the meta tag with csrf-token and extract the content
-        csrf_match = re.search(r'<meta.*?name="csrf-token".*?content="([^"]*)".*?>', self.html)
+        html = response.text
+        csrf_match = re.search(r'<meta.*?name="csrf-token".*?content="([^"]*)".*?>', html)
         if not csrf_match:
             raise ValueError("CSRF token not found in the HTML")
-        csrf_token = csrf_match.group(1)
-        self.Client.headers['x-csrf-token'] = csrf_token
+        self.Client.headers['x-csrf-token'] = csrf_match.group(1)
         self.Client.cookies['animeunity_session'] = response.cookies.get('animeunity_session') or ""
+        return html
 
 
     def _search(self, input: str) -> list[Anime]:
+        _ = self._session  # trigger lazy init
         search_url = f"{self.BASE_URL}/livesearch"
         response = self.Client.post(
             url=search_url,
@@ -52,7 +52,7 @@ class Animeunity(Provider):
 
 
     def _latest(self, filter, specials) -> list[Anime]:
-        regex = re.search(r'<layout-items[^>]*items-json="([^"]*)"', self.html)
+        regex = re.search(r'<layout-items[^>]*items-json="([^"]*)"', self._session)
         if not regex:
             raise ValueError("Errore nel parsing della pagina principale")
 
@@ -131,7 +131,7 @@ class Animeunity(Provider):
 
     def _parse_info(self, data: dict) -> tuple[str, str, int, AnimeStatus, dict[str, str]]:
         title = data['title_eng'] or data['title'] or data['title_it']
-        last_ep = str(data['real_episodes_count']) if 'real_episodes_count' in data else "0" 
+        last_ep = str(data['real_episodes_count']) if 'real_episodes_count' in data else "0"
         anilist_id = data['anilist_id']
         match data['status']:
             case "In Corso":