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

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

@@ -0,0 +1,65 @@
+## 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 → aw_cli-2.3.2}/.gitignore

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

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

@@ -1,7 +1,9 @@
 Metadata-Version: 2.4
 Name: aw-cli
-Version: 2.3
+Version: 2.3.2
 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
@@ -11,7 +13,6 @@ 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 → aw_cli-2.3.2}/pyproject.toml

@@ -12,9 +12,12 @@ dependencies = [
     "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 +34,7 @@ dev = [
     "pyright>=1.1.406",
     "pytest>=8.4.2",
 ]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"

{aw_cli-2.3/src/aw_cli/fzf → aw_cli-2.3.2/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.2/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 → aw_cli-2.3.2}/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":

aw_cli-2.3.2/src/aw_cli/providers/animeworld.py

@@ -0,0 +1,217 @@
+from functools import lru_cache
+import re
+from html import unescape
+from urllib.parse import quote_plus
+from ..anime import Anime, AnimeStatus
+from .provider import Provider, HTTPError
+
+
+class Animeworld(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, client=None):
+        super().__init__("https://www.animeworld.ac", client=client)
+        self._visited = {}
+
+    @lru_cache
+    def _get_html(self, url: str) -> str:
+        """
+        Ottiene l'html della pagina web `url`.
+        Gestisce cookie JavaScript (document.cookie) e imposta il csrf-token se presente.
+        """
+        if not re.match(r"^https?://", url):
+            raise HTTPError("Errore 404: pagina non trovata")
+
+        response = self.Client.get(url)
+
+        # Gestione cookie impostati tramite JavaScript (document.cookie)
+        cookie_match = re.search(
+            r'document\.cookie\s*?=\s*?"([^=]+)=([^";]+)', response.text
+        )
+        if cookie_match:
+            name, value = cookie_match.groups()
+            self.Client.cookies.set(name, value)
+            response = self.Client.get(url)
+
+        response.raise_for_status()
+
+        # Estrai e aggiorna il csrf-token se presente nella pagina per le chiamate API
+        csrf_token_match = re.search(
+            r'<meta.*?id="csrf-token"\s*?content="(.*?)">', response.text
+        )
+        if csrf_token_match:
+            self.Client.headers["csrf-token"] = csrf_token_match.group(1)
+
+        if response.status_code != 200 or "Errore 404" in response.text:
+            raise HTTPError("Errore 404: pagina non trovata")
+
+        return response.text
+
+    def _search(self, input: str) -> list[Anime]:
+        # Assicuriamoci che il client abbia cookies/csrf-token caricando prima la homepage
+        if "csrf-token" not in self.Client.headers:
+            try:
+                self._get_html(self.BASE_URL)
+            except Exception:
+                pass
+
+        response = self.Client.post(
+            f"{self.BASE_URL}/api/search/v2", params={"keyword": input}
+        )
+        response.raise_for_status()
+
+        data = response.json()
+        if "error" in data or "animes" not in data:
+            return []
+
+        animes = []
+        for elem in data["animes"]:
+            link = elem.get("link")
+            identifier = elem.get("identifier")
+            if link and identifier:
+                url = f"{self.BASE_URL}/play/{link}.{identifier}"
+            else:
+                url = self.BASE_URL
+
+            name = elem.get("name", "")
+            anime = Anime(unescape(name), url)
+
+            # Pre-populate all metadata from search JSON using a clean helper
+            anilist_id, status, info = self._parse_info(elem)
+            anime.set_info(anilist_id, status, info)
+            animes.append(anime)
+        return animes
+
+    def _latest(self, filter: str, specials: bool) -> list[Anime]:
+        html = self._get_html(self.BASE_URL)
+        animes = list[Anime]()
+
+        # Trova tutti i tag <a> con classe "poster" per estrarre in modo robusto
+        for a_tag in re.findall(r'<a\s+[^>]*class="poster"[^>]*>', html):
+            href_match = re.search(r'href="([^"]+)"', a_tag)
+            title_match = re.search(r'title="([^"]+)"', a_tag)
+            if not href_match or not title_match:
+                continue
+
+            url = href_match.group(1)
+            title = title_match.group(1)
+
+            # Estrae l'episodio dal titolo (es: "Nome Anime Ep 9")
+            ep = "0"
+            ep_match = re.search(r' Ep[\.\s]+([^"]+)$', title)
+            if ep_match:
+                ep = ep_match.group(1).strip()
+                name = title[: ep_match.start()].strip()
+            else:
+                name = title
+
+            parts = url.strip("/").split("/")
+            if len(parts) >= 3:
+                anime_slug = parts[1]
+                player_id = parts[2]
+                anime_ref = f"{self.BASE_URL}/play/{anime_slug}"
+                ep_ref = player_id
+            else:
+                anime_ref = self.BASE_URL + url
+                ep_ref = self.BASE_URL + url
+
+            anime = Anime(unescape(name), anime_ref, ep)
+            anime.update_episodes({ep: ep_ref}, specials=specials)
+            animes.append(anime)
+
+        BLOCK_SIZE = 45
+        filter_keys = ["a", "s", "d", "t"]
+        multiplier = filter_keys.index(filter[0])
+
+        start = multiplier * BLOCK_SIZE
+        end = (multiplier + 1) * BLOCK_SIZE if multiplier < len(filter_keys) else None
+
+        return animes[start:end]
+
+    def _episodes(self, anime: Anime):
+        html = self._get_html(anime.ref)
+        episodes_url = dict[str, str]()
+
+        # Estrae i tag <a> in modo super stabile limitandosi agli elementi con classe "episode"
+        for a_tag in re.findall(r'<li class="episode">[\s\n]*(<a\s+[^>]+>)', html):
+            id_match = re.search(r'data-id="([^"]+)"', a_tag)
+            num_match = re.search(r'data-num="([^"]+)"', a_tag)
+            if id_match and num_match:
+                episodes_url[num_match.group(1)] = id_match.group(1)
+        return episodes_url
+
+    def _episode_link(self, anime: Anime, episode: Anime.Episode) -> str:
+        player_id = episode.ref
+        if "play/" in player_id:
+            player_id = player_id.split("/")[-1]
+
+        api_url = f"{self.BASE_URL}/api/episode/serverPlayerAnimeWorld?id={player_id}"
+        response = self.Client.get(api_url)
+        response.raise_for_status()
+
+        source_match = re.search(r'<source src="([^"]+)"', response.text)
+        if not source_match:
+            raise ValueError("Errore nel parsing della pagina dell'episodio")
+        return source_match.group(1)
+
+    def _info_anime(self, anime: Anime):
+        html = self._get_html(anime.ref)
+
+        res = re.search(r'<a.*id="anilist-button".*href="\D*(\d*)"', html)
+        anilist_id = int(res.group(1)) if res else 0
+
+        temp = re.findall(
+            r'<dt>(.*?):</dt>[\n\s]*<dd(?: class="[^"]*")?>((?:.|\n)+?)</dd>', html
+        )
+        plot_match = re.search(r'<div class="desc">((?:.|\n)+?)</div>', html)
+        if plot_match:
+            temp.append(("Trama", plot_match.group(1)))
+
+        info = dict[str, str]()
+        status = AnimeStatus.UNKNOWN
+        for key, value in temp:
+            key, value = key.strip(), value.strip()
+            if key == "Stato":
+                if match := re.search(r'status=(\d+)"', value):
+                    status_val = int(match.group(1))
+                    if status_val < len(AnimeStatus):
+                        status = list(AnimeStatus)[status_val]
+            value = re.sub(r"[\s\n]+", " ", re.sub(r"<.*?>", "", value)).strip()
+            info[key] = unescape(value)
+
+        anime.set_info(anilist_id, status, info)
+
+    def _parse_info(self, elem: dict) -> tuple[int, AnimeStatus, dict[str, str]]:
+        """Estrae e mappa i metadati ritornati dal JSON dell'API di ricerca di AnimeWorld."""
+        anilist_id = elem.get("anilistId", 0)
+        state_val = elem.get("stateName", "Sconosciuto")
+        status = AnimeStatus.UNKNOWN
+        if state_val == "Finito":
+            status = AnimeStatus.FINISHED
+        elif state_val == "In corso":
+            status = AnimeStatus.ONGOING
+        elif state_val == "Non rilasciato":
+            status = AnimeStatus.NOT_RELEASED
+
+        info = {
+            "Categoria": "Anime" if elem.get("animeType") == "0" else "Movie",
+            "Audio": "Italiano" if elem.get("dub") == "1" else "Giapponese",
+            "Data di Uscita": elem.get("release") or elem.get("year", ""),
+            "Studio": elem.get("studio", ""),
+            "Genere": ", ".join(
+                cat.get("name", "") for cat in elem.get("categories", [])
+            ),
+            "Voto": f"{elem.get('malVote')}" if elem.get("malVote") else "Sconosciuto",
+            "Episodi": f"{elem.get('episodes', '0')}",
+            "Stato": state_val,
+            "Trama": elem.get("story", ""),
+        }
+        return int(anilist_id) if anilist_id else 0, status, info

