weeb-cli 0.1.2__tar.gz → 0.1.3__tar.gz

{weeb_cli-0.1.2/weeb_cli.egg-info → weeb_cli-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weeb-cli
-Version: 0.1.2
+Version: 0.1.3
 Summary: Tarayıcı yok, reklam yok, dikkat dağıtıcı unsur yok. Sadece siz ve eşsiz bir anime izleme deneyimi.
 Author-email: ewgsta <ewgst@proton.me>
 License-Expression: CC-BY-NC-ND-4.0

{weeb_cli-0.1.2 → weeb_cli-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weeb-cli"
-version = "0.1.2"
+version = "0.1.3"
 description = "Tarayıcı yok, reklam yok, dikkat dağıtıcı unsur yok. Sadece siz ve eşsiz bir anime izleme deneyimi."
 readme = "README.md"
 authors = [{ name = "ewgsta", email = "ewgst@proton.me" }]
@@ -23,8 +23,12 @@ dependencies = [
     "requests"
 ]
 
-[tool.setuptools]
-packages = ["weeb_cli"]
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["weeb_cli*"]
+
+[tool.setuptools.package-data]
+weeb_cli = ["locales/*.json"]
 
 [project.urls]
 Homepage = "https://github.com/ewgsta/weeb-cli"

weeb_cli-0.1.3/weeb_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.3"

weeb_cli-0.1.3/weeb_cli/commands/downloads.py

@@ -0,0 +1,70 @@
+from rich.console import Console
+from rich.live import Live
+from rich.table import Table
+from rich.progress import ProgressBar, BarColumn
+from weeb_cli.services.downloader import queue_manager
+from weeb_cli.i18n import i18n
+import time
+
+console = Console()
+
+def show_downloads():
+    console.clear()
+    console.print(f"[bold cyan]{i18n.get('details.download')}[/bold cyan] ([dim]Ctrl+C to exit[/dim])\n")
+    
+    def generate_table():
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Anime", width=30)
+        table.add_column("Ep", justify="right", width=5)
+        table.add_column("Status", width=15)
+        table.add_column("Progress", width=20)
+        table.add_column("ETA", width=10)
+        
+        queue = queue_manager.queue
+        
+        active = [i for i in queue if i["status"] == "processing"]
+        pending = [i for i in queue if i["status"] == "pending"]
+        finished = [i for i in queue if i["status"] in ["completed", "failed"]]
+        finished = finished[-5:] 
+        
+        display_list = active + pending + finished
+        
+        if not display_list:
+            table.add_row("-", "-", "Empty", "-", "-")
+            return table
+
+        for item in display_list:
+            status = item["status"]
+            style = "white"
+            if status == "processing":
+                style = "cyan"
+            elif status == "completed":
+                style = "green"
+            elif status == "failed":
+                style = "red"
+            elif status == "pending":
+                style = "dim"
+                
+            progress = item.get("progress", 0)
+            bars = int(progress / 5)
+            bar_str = "█" * bars + "░" * (20 - bars)
+            
+            p_text = f"{progress}%" if status == "processing" else ""
+            
+            table.add_row(
+                f"[{style}]{item['anime_title'][:28]}[/{style}]",
+                f"{item['episode_number']}",
+                f"[{style}]{status.upper()}[/{style}]",
+                f"[{style}]{bar_str} {p_text}[/{style}]",
+                f"{item.get('eta', '-')}"
+            )
+            
+        return table
+
+    try:
+        with Live(generate_table(), refresh_per_second=1) as live:
+            while True:
+                live.update(generate_table())
+                time.sleep(1)
+    except KeyboardInterrupt:
+        return

weeb_cli-0.1.3/weeb_cli/commands/search.py

@@ -0,0 +1,345 @@
+import questionary
+from rich.console import Console
+from weeb_cli.i18n import i18n
+from weeb_cli.ui.header import show_header
+from weeb_cli.services.search import search
+from weeb_cli.services.details import get_details
+from weeb_cli.services.watch import get_streams
+from weeb_cli.services.player import player
+from weeb_cli.services.progress import progress_tracker
+from weeb_cli.services.downloader import queue_manager
+import time
+
+console = Console()
+
+def search_anime():
+    while True:
+        console.clear()
+        show_header(i18n.get("menu.options.search"), show_source=True)
+        
+        try:
+            query = questionary.text(
+                i18n.get("search.prompt") + ":",
+                qmark=">",
+                style=questionary.Style([
+                    ('qmark', 'fg:cyan bold'),
+                    ('question', 'fg:white'),
+                    ('answer', 'fg:cyan bold'), 
+                ])
+            ).ask()
+            
+            if query is None: 
+                return
+            
+            if not query.strip():
+                continue
+
+            with console.status(i18n.get("search.searching"), spinner="dots"):
+                data = search(query)
+            
+            if data is None:
+                time.sleep(1)
+                continue
+
+            if isinstance(data, dict):
+                if "results" in data and isinstance(data["results"], list):
+                    data = data["results"]
+                elif "data" in data:
+                    inner = data["data"]
+                    if isinstance(inner, list):
+                        data = inner
+                    elif isinstance(inner, dict):
+                        if "results" in inner and isinstance(inner["results"], list):
+                            data = inner["results"]
+                        elif "animes" in inner and isinstance(inner["animes"], list):
+                            data = inner["animes"]
+                        elif "items" in inner and isinstance(inner["items"], list):
+                            data = inner["items"]
+            
+            if not data or not isinstance(data, list):
+                console.print(f"[red]{i18n.get('search.no_results')}[/red]")
+                time.sleep(1.5)
+                continue
+
+            choices = []
+            for item in data:
+                 title = item.get("title") or item.get("name")
+                 if title:
+                     choices.append(questionary.Choice(title, value=item))
+            
+            if not choices:
+                console.print(f"[red]{i18n.get('search.no_results')}[/red]")
+                time.sleep(1.5)
+                continue
+
+
+
+            selected = questionary.select(
+                i18n.get("search.results"),
+                choices=choices,
+                pointer=">",
+                use_shortcuts=False,
+                style=questionary.Style([
+                    ('pointer', 'fg:cyan bold'),
+                    ('highlighted', 'fg:cyan'),
+                    ('selected', 'fg:cyan bold'),
+                ])
+            ).ask()
+
+            if selected == "cancel" or selected is None:
+                continue
+            
+            show_anime_details(selected)
+            
+        except KeyboardInterrupt:
+            return
+
+from weeb_cli.services.details import get_details
+
+def show_anime_details(anime):
+    slug = anime.get("slug") or anime.get("id")
+    if not slug:
+        console.print(f"[red]{i18n.get('details.error_slug')}[/red]")
+        time.sleep(1)
+        return
+
+    while True:
+        console.clear()
+        show_header(anime.get("title") or anime.get("name") or "Anime")
+        
+        with console.status(i18n.get("common.processing"), spinner="dots"):
+            details = get_details(slug)
+        
+        # Parse response structure: { data: { details: { ... } } }
+        if isinstance(details, dict):
+            if "data" in details and isinstance(details["data"], dict):
+                details = details["data"]
+            
+            # Capture source
+            source = details.get("source")
+            
+            if "details" in details and isinstance(details["details"], dict):
+                details = details["details"]
+                # Restore source if captured
+                if source:
+                    details["source"] = source
+
+        if not details:
+            console.print(f"[red]{i18n.get('details.not_found')}[/red]")
+            time.sleep(1)
+            return
+        
+        desc = details.get("description") or details.get("synopsis") or details.get("desc")
+        if desc:
+            console.print(f"\n[dim]{desc[:300]}...[/dim]\n", justify="left")
+
+        opt_watch = i18n.get("details.watch")
+        opt_dl = i18n.get("details.download")
+        
+        try:
+            action = questionary.select(
+                i18n.get("details.action_prompt"),
+                choices=[opt_watch, opt_dl],
+                pointer=">",
+                use_shortcuts=False
+            ).ask()
+            
+            if action is None:
+                return
+            
+            if action == opt_dl:
+                handle_download_flow(slug, details)
+            elif action == opt_watch:
+                handle_watch_flow(slug, details)
+                
+        except KeyboardInterrupt:
+            return
+
+def get_episodes_safe(details):
+    episodes = None
+    for k in ["episodes", "episodes_list", "episode_list", "results", "chapters"]:
+        if k in details and isinstance(details[k], list):
+            episodes = details[k]
+            break
+            
+    if not episodes:
+        for v in details.values():
+            if isinstance(v, list) and v and isinstance(v[0], dict) and ("number" in v[0] or "ep_num" in v[0] or "url" in v[0]):
+                episodes = v
+                break
+    return episodes
+
+def handle_watch_flow(slug, details):
+    episodes = get_episodes_safe(details)
+    if not episodes:
+        console.print(f"[yellow]{i18n.get('details.no_episodes')}[/yellow]")
+        time.sleep(1.5)
+        return
+
+    prog_data = progress_tracker.get_anime_progress(slug)
+    completed_ids = set(prog_data.get("completed", []))
+    last_watched = prog_data.get("last_watched", 0)
+    next_ep_num = last_watched + 1
+
+    while True:
+        ep_choices = []
+        for ep in episodes:
+            num_val = ep.get('number') or ep.get('ep_num')
+            try:
+                num = int(num_val)
+            except:
+                num = -1
+            
+            prefix = "   "
+            if num in completed_ids:
+                prefix = "✓  "
+            elif num == next_ep_num:
+                prefix = "●  "
+            
+            name = f"{prefix}{i18n.get('details.episode')} {num_val}"
+            ep_choices.append(questionary.Choice(name, value=ep))
+
+        try:
+            selected_ep = questionary.select(
+                i18n.get("details.select_episode") + ":",
+                choices=ep_choices,
+                pointer=">",
+                use_shortcuts=False
+            ).ask()
+            
+            if selected_ep is None:
+                return
+
+            ep_id = selected_ep.get("id")
+            ep_num = selected_ep.get("number")
+            
+            if not ep_id:
+                console.print(f"[red]{i18n.get('details.invalid_ep_id')}[/red]")
+                time.sleep(1)
+                continue
+
+            with console.status(i18n.get("common.processing"), spinner="dots"):
+                stream_resp = get_streams(slug, ep_id)
+            stream_url = None
+            if stream_resp and isinstance(stream_resp, dict):
+                 data_node = stream_resp
+                 for _ in range(3):
+                     if "data" in data_node and isinstance(data_node["data"], (dict, list)):
+                         data_node = data_node["data"]
+                     else:
+                         break
+                 
+                 sources = None
+                 if isinstance(data_node, list):
+                     sources = data_node
+                 elif isinstance(data_node, dict):
+                     sources = data_node.get("links") or data_node.get("sources")
+                 
+                 if sources and isinstance(sources, list):
+                     first = sources[0]
+                     if isinstance(first, dict):
+                        stream_url = first.get("url")
+                 elif isinstance(data_node, dict) and "url" in data_node:
+                     stream_url = data_node["url"]
+            
+            if not stream_url:
+                console.print(f"[red]{i18n.get('details.stream_not_found')}[/red]")
+                time.sleep(1.5)
+                continue
+            
+            console.print(f"[green]{i18n.get('details.player_starting')}[/green]")
+            title = f"{details.get('title', 'Anime')} - Ep {ep_num}"
+            
+            headers = {}
+            if details.get("source") == "hianime":
+                headers["Referer"] = "https://hianime.to"
+            
+            success = player.play(stream_url, title=title, headers=headers)
+            
+            if success:
+                try:
+                    ans = questionary.confirm(i18n.get("details.mark_watched")).ask()
+                    if ans:
+                        n = int(ep_num)
+                        progress_tracker.mark_watched(slug, n)
+                        
+                        completed_ids.add(n)
+                        if n >= next_ep_num:
+                            next_ep_num = n + 1
+                except:
+                    pass
+            
+        except KeyboardInterrupt:
+            return
+
+def handle_download_flow(slug, details):
+    episodes = get_episodes_safe(details)
+    if not episodes:
+        console.print(f"[yellow]{i18n.get('details.no_episodes')}[/yellow]")
+        time.sleep(1.5)
+        return
+
+    opt_all = i18n.get("details.download_options.all")
+    opt_manual = i18n.get("details.download_options.manual")
+    opt_range = i18n.get("details.download_options.range")
+
+    try:
+        mode = questionary.select(
+            i18n.get("details.download_options.prompt"),
+            choices=[opt_all, opt_manual, opt_range],
+            pointer=">",
+            use_shortcuts=False
+        ).ask()
+        
+        if mode is None:
+            return
+            
+        selected_eps = []
+        
+        if mode == opt_all:
+            selected_eps = episodes
+            
+        elif mode == opt_manual:
+             choices = []
+             for ep in episodes:
+                 name = f"{i18n.get('details.episode')} {ep.get('number')}"
+                 choices.append(questionary.Choice(name, value=ep))
+                 
+             selected_eps = questionary.checkbox(
+                 "Select Episodes:",
+                 choices=choices
+             ).ask()
+             
+        elif mode == opt_range:
+             r_str = questionary.text(i18n.get("details.download_options.range_input")).ask()
+             if not r_str: return
+             nums = set()
+             try:
+                 parts = r_str.split(',')
+                 for p in parts:
+                     p = p.strip()
+                     if '-' in p:
+                         s, e = p.split('-')
+                         for x in range(int(s), int(e)+1): nums.add(x)
+                     elif p.isdigit():
+                         nums.add(int(p))
+             except:
+                 console.print(f"[red]{i18n.get('details.download_options.range_error')}[/red]")
+                 time.sleep(1)
+                 return
+             
+             selected_eps = [ep for ep in episodes if int(ep.get('number', -1)) in nums]
+
+        if not selected_eps:
+             return
+             
+        console.print(f"[green]{i18n.get('details.download_options.started')}[/green]")
+        console.print(f"[dim]{i18n.t('details.queueing', count=len(selected_eps))}[/dim]")
+        
+        anime_title = details.get("title") or "Unknown Anime"
+        queue_manager.add_to_queue(anime_title, selected_eps, slug)
+        
+        time.sleep(1.5)
+        
+    except KeyboardInterrupt:
+        return

weeb_cli-0.1.3/weeb_cli/commands/settings.py

@@ -0,0 +1,238 @@
+import questionary
+from rich.console import Console
+from weeb_cli.i18n import i18n
+from weeb_cli.config import config
+import time
+from weeb_cli.ui.header import show_header
+import os
+from weeb_cli.services.dependency_manager import dependency_manager
+
+console = Console()
+
+
+def toggle_config(key, name):
+    current = config.get(key)
+    new_val = not current
+    
+    if new_val:
+        dep_name = name.lower()
+        if "aria2" in dep_name: dep_name = "aria2"
+        elif "yt-dlp" in dep_name: dep_name = "yt-dlp"
+        
+        path = dependency_manager.check_dependency(dep_name)
+        if not path:
+             console.print(f"[cyan]{i18n.t('setup.downloading', tool=name)}...[/cyan]")
+             if not dependency_manager.install_dependency(dep_name):
+                 console.print(f"[red]{i18n.t('setup.failed', tool=name)}[/red]")
+                 time.sleep(1)
+                 return
+
+    config.set(key, new_val)
+    
+    msg_key = "settings.toggle_on" if new_val else "settings.toggle_off"
+    console.print(f"[green]{i18n.t(msg_key, tool=name)}[/green]")
+    time.sleep(0.5)
+
+def open_settings():
+    while True:
+        console.clear()
+        show_header(i18n.get("settings.title"))
+        
+        lang = config.get("language")
+        source = config.get("scraping_source", "local")
+        display_source = "weeb" if source == "local" else source
+
+        aria2_state = i18n.get("common.enabled") if config.get("aria2_enabled") else i18n.get("common.disabled")
+        ytdlp_state = i18n.get("common.enabled") if config.get("ytdlp_enabled") else i18n.get("common.disabled")
+        
+        opt_lang = i18n.get("settings.language")
+        opt_source = f"{i18n.get('settings.source')} [{display_source}]"
+        opt_download = i18n.get("settings.download_settings")
+        opt_aria2 = f"{i18n.get('settings.aria2')} [{aria2_state}]"
+        opt_ytdlp = f"{i18n.get('settings.ytdlp')} [{ytdlp_state}]"
+        
+        opt_aria2_conf = f"  ↳ {i18n.get('settings.aria2_config')}"
+        opt_ytdlp_conf = f"  ↳ {i18n.get('settings.ytdlp_config')}"
+        
+        choices = [opt_lang, opt_source, opt_download, opt_aria2]
+        if config.get("aria2_enabled"):
+            choices.append(opt_aria2_conf)
+            
+        choices.append(opt_ytdlp)
+        if config.get("ytdlp_enabled"):
+            choices.append(opt_ytdlp_conf)
+        
+        try:
+            answer = questionary.select(
+                i18n.get("settings.title"),
+                choices=choices,
+                pointer=">",
+                use_shortcuts=False,
+                style=questionary.Style([
+                    ('pointer', 'fg:cyan bold'),
+                    ('highlighted', 'fg:cyan'),
+                    ('selected', 'fg:cyan bold'),
+                ])
+            ).ask()
+        except KeyboardInterrupt:
+            return
+
+        if answer == opt_lang:
+            change_language()
+        elif answer == opt_source:
+            change_source()
+        elif answer == opt_download:
+            download_settings_menu()
+        elif answer == opt_aria2:
+            toggle_config("aria2_enabled", "Aria2")
+        elif answer == opt_aria2_conf:
+            aria2_settings_menu()
+        elif answer == opt_ytdlp:
+            toggle_config("ytdlp_enabled", "yt-dlp")
+        elif answer == opt_ytdlp_conf:
+            ytdlp_settings_menu()
+        elif answer is None:
+            return
+
+def change_language():
+    langs = {"Türkçe": "tr", "English": "en"}
+    try:
+        selected = questionary.select(
+            "Select Language / Dil Seçiniz:",
+            choices=list(langs.keys()),
+            pointer=">",
+            use_shortcuts=False
+        ).ask()
+        
+        if selected:
+            lang_code = langs[selected]
+            i18n.set_language(lang_code)
+            
+            new_source = "local" if lang_code == "tr" else "hianime"
+            config.set("scraping_source", new_source)
+            
+            console.print(f"[green]{i18n.get('settings.language_changed')}[/green]")
+            time.sleep(1)
+    except KeyboardInterrupt:
+        pass
+
+def change_source():
+    current_lang = config.get("language")
+    
+    sources = []
+    if current_lang == "tr":
+        sources = ["weeb", "animecix", "turkanime", "anizle"]
+    else:
+        sources = ["hianime", "allanime"]
+        
+    try:
+        selected = questionary.select(
+            i18n.get("settings.source"),
+            choices=sources,
+            pointer=">",
+            use_shortcuts=False
+        ).ask()
+        
+        if selected:
+            save_val = "local" if selected == "Weeb" else selected
+            config.set("scraping_source", save_val)
+            console.print(f"[green]{i18n.t('settings.source_changed', source=selected)}[/green]")
+            time.sleep(1)
+    except KeyboardInterrupt:
+        pass
+        
+
+
+def aria2_settings_menu():
+    while True:
+        console.clear()
+        show_header(i18n.get("settings.aria2_config"))
+        
+        curr_conn = config.get("aria2_max_connections", 16)
+        
+        opt_conn = f"{i18n.get('settings.max_conn')} [{curr_conn}]"
+        
+        try:
+            sel = questionary.select(
+                i18n.get("settings.aria2_config"),
+                choices=[opt_conn],
+                pointer=">",
+                use_shortcuts=False
+            ).ask()
+            
+            if sel == opt_conn:
+                val = questionary.text(f"{i18n.get('settings.enter_conn')}:", default=str(curr_conn)).ask()
+                if val and val.isdigit():
+                    config.set("aria2_max_connections", int(val))
+            elif sel is None:
+                return
+        except KeyboardInterrupt:
+            return
+
+def download_settings_menu():
+    while True:
+        console.clear()
+        show_header(i18n.get("settings.download_settings"))
+        
+        curr_dir = config.get("download_dir")
+        console.print(f"[dim]Current: {curr_dir}[/dim]\n", justify="left")
+        
+        curr_concurrent = config.get("max_concurrent_downloads", 3)
+        
+        opt_name = i18n.get("settings.change_folder_name")
+        opt_path = i18n.get("settings.change_full_path")
+        opt_concurrent = f"{i18n.get('settings.concurrent_downloads')} [{curr_concurrent}]"
+        
+        try:
+            sel = questionary.select(
+                i18n.get("settings.download_settings"),
+                choices=[opt_name, opt_path, opt_concurrent],
+                pointer=">",
+                use_shortcuts=False
+            ).ask()
+            
+            if sel == opt_name:
+                val = questionary.text("Folder Name:", default="weeb-downloads").ask()
+                if val:
+                    new_path = os.path.join(os.getcwd(), val)
+                    config.set("download_dir", new_path)
+            elif sel == opt_path:
+                val = questionary.text("Full Path:", default=curr_dir).ask()
+                if val:
+                    config.set("download_dir", val)
+            elif sel == opt_concurrent:
+                val = questionary.text(i18n.get("settings.enter_concurrent"), default=str(curr_concurrent)).ask()
+                if val and val.isdigit():
+                    n = int(val)
+                    if 1 <= n <= 5:
+                        config.set("max_concurrent_downloads", n)
+            elif sel is None:
+                return
+        except KeyboardInterrupt:
+            return
+
+
+def ytdlp_settings_menu():
+    while True:
+        console.clear()
+        show_header(i18n.get("settings.ytdlp_config"))
+        
+        curr_fmt = config.get("ytdlp_format", "best")
+        opt_fmt = f"{i18n.get('settings.format')} [{curr_fmt}]"
+        
+        try:
+            sel = questionary.select(
+                i18n.get("settings.ytdlp_config"), 
+                choices=[opt_fmt], 
+                pointer=">",
+                use_shortcuts=False
+            ).ask()
+            
+            if sel == opt_fmt:
+                val = questionary.text(f"{i18n.get('settings.enter_format')}:", default=curr_fmt).ask()
+                if val:
+                    config.set("ytdlp_format", val)
+            elif sel is None:
+                return
+        except KeyboardInterrupt:
+            return