{aw_cli-2.3 → aw_cli-2.3.2}/src/aw_cli/providers/local.py

@@ -12,7 +12,7 @@ class LocalProvider(Provider):
     - info_anime: carica info dalla cronologia
     """
     def __init__(self, path, history: list[Anime]):
-        super().__init__(path)
+        self.BASE_URL = path
         self.history = history
 
     def _search(self, input: str) -> list[Anime]:

{aw_cli-2.3 → aw_cli-2.3.2}/src/aw_cli/providers/provider.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
-from httpx import Client, HTTPError #, AsyncClient
+from curses import error
+from httpx import Client, HTTPError  # , AsyncClient
 from ..anime import Anime
 from .. import utilities as ut
 
@@ -8,6 +9,7 @@ def error_handler(relink=False):
     """
     Decoratore per gestire gli errori delle funzioni.
     """
+
     def decorator(func):
         def wrapper(self, *args, **kwargs):
             try:
@@ -15,11 +17,17 @@ def error_handler(relink=False):
             except Exception as e:
                 if relink and isinstance(e, HTTPError):
                     return update_link(self, func, *args, **kwargs)
-                ut.console.print(f"Errore {e.__class__.__name__} durante {func.__name__}: {e}", style="error")
-                return None
+                ut.console.print(
+                    f"Errore {e.__class__.__name__} durante {func.__name__}: {e}",
+                    style="error",
+                )
+                exit(1)
+
         return wrapper
+
     return decorator
 
+
 def update_link(self, callback, anime: Anime, episode: Anime.Episode | None = None):
     """
     Gestisce il caso in cui il riferimento dell'anime o all'episodio non è più valido
@@ -30,9 +38,11 @@ def update_link(self, callback, anime: Anime, episode: Anime.Episode | None = No
         return callback(self, anime, anime.episode(episode.num))
     else:
         ut.console.print("Il link dell'anime è stato cambiato", style="warning")
-        res: list[Anime] = self.search(anime.name)
-        if len(res) == 0:
-            raise LookupError(f"Nessun risultato trovato per {anime.name} su {self.__class__.__name__}")
+        res: list[Anime] | None = self.search(anime.name)
+        if not res:
+            ut.console.print(f"Errore o nessun risultato durante la ricerca di {anime.name} su {self.__class__.__name__}", style="error")
+            ut.console.print("Cercarlo manualmente", style="highlight")
+            exit(1)
         anime.ref = res[0].ref
         return callback(self, anime)
 
@@ -45,20 +55,23 @@ class Provider(ABC):
         _url (str): l'url del sito del provider.
         _headers (dict): gli headers da utilizzare per le richieste HTTP.
     """
-    def __init__(self, url: str):
+
+    def __init__(self, url: str, client: Client | None = None):
         """
         Costruisce un'instanza di Provider.
 
         Args:
             url (str): l'url del sito del provider.
+            client (Client | None): client HTTP opzionale da iniettare (utile per testing).
         """
         self.BASE_URL = url
-        self.Client = Client(
+        self.Client = client or Client(
             headers={
-                'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36'
+                "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36",
+                "Connection": "close"
             },
             follow_redirects=True,
-            timeout=10
+            timeout=10,
         )
 
     @error_handler(relink=False)
@@ -131,8 +144,7 @@ class Provider(ABC):
             anime (Anime): l'anime di riferimento.
         """
         anime.update_episodes(
-            self._episodes(anime),
-            ut.config_data["general"]["specials"]
+            self._episodes(anime), ut.config_data["general"]["specials"]
         )
 
     @abstractmethod