mangadl-cli 1.1.0__py3-none-any.whl

mangadl/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "1.1.0"
+__author__ = "aydinAGF"

mangadl/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

mangadl/cli.py

@@ -0,0 +1,532 @@
+import sys
+import os
+import re
+import json
+import time
+import threading
+import shutil
+import argparse
+from typing import List, Optional
+
+from .scraper import search_manga, get_all_chapters, filter_chapters, get_chapter_images
+from .downloader import download_chapter, download_chapter_temp, _pack_cbz_merged, _is_termux, DEFAULT_DOWNLOAD_DIR, _has_aria2c, _has_pillow
+
+BANNER = r"""
+  ╔══════════════════════════════════════════════╗
+  ║               Manga Downloader               ║
+  ║  weebcentral.com  |  aydinAGF  |   CBZ/PDF   ║
+  ╚══════════════════════════════════════════════╝
+"""
+
+HELP = """
+  Chapter range formats:
+    1          → single chapter
+    2-8        → chapters 2 to 8
+    1-90       → chapters 1 to 90
+    all        → every chapter
+    1,5,10     → specific chapters
+    1-10,20    → mixed
+"""
+
+FORMAT_MENU = """
+  Output format:
+    1. CBZ           — comic book archive (one per chapter)
+    2. PDF           — single PDF per chapter{pdf_note}
+    3. Images        — raw image folder (one folder per chapter)
+    4. CBZ (All-in-One) — merge all selected chapters into one big CBZ
+"""
+
+
+def _session_path(download_dir: str, safe_title: str) -> str:
+    return os.path.join(download_dir, safe_title, ".mangadl_session.json")
+
+
+def _load_session(download_dir: str, safe_title: str) -> dict:
+    path = _session_path(download_dir, safe_title)
+    if os.path.exists(path):
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+def _save_session(download_dir: str, safe_title: str, session: dict):
+    path = _session_path(download_dir, safe_title)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(session, f, indent=2)
+
+
+def _clear_session(download_dir: str, safe_title: str):
+    path = _session_path(download_dir, safe_title)
+    if os.path.exists(path):
+        os.remove(path)
+
+
+def _live_search() -> Optional[dict]:
+    try:
+        from prompt_toolkit import prompt
+        from prompt_toolkit.completion import Completer, Completion
+
+        class MangaCompleter(Completer):
+            def __init__(self):
+                self._cache: dict = {}
+                self._last_text = ""
+                self._results: List[dict] = []
+
+            def get_completions(self, document, complete_event):
+                text = document.text_before_cursor.strip()
+                if len(text) < 2 or text == self._last_text:
+                    for r in self._results:
+                        yield Completion(r["title"], start_position=-len(text))
+                    return
+                self._last_text = text
+                try:
+                    self._results = search_manga(text)
+                except Exception:
+                    self._results = []
+                for r in self._results:
+                    yield Completion(r["title"], start_position=-len(text))
+
+        completer = MangaCompleter()
+        print("\n  Type manga name — suggestions appear as you type. Press Tab to pick, Enter to search.\n")
+        try:
+            query = prompt("  Search: ", completer=completer, complete_while_typing=True)
+        except (KeyboardInterrupt, EOFError):
+            return None
+
+        query = query.strip()
+        if not query:
+            return None
+        print(f"\n  Searching for '{query}'...")
+        results = search_manga(query)
+
+    except ImportError:
+        try:
+            print("\n  Type manga name and press Enter.\n")
+            query = input("  Search: ").strip()
+        except (KeyboardInterrupt, EOFError):
+            return None
+        if not query:
+            return None
+        print(f"  Searching for '{query}'...")
+        results = search_manga(query)
+
+    if not results:
+        print("  [!] No results found. Try a different name.")
+        return None
+
+    print()
+    print("  +--------------------------------------------+")
+    print("  |              Search Results                 |")
+    print("  +--------------------------------------------+")
+    for i, r in enumerate(results[:15], 1):
+        title = r["title"][:48]
+        print(f"  |  {i:>2}. {title:<48}|")
+    print("  +--------------------------------------------+")
+
+    while True:
+        try:
+            choice = input(f"\n  Pick a number (1-{min(len(results), 15)}): ").strip()
+            if not choice:
+                continue
+            idx = int(choice) - 1
+            if 0 <= idx < min(len(results), 15):
+                return results[idx]
+            print("  [!] Invalid choice.")
+        except ValueError:
+            print("  [!] Please enter a number.")
+        except (KeyboardInterrupt, EOFError):
+            return None
+
+
+def _get_chapter_range(ch_min: float, ch_max: float, total: int) -> str:
+    print(HELP)
+    while True:
+        try:
+            raw = input(f"  Enter chapter range ({ch_min:.0f}-{ch_max:.0f} available): ").strip()
+            if raw:
+                return raw
+        except (KeyboardInterrupt, EOFError):
+            return ""
+
+
+def _get_output_format() -> str:
+    pdf_note = "" if _has_pillow() else "  [!] requires: pip install Pillow"
+    print(FORMAT_MENU.format(pdf_note=pdf_note))
+    formats = {1: "cbz", 2: "pdf", 3: "images", 4: "cbz-merge"}
+    while True:
+        try:
+            raw = input("  Select format (1-4) [default: 1]: ").strip()
+            if not raw:
+                return "cbz"
+            num = int(raw)
+            if num in formats:
+                chosen = formats[num]
+                if chosen == "pdf" and not _has_pillow():
+                    print("  [!] Pillow not installed. Install it first: pip install Pillow")
+                    continue
+                return chosen
+            print("  [!] Enter 1, 2, 3, or 4.")
+        except ValueError:
+            print("  [!] Enter 1, 2, 3, or 4.")
+        except (KeyboardInterrupt, EOFError):
+            return "cbz"
+
+
+def _progress_bar(done: int, total: int, width: int = 30) -> str:
+    pct = done / total if total else 0
+    filled = int(width * pct)
+    bar = "#" * filled + "-" * (width - filled)
+    return f"[{bar}] {done}/{total}"
+
+
+def _spinner_thread(stop: threading.Event, label: str):
+    frames = ["|", "/", "-", "\\"]
+    i = 0
+    while not stop.is_set():
+        sys.stdout.write(f"\r  {frames[i % len(frames)]}  {label}...")
+        sys.stdout.flush()
+        stop.wait(0.1)
+        i += 1
+    sys.stdout.write("\r" + " " * 70 + "\r")
+    sys.stdout.flush()
+
+
+def _pick_download_dir(default: str) -> str:
+    print(f"  Download directory: {default}")
+    try:
+        raw = input("  Change directory? (y/N) [default: keep current]: ").strip().lower()
+    except (KeyboardInterrupt, EOFError):
+        print()
+        return default
+    if raw not in ("y", "yes"):
+        return default
+    print("  Enter new path (or press Enter to keep current):")
+    try:
+        new_path = input(f"  [{default}]: ").strip()
+    except (KeyboardInterrupt, EOFError):
+        print()
+        return default
+    if not new_path:
+        return default
+    new_path = os.path.expanduser(new_path)
+    os.makedirs(new_path, exist_ok=True)
+    print(f"  Download directory set to: {new_path}\n")
+    return new_path
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="mangadl",
+        description="Manga downloader for Termux — downloads from weebcentral.com",
+        add_help=True,
+    )
+    parser.add_argument(
+        "--dir",
+        metavar="PATH",
+        default=None,
+        help=f"Set download directory (default: {DEFAULT_DOWNLOAD_DIR})",
+    )
+    args = parser.parse_args()
+
+    print(BANNER)
+
+    if not _has_aria2c():
+        if _is_termux():
+            print("  [~] aria2c not found — downloads will use threads (slower).")
+            print("      Install with: pkg install aria2\n")
+        else:
+            print("  [~] aria2c not found — downloads will use threads (slower).")
+            print("      Install: https://aria2.github.io/\n")
+
+    if args.dir:
+        download_dir = os.path.expanduser(args.dir)
+        os.makedirs(download_dir, exist_ok=True)
+        print(f"  Download directory: {download_dir}\n")
+    else:
+        download_dir = os.environ.get("MANGA_DOWNLOAD_DIR", DEFAULT_DOWNLOAD_DIR)
+        download_dir = _pick_download_dir(download_dir)
+
+    while True:
+        manga = _live_search()
+        if not manga:
+            print("\n  Goodbye!\n")
+            break
+
+        title = manga["title"]
+        series_id = manga["series_id"]
+        print(f"\n  Selected: {title}")
+
+        stop = threading.Event()
+        t = threading.Thread(target=_spinner_thread, args=(stop, "Fetching chapter list"), daemon=True)
+        t.start()
+        chapters = get_all_chapters(series_id)
+        stop.set()
+        t.join()
+
+        if not chapters:
+            print("  [!] Could not fetch chapter list. Try again.")
+            continue
+
+        total_ch = len(chapters)
+        ch_min = chapters[0][0]
+        ch_max = chapters[-1][0]
+        print(f"  Found {total_ch} chapters  (Ch {ch_min:.0f} - Ch {ch_max:.0f})\n")
+
+        raw_range = _get_chapter_range(ch_min, ch_max, total_ch)
+        if not raw_range:
+            continue
+
+        selected = filter_chapters(chapters, raw_range)
+        if not selected:
+            print("  [!] No chapters matched that range.")
+            continue
+
+        output_format = _get_output_format()
+        ext_label = {"cbz": "CBZ", "pdf": "PDF", "images": "Images", "cbz-merge": "CBZ (All-in-One)"}[output_format]
+
+        print(f"\n  Downloading {len(selected)} chapter(s) -> {ext_label}")
+        print(f"  Saving to: {download_dir}/{title}/")
+        print(f"  Downloader: {'aria2c' if _has_aria2c() else 'threaded'}\n")
+
+        safe_title = re.sub(r'[\\/*?:"<>|]', "_", title).strip()
+
+        if output_format == "cbz-merge":
+            session = _load_session(download_dir, safe_title)
+            resume = False
+            tmp_dirs = []
+            downloaded_chapters = set()
+
+            if session and session.get("title") == title:
+                saved_selection = session.get("selected_chapters", [])
+                saved_tmps = session.get("tmp_dirs", [])
+                valid_tmps = [td for td in saved_tmps if os.path.isdir(td)]
+                if valid_tmps and saved_selection:
+                    downloaded_chapters = set(saved_selection)
+                    tmp_dirs = valid_tmps
+                    print(f"  [~] Found previous session: {len(valid_tmps)} chapter(s) already downloaded.")
+                    try:
+                        choice = input("  Resume? (Y/n): ").strip().lower()
+                    except (KeyboardInterrupt, EOFError):
+                        choice = "n"
+                    if choice != "n":
+                        resume = True
+                        print(f"  Resuming with {len(valid_tmps)} cached chapter(s)...\n")
+
+            if not resume:
+                session = {"title": title, "selected_chapters": [], "tmp_dirs": []}
+                downloaded_chapters = set()
+
+            pending = [(ch_num, ch_url) for ch_num, ch_url in selected if ch_num not in downloaded_chapters]
+            total_selected = len(selected)
+
+            max_retries = 3
+            for attempt in range(max_retries):
+                if attempt > 0:
+                    print(f"\n  Retry attempt {attempt + 1}/{max_retries}...")
+                    pending = [(ch_num, ch_url) for ch_num, ch_url in selected if ch_num not in downloaded_chapters]
+
+                if not pending:
+                    break
+
+                for i, (ch_num, ch_url) in enumerate(pending, 1):
+                    idx = [c for c, _ in selected].index(ch_num) + 1
+                    ch_label = f"Ch {ch_num:.0f}" if ch_num == int(ch_num) else f"Ch {ch_num}"
+                    prefix = f"  [{idx}/{total_selected}]  {ch_label}"
+
+                    stop2 = threading.Event()
+                    t2 = threading.Thread(target=_spinner_thread, args=(stop2, f"{prefix} -- fetching pages"), daemon=True)
+                    t2.start()
+                    images = get_chapter_images(ch_url)
+                    stop2.set()
+                    t2.join()
+
+                    if not images:
+                        print(f"  [!] {ch_label}: no images found, skipping.")
+                        continue
+
+                    page_count = len(images)
+
+                    def on_progress(done: int, total: int, _prefix=prefix):
+                        bar = _progress_bar(done, total)
+                        sys.stdout.write(f"\r  {_prefix}  {bar}")
+                        sys.stdout.flush()
+
+                    sys.stdout.write(f"\r  {prefix}  {_progress_bar(0, page_count)}")
+                    sys.stdout.flush()
+
+                    tmp_dir, ok, log = download_chapter_temp(ch_num, images, on_progress)
+
+                    if ok:
+                        tmp_dirs.append(tmp_dir)
+                        downloaded_chapters.add(ch_num)
+                        sys.stdout.write(f"\r  {prefix}  {_progress_bar(page_count, page_count)}  OK\n")
+                        session["selected_chapters"] = list(downloaded_chapters)
+                        session["tmp_dirs"] = tmp_dirs
+                        _save_session(download_dir, safe_title, session)
+                    else:
+                        sys.stdout.write(f"\r  {prefix}  FAILED\n")
+                        sys.stdout.flush()
+                    sys.stdout.flush()
+
+            failed = [ch for ch, _ in selected if ch not in downloaded_chapters]
+            if failed:
+                failed_labels = [f"Ch {ch:.0f}" if ch == int(ch) else f"Ch {ch}" for ch in failed]
+                print(f"\n  [!] {len(failed)} chapter(s) failed: {', '.join(failed_labels)}")
+                while True:
+                    try:
+                        choice = input("  Retry failed chapters? (Y/n): ").strip().lower()
+                    except (KeyboardInterrupt, EOFError):
+                        choice = "n"
+                    if choice == "n":
+                        break
+                    retry_failed = [(ch, [u for c, u in selected if c == ch][0]) for ch in failed]
+                    for ch_num, ch_url in retry_failed:
+                        idx = [c for c, _ in selected].index(ch_num) + 1
+                        ch_label = f"Ch {ch_num:.0f}" if ch_num == int(ch_num) else f"Ch {ch_num}"
+                        prefix = f"  [{idx}/{total_selected}]  {ch_label}"
+
+                        stop2 = threading.Event()
+                        t2 = threading.Thread(target=_spinner_thread, args=(stop2, f"{prefix} -- fetching pages"), daemon=True)
+                        t2.start()
+                        images = get_chapter_images(ch_url)
+                        stop2.set()
+                        t2.join()
+
+                        if not images:
+                            print(f"  [!] {ch_label}: no images found, skipping.")
+                            continue
+
+                        page_count = len(images)
+
+                        def on_progress(done: int, total: int, _prefix=prefix):
+                            bar = _progress_bar(done, total)
+                            sys.stdout.write(f"\r  {_prefix}  {bar}")
+                            sys.stdout.flush()
+
+                        sys.stdout.write(f"\r  {prefix}  {_progress_bar(0, page_count)}")
+                        sys.stdout.flush()
+
+                        tmp_dir, ok, log = download_chapter_temp(ch_num, images, on_progress)
+
+                        if ok:
+                            tmp_dirs.append(tmp_dir)
+                            downloaded_chapters.add(ch_num)
+                            sys.stdout.write(f"\r  {prefix}  {_progress_bar(page_count, page_count)}  OK\n")
+                            session["selected_chapters"] = list(downloaded_chapters)
+                            session["tmp_dirs"] = tmp_dirs
+                            _save_session(download_dir, safe_title, session)
+                        else:
+                            sys.stdout.write(f"\r  {prefix}  FAILED\n")
+                            sys.stdout.flush()
+                        sys.stdout.flush()
+                    failed = [ch for ch, _ in selected if ch not in downloaded_chapters]
+                    if not failed:
+                        break
+                    print(f"\n  [!] Still {len(failed)} chapter(s) failed.")
+
+            if tmp_dirs:
+                out_path = os.path.join(download_dir, safe_title, f"{safe_title} - Merged ({len(tmp_dirs)} ch).cbz")
+                os.makedirs(os.path.dirname(out_path), exist_ok=True)
+
+                def on_merge_progress(done: int, total: int):
+                    bar = _progress_bar(done, total)
+                    sys.stdout.write(f"\r  Merging pages  {bar}")
+                    sys.stdout.flush()
+
+                print(f"\n  Merging {len(tmp_dirs)} chapter(s) into one CBZ...")
+                merge_ok, merge_log = _pack_cbz_merged(tmp_dirs, out_path, on_merge_progress)
+
+                if merge_ok:
+                    for td in tmp_dirs:
+                        shutil.rmtree(td, ignore_errors=True)
+                    _clear_session(download_dir, safe_title)
+                    sys.stdout.write(f"\r  Merging pages  {_progress_bar(1, 1)}  OK\n")
+                    print(f"\n  Saved: {out_path}")
+                    print(f"    ({len(downloaded_chapters)}/{total_selected} chapters, {merge_log})")
+                    if failed:
+                        print(f"    [!] {len(failed)} chapter(s) skipped: {', '.join(f'Ch {c:.0f}' if c == int(c) else f'Ch {c}' for c in failed)}")
+                else:
+                    print(f"\n  [!] Merge failed: {merge_log}")
+                    print("  Temp files kept — you can resume next time.")
+
+            continue
+
+        ok_count = 0
+        for i, (ch_num, ch_url) in enumerate(selected, 1):
+            ch_label = f"Ch {ch_num:.0f}" if ch_num == int(ch_num) else f"Ch {ch_num}"
+            prefix = f"  [{i}/{len(selected)}]  {ch_label}"
+
+            stop2 = threading.Event()
+            t2 = threading.Thread(target=_spinner_thread, args=(stop2, f"{prefix} -- fetching pages"), daemon=True)
+            t2.start()
+            images = get_chapter_images(ch_url)
+            stop2.set()
+            t2.join()
+
+            if not images:
+                print(f"  [!] {ch_label}: no images found, skipping.")
+                continue
+
+            page_count = len(images)
+
+            def on_progress(done: int, total: int, _prefix=prefix):
+                bar = _progress_bar(done, total)
+                sys.stdout.write(f"\r  {_prefix}  {bar}")
+                sys.stdout.flush()
+
+            sys.stdout.write(f"\r  {prefix}  {_progress_bar(0, page_count)}")
+            sys.stdout.flush()
+
+            ok, log = download_chapter(
+                ch_num, images, title, download_dir,
+                on_progress, verbose=True,
+                output_format=output_format,
+            )
+
+            ch_full = ch_label.replace("Ch ", "Chapter ")
+            if output_format == "pdf":
+                out_name = f"{safe_title} - {ch_full}.pdf"
+            elif output_format == "images":
+                out_name = f"{ch_full}/"
+            else:
+                out_name = f"{safe_title} - {ch_full}.cbz"
+
+            if ok:
+                sys.stdout.write(
+                    f"\r  {prefix}  {_progress_bar(page_count, page_count)}  OK  ->  {out_name}\n"
+                )
+                ok_count += 1
+            else:
+                sys.stdout.write(f"\r  {prefix}  FAILED\n")
+                sys.stdout.flush()
+                print()
+                print("  -- Error log -----------------------------------------")
+                for line in log.strip().splitlines():
+                    print(f"  {line}")
+                print("  -------------------------------------------------------")
+                print()
+            sys.stdout.flush()
+
+        print()
+        if ok_count == len(selected):
+            print(f"  All {ok_count} chapter(s) saved as {ext_label} to: {download_dir}/{title}/")
+        else:
+            print(f"  {ok_count}/{len(selected)} chapter(s) saved.")
+
+        print()
+        try:
+            again = input("  Download another manga? (Y/n): ").strip().lower()
+            if again == "n":
+                print("\n  Goodbye!\n")
+                break
+        except (KeyboardInterrupt, EOFError):
+            print("\n\n  Goodbye!\n")
+            break
+
+
+if __name__ == "__main__":
+    main()

mangadl/downloader.py

@@ -0,0 +1,372 @@
+import os
+import re
+import shutil
+import subprocess
+import threading
+import zipfile
+import urllib.request
+from typing import List, Callable, Optional
+
+
+def _is_termux() -> bool:
+    return os.path.isdir("/data/data/com.termux") or "TERMUX_VERSION" in os.environ
+
+
+def _default_download_dir() -> str:
+    if os.name == "nt":
+        home = os.path.expanduser("~")
+        for candidate in [
+            os.path.join(home, "Downloads", "Manga"),
+            os.path.join(home, "Manga"),
+        ]:
+            parent = os.path.dirname(candidate)
+            if os.path.isdir(parent):
+                return candidate
+        return os.path.join(home, "Downloads", "Manga")
+    if os.path.isdir("/sdcard"):
+        return "/sdcard/Manga"
+    home = os.path.expanduser("~")
+    return os.path.join(home, "Downloads", "Manga")
+
+
+def _get_temp_dir() -> str:
+    if _is_termux():
+        termux_tmp = "/data/data/com.termux/files/usr/tmp"
+        if os.path.isdir(termux_tmp):
+            return termux_tmp
+        return "/tmp"
+    for var in ["TEMP", "TMP"]:
+        d = os.environ.get(var)
+        if d and os.path.isdir(d):
+            return d
+    return "/tmp"
+
+
+DEFAULT_DOWNLOAD_DIR = _default_download_dir()
+ARIA2C_CONNECTIONS = 8 if _is_termux() else 16
+FALLBACK_WORKERS = 4 if _is_termux() else 8
+MIN_IMAGE_BYTES = 2048
+REQUEST_TIMEOUT = 30 if _is_termux() else 20
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Linux; Android 13; Termux) AppleWebKit/537.36",
+    "Referer": "https://weebcentral.com/",
+    "Accept": "image/png,image/webp,image/*,*/*",
+}
+
+
+def _safe_dir_name(name: str) -> str:
+    return re.sub(r'[\\/*?:"<>|]', "_", name).strip()
+
+
+def _has_aria2c() -> bool:
+    return shutil.which("aria2c") is not None
+
+
+def _has_pillow() -> bool:
+    try:
+        import PIL
+        return True
+    except ImportError:
+        return False
+
+
+def _count_valid_images(directory: str) -> int:
+    count = 0
+    for f in os.listdir(directory):
+        if f.startswith("."):
+            continue
+        if f.lower().endswith((".png", ".jpg", ".jpeg", ".webp")):
+            path = os.path.join(directory, f)
+            if os.path.getsize(path) >= MIN_IMAGE_BYTES:
+                count += 1
+    return count
+
+
+def _sorted_images(directory: str) -> List[str]:
+    files = []
+    for f in sorted(os.listdir(directory)):
+        if f.startswith("."):
+            continue
+        if f.lower().endswith((".png", ".jpg", ".jpeg", ".webp", ".gif")):
+            path = os.path.join(directory, f)
+            if os.path.getsize(path) >= MIN_IMAGE_BYTES:
+                files.append(path)
+    return files
+
+
+def _download_with_aria2c(urls: List[str], output_dir: str) -> tuple:
+    url_file = os.path.join(output_dir, ".aria2c_urls.txt")
+    with open(url_file, "w") as f:
+        for i, url in enumerate(urls):
+            ext = url.split("?")[0].rsplit(".", 1)[-1] or "jpg"
+            filename = f"{i+1:03d}.{ext}"
+            f.write(f"{url}\n")
+            f.write(f"\tout={filename}\n")
+
+    try:
+        proc = subprocess.Popen(
+            [
+                "aria2c",
+                f"--input-file={url_file}",
+                f"--dir={output_dir}",
+                f"-x{ARIA2C_CONNECTIONS}",
+                f"-s{ARIA2C_CONNECTIONS}",
+                "-k", "512K",
+                "--auto-file-renaming=false",
+                "--allow-overwrite=true",
+                "--summary-interval=0",
+                "--console-log-level=notice",
+                "--referer=https://weebcentral.com/",
+                "--user-agent=Mozilla/5.0 (Linux; Android 13; Termux) AppleWebKit/537.36",
+                "--header=Accept: image/png,image/webp,image/*,*/*",
+                "--header=Accept-Language: en-US,en;q=0.9",
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+        )
+        raw_out, _ = proc.communicate()
+        log = raw_out.decode("utf-8", errors="ignore")
+        valid = _count_valid_images(output_dir)
+        success = valid >= max(1, int(len(urls) * 0.9))
+        return success, log
+    finally:
+        if os.path.exists(url_file):
+            os.remove(url_file)
+
+
+def _download_fallback(
+    urls: List[str],
+    output_dir: str,
+    on_progress: Optional[Callable] = None,
+) -> tuple:
+    lock = threading.Lock()
+    results = [False] * len(urls)
+    errors: List[str] = []
+
+    def worker(idx: int, url: str):
+        ext = url.split("?")[0].rsplit(".", 1)[-1] or "jpg"
+        path = os.path.join(output_dir, f"{idx+1:03d}.{ext}")
+        ok = False
+        try:
+            req = urllib.request.Request(url, headers=HEADERS)
+            with urllib.request.urlopen(req, timeout=REQUEST_TIMEOUT) as resp:
+                data = resp.read()
+            if len(data) >= MIN_IMAGE_BYTES:
+                with open(path, "wb") as fh:
+                    fh.write(data)
+                ok = True
+        except Exception as e:
+            with lock:
+                errors.append(f"  [{idx+1:03d}] {e}")
+        results[idx] = ok
+        if on_progress:
+            with lock:
+                on_progress(sum(1 for r in results if r), len(urls))
+
+    from concurrent.futures import ThreadPoolExecutor
+    with ThreadPoolExecutor(max_workers=FALLBACK_WORKERS) as pool:
+        futures = [pool.submit(worker, i, u) for i, u in enumerate(urls)]
+        for f in futures:
+            f.result()
+
+    success = sum(results) >= max(1, int(len(urls) * 0.9))
+    return success, "\n".join(errors) if errors else "OK"
+
+
+def _pack_cbz(image_dir: str, cbz_path: str) -> bool:
+    files = _sorted_images(image_dir)
+    if not files:
+        return False
+    try:
+        with zipfile.ZipFile(cbz_path, "w", compression=zipfile.ZIP_STORED) as zf:
+            for fpath in files:
+                zf.write(fpath, arcname=os.path.basename(fpath))
+        return True
+    except Exception:
+        return False
+
+
+def _pack_cbz_merged(
+    chapter_dirs: List[str],
+    cbz_path: str,
+    on_progress: Optional[Callable] = None,
+) -> tuple:
+    all_files = []
+    for ch_dir in chapter_dirs:
+        files = _sorted_images(ch_dir)
+        all_files.extend(files)
+
+    if not all_files:
+        return False, "No valid images found across any chapter."
+
+    try:
+        total = len(all_files)
+        with zipfile.ZipFile(cbz_path, "w", compression=zipfile.ZIP_STORED) as zf:
+            for i, fpath in enumerate(all_files):
+                ext = os.path.splitext(fpath)[1].lower() or ".jpg"
+                arcname = f"{i + 1:04d}{ext}"
+                zf.write(fpath, arcname=arcname)
+                if on_progress:
+                    on_progress(i + 1, total)
+        return True, f"Merged {total} pages into single CBZ."
+    except Exception as e:
+        return False, f"Merged CBZ failed: {e}"
+
+
+def download_chapter_temp(
+    chapter_num: float,
+    images: List[str],
+    on_progress: Optional[Callable] = None,
+) -> tuple:
+    tmp_dir = os.path.join(_get_temp_dir(), f".mangadl_ch_{chapter_num}_{os.getpid()}")
+    os.makedirs(tmp_dir, exist_ok=True)
+
+    try:
+        if _has_aria2c():
+            ok, log = _download_with_aria2c(images, tmp_dir)
+            if on_progress:
+                on_progress(len(images), len(images))
+            if not ok:
+                log += "\n  [~] aria2c failed — retrying with built-in downloader...\n"
+                for f in os.listdir(tmp_dir):
+                    fp = os.path.join(tmp_dir, f)
+                    if os.path.getsize(fp) < MIN_IMAGE_BYTES:
+                        os.remove(fp)
+                ok2, log2 = _download_fallback(images, tmp_dir, on_progress)
+                log += log2
+                ok = ok2
+        else:
+            ok, log = _download_fallback(images, tmp_dir, on_progress)
+
+        if not ok:
+            valid = _count_valid_images(tmp_dir)
+            log += f"\n  [!] Only {valid}/{len(images)} pages downloaded successfully."
+            return tmp_dir, False, log
+
+        return tmp_dir, True, log
+    except Exception as e:
+        return tmp_dir, False, str(e)
+
+
+def _pack_pdf(image_dir: str, pdf_path: str) -> bool:
+    try:
+        from PIL import Image
+    except ImportError:
+        return False
+
+    files = _sorted_images(image_dir)
+    if not files:
+        return False
+    try:
+        imgs = []
+        for fpath in files:
+            img = Image.open(fpath).convert("RGB")
+            imgs.append(img)
+        if not imgs:
+            return False
+        imgs[0].save(
+            pdf_path,
+            save_all=True,
+            append_images=imgs[1:],
+            format="PDF",
+        )
+        return True
+    except Exception:
+        return False
+
+
+def _copy_images(image_dir: str, dest_dir: str) -> bool:
+    files = _sorted_images(image_dir)
+    if not files:
+        return False
+    os.makedirs(dest_dir, exist_ok=True)
+    for fpath in files:
+        shutil.copy2(fpath, dest_dir)
+    return True
+
+
+def download_chapter(
+    chapter_num: float,
+    images: List[str],
+    manga_title: str,
+    base_dir: str = DEFAULT_DOWNLOAD_DIR,
+    on_progress: Optional[Callable] = None,
+    verbose: bool = False,
+    output_format: str = "cbz",
+) -> tuple:
+    if not images:
+        return False, "No image URLs found for this chapter."
+
+    safe_title = _safe_dir_name(manga_title)
+    ch_label = (
+        f"Chapter {int(chapter_num)}"
+        if chapter_num == int(chapter_num)
+        else f"Chapter {chapter_num}"
+    )
+
+    series_dir = os.path.join(base_dir, safe_title)
+    os.makedirs(series_dir, exist_ok=True)
+
+    if output_format == "pdf":
+        out_path = os.path.join(series_dir, f"{safe_title} - {ch_label}.pdf")
+    elif output_format == "images":
+        out_path = os.path.join(series_dir, ch_label)
+    else:
+        out_path = os.path.join(series_dir, f"{safe_title} - {ch_label}.cbz")
+
+    if output_format == "images":
+        if os.path.isdir(out_path) and len(_sorted_images(out_path)) > 0:
+            if on_progress:
+                on_progress(len(images), len(images))
+            return True, "Already downloaded (skipped)."
+    else:
+        if os.path.exists(out_path) and os.path.getsize(out_path) > 0:
+            if on_progress:
+                on_progress(len(images), len(images))
+            return True, "Already downloaded (skipped)."
+
+    tmp_dir = os.path.join(series_dir, f".tmp_{ch_label}")
+    os.makedirs(tmp_dir, exist_ok=True)
+
+    log = ""
+    try:
+        if _has_aria2c():
+            ok, log = _download_with_aria2c(images, tmp_dir)
+            if on_progress:
+                on_progress(len(images), len(images))
+            if not ok:
+                log += "\n  [~] aria2c failed — retrying with built-in downloader...\n"
+                for f in os.listdir(tmp_dir):
+                    fp = os.path.join(tmp_dir, f)
+                    if os.path.getsize(fp) < MIN_IMAGE_BYTES:
+                        os.remove(fp)
+                ok2, log2 = _download_fallback(images, tmp_dir, on_progress)
+                log += log2
+                ok = ok2
+        else:
+            ok, log = _download_fallback(images, tmp_dir, on_progress)
+
+        if not ok:
+            valid = _count_valid_images(tmp_dir)
+            log += f"\n  [!] Only {valid}/{len(images)} pages downloaded successfully."
+            return False, log
+
+        if output_format == "pdf":
+            packed = _pack_pdf(tmp_dir, out_path)
+        elif output_format == "images":
+            packed = _copy_images(tmp_dir, out_path)
+        else:
+            packed = _pack_cbz(tmp_dir, out_path)
+
+        if not packed:
+            if output_format == "pdf" and not _has_pillow():
+                log += "\n  [!] PDF output requires Pillow: pip install Pillow"
+            else:
+                log += "\n  [!] Packing failed — no valid images in temp folder."
+            return False, log
+
+        return True, log
+
+    finally:
+        if os.path.exists(tmp_dir):
+            shutil.rmtree(tmp_dir, ignore_errors=True)

mangadl/scraper.py

@@ -0,0 +1,142 @@
+import re
+import os
+import urllib.request
+import urllib.parse
+from typing import List, Optional, Tuple, Dict
+
+BASE_URL = "https://weebcentral.com"
+REQUEST_TIMEOUT = 30 if os.path.isdir("/data/data/com.termux") or "TERMUX_VERSION" in os.environ else 20
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Linux; Android 13; Termux) AppleWebKit/537.36",
+    "Accept": "text/html,*/*",
+    "Referer": BASE_URL + "/",
+}
+
+
+def _get(url: str, extra_headers: Optional[dict] = None) -> str:
+    h = dict(HEADERS)
+    if extra_headers:
+        h.update(extra_headers)
+    req = urllib.request.Request(url, headers=h)
+    resp = urllib.request.urlopen(req, timeout=REQUEST_TIMEOUT)
+    return resp.read().decode("utf-8", errors="ignore")
+
+
+def _post(url: str, data: dict, extra_headers: Optional[dict] = None) -> str:
+    h = dict(HEADERS)
+    h["Content-Type"] = "application/x-www-form-urlencoded"
+    h["HX-Request"] = "true"
+    if extra_headers:
+        h.update(extra_headers)
+    encoded = urllib.parse.urlencode(data).encode()
+    req = urllib.request.Request(url, data=encoded, headers=h)
+    resp = urllib.request.urlopen(req, timeout=REQUEST_TIMEOUT)
+    return resp.read().decode("utf-8", errors="ignore")
+
+
+def search_manga(query: str) -> List[Dict]:
+    try:
+        html = _post(
+            f"{BASE_URL}/search/simple?location=main",
+            {"text": query},
+            {"HX-Request": "true"},
+        )
+    except Exception:
+        return []
+
+    results = []
+    pairs = re.findall(
+        r'href="(https://weebcentral\.com/series/([^/]+)/([^"]+))"[^>]*>.*?'
+        r'<div[^>]*class="[^"]*flex-1[^"]*"[^>]*>\s*(.*?)\s*</div>',
+        html,
+        re.DOTALL,
+    )
+    for url, series_id, slug, raw_title in pairs:
+        title = re.sub(r"<[^>]+>", "", raw_title).strip()
+        if title:
+            results.append({"title": title, "url": url, "series_id": series_id, "slug": slug})
+    return results
+
+
+def get_all_chapters(series_id: str) -> List[Tuple[float, str]]:
+    url = f"{BASE_URL}/series/{series_id}/full-chapter-list"
+    try:
+        html = _get(url, {"HX-Request": "true"})
+    except Exception:
+        return []
+
+    pairs = re.findall(
+        r'href="(https://weebcentral\.com/chapters/[^"]+)"[^>]*>.*?'
+        r'<span class="">\s*([^<]+?)\s*</span>',
+        html,
+        re.DOTALL,
+    )
+
+    result = []
+    for ch_url, title_text in pairs:
+        num_match = re.search(r'([\d]+(?:\.\d+)?)\s*$', title_text.strip())
+        if not num_match:
+            continue
+        try:
+            ch_num = float(num_match.group(1))
+            result.append((ch_num, ch_url))
+        except ValueError:
+            continue
+
+    result.sort(key=lambda x: x[0])
+    return result
+
+
+def filter_chapters(
+    chapters: List[Tuple[float, str]], chapter_range: str
+) -> List[Tuple[float, str]]:
+    if chapter_range.strip().lower() == "all":
+        return chapters
+
+    ch_map = {ch_num: ch_url for ch_num, ch_url in chapters}
+    all_nums = sorted(ch_map.keys())
+
+    selected = set()
+    for part in chapter_range.split(","):
+        part = part.strip()
+        if "-" in part:
+            bounds = part.split("-", 1)
+            try:
+                lo, hi = float(bounds[0]), float(bounds[1])
+                for n in all_nums:
+                    if lo <= n <= hi:
+                        selected.add(n)
+            except ValueError:
+                pass
+        else:
+            try:
+                n = float(part)
+                closest = min(all_nums, key=lambda x: abs(x - n))
+                if abs(closest - n) < 0.6:
+                    selected.add(closest)
+            except ValueError:
+                pass
+
+    return [(n, ch_map[n]) for n in sorted(selected) if n in ch_map]
+
+
+def get_chapter_images(chapter_url: str) -> List[str]:
+    chapter_id = chapter_url.rstrip("/").split("/")[-1]
+    img_url = f"{BASE_URL}/chapters/{chapter_id}/images?is_prev=False&reading_style=long_strip"
+    try:
+        html = _get(img_url, {"HX-Request": "true"})
+    except Exception:
+        return []
+
+    imgs = re.findall(
+        r'<img\s[^>]*src="(https://[^"]+\.(?:jpg|png|webp|jpeg)[^"]*)"',
+        html,
+        re.IGNORECASE,
+    )
+    seen = set()
+    unique = []
+    for img in imgs:
+        if img not in seen:
+            seen.add(img)
+            unique.append(img)
+    return unique

mangadl_cli-1.1.0.dist-info/METADATA

@@ -0,0 +1,206 @@
+Metadata-Version: 2.4
+Name: mangadl-cli
+Version: 1.1.0
+Summary: A manga downloader CLI for Termux — downloads from weebcentral.com with CBZ, PDF, or image output, chapter range selection, live search, and aria2c downloading.
+Author: aydinAGF
+License-Expression: MIT
+Project-URL: Repository, https://github.com/aydinAGF/mangadl
+Keywords: manga,downloader,termux,weebcentral,android,cli,aria2c
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Environment :: Console
+Classifier: Topic :: Multimedia
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: prompt_toolkit>=3.0.0
+Requires-Dist: Pillow>=9.0.0
+
+# mangadl
+
+A manga downloader CLI that downloads from [weebcentral.com](https://weebcentral.com). Works on **Android (Termux)**, **Windows**, **Linux**, and **macOS**.
+
+---
+
+## Features
+
+- **Live search** — type manga name, get suggestions as you type
+- **Chapter range selection** — single, range, batch, mixed
+- **Multiple output formats** — CBZ, PDF, Images, or merged All-in-One CBZ
+- **Fast downloads** — aria2c multi-connection downloading
+- **Resume support** — interrupted downloads continue from where they stopped
+- **Auto-retry** — failed chapters retry automatically
+- **Cross-platform** — same command on all platforms
+
+---
+
+## Install
+
+### Android (Termux)
+
+```bash
+# Update packages
+pkg update && pkg upgrade
+
+# Install dependencies
+pkg install aria2 python
+
+# Install mangadl
+pip install mangadl
+```
+
+Grant storage access so mangadl can save to your gallery:
+```bash
+termux-setup-storage
+```
+
+### Windows
+
+1. Install Python from https://www.python.org/downloads/ (check "Add to PATH")
+2. Open Command Prompt or PowerShell:
+```bash
+pip install mangadl
+```
+
+Optional — install aria2 for faster downloads: https://aria2.github.io/
+
+### Linux (Debian/Ubuntu)
+
+```bash
+# Install dependencies
+sudo apt update
+sudo apt install python3-pip aria2
+
+# Install mangadl
+pip install mangadl
+```
+
+### macOS
+
+```bash
+# Install dependencies
+brew install aria2
+
+# Install mangadl
+pip3 install mangadl
+```
+
+---
+
+## Usage
+
+```bash
+mangadl
+```
+
+1. Type manga name — suggestions appear as you type
+2. Pick a result from the numbered list
+3. Enter chapter range (see format below)
+4. Choose output format
+5. Downloads start automatically
+
+### Command-line options
+
+```bash
+# Set custom download directory
+mangadl --dir /path/to/manga
+
+# Show help
+mangadl --help
+```
+
+---
+
+## Output formats
+
+| Format | Description |
+|--------|-------------|
+| **CBZ** | Comic book archive — one file per chapter, best for comic readers |
+| **PDF** | Single PDF per chapter (requires `pip install Pillow`) |
+| **Images** | Raw image folder — one folder per chapter |
+| **CBZ (All-in-One)** | Merge all selected chapters into one big CBZ file |
+
+### All-in-One CBZ
+
+When you select "CBZ (All-in-One)", mangadl:
+1. Downloads all selected chapters to temp files
+2. Numbers pages sequentially across chapters (0001, 0002, ...)
+3. Merges everything into a single CBZ
+
+Example: Chapter 1 (20 pages) + Chapter 2 (15 pages) = one CBZ with 35 pages numbered 0001-0035.
+
+---
+
+## Chapter range formats
+
+| Input | Meaning |
+|-------|---------|
+| `1` | Single chapter 1 |
+| `2-8` | Chapters 2 through 8 |
+| `1-90` | Chapters 1 through 90 |
+| `all` | Every chapter |
+| `1,5,10` | Specific chapters |
+| `1-10,20,30-35` | Mixed ranges |
+
+---
+
+## Default download locations
+
+| Platform | Default path |
+|----------|-------------|
+| Android (Termux) | `/sdcard/Manga/` |
+| Windows | `C:\Users\<you>\Downloads\Manga\` |
+| Linux | `~/Downloads/Manga/` |
+| macOS | `~/Downloads/Manga/` |
+
+You can change the directory:
+- At startup when prompted
+- With the `--dir` flag: `mangadl --dir /custom/path`
+- With environment variable: `MANGA_DOWNLOAD_DIR=/path manga2`
+
+---
+
+## Requirements
+
+| Tool | Required? | Install |
+|------|-----------|---------|
+| Python 3.8+ | Yes | Pre-installed on most systems |
+| aria2 | Recommended | `pkg install aria2` / `apt install aria2` / `brew install aria2` |
+| prompt_toolkit | Yes (included) | Installed automatically |
+| Pillow | Optional | `pip install Pillow` (for PDF output) |
+
+Without aria2, mangadl uses built-in threaded downloads (slower but works).
+
+---
+
+## Troubleshooting
+
+### aria2c not found
+```bash
+# Termux
+pkg install aria2
+
+# Windows — download from https://aria2.github.io/
+# Linux
+sudo apt install aria2
+
+# macOS
+brew install aria2
+```
+
+### Permission denied on /sdcard (Termux)
+```bash
+termux-setup-storage
+```
+
+### Python not found (Windows)
+Make sure you checked "Add Python to PATH" during install. Then restart your terminal.
+
+### Slow downloads
+Install aria2 for faster multi-connection downloading.
+
+---
+
+## License
+
+MIT

mangadl_cli-1.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+mangadl/__init__.py,sha256=wtxrJTbU0eJJbo3nQ9mx96IOvuQAtlScbTKpRfwisbc,46
+mangadl/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+mangadl/cli.py,sha256=LW5K0zG8bARokEq-ucB2FSXtWzGR0rRlDfpWh1n1fMs,20864
+mangadl/downloader.py,sha256=CaYdHyXnPoAq_j_2SWuCZGqwP9LwjID0qty50xqvYS8,11911
+mangadl/scraper.py,sha256=C3-cXfnNrVn2Y5QAj6XnVyA6kyoMIlqjX1o9P4GECYs,4329
+mangadl_cli-1.1.0.dist-info/METADATA,sha256=qeE2jsxMQdx7SWlGLnyDp2ufmdI6QAxrHe70yD-aX5I,4984
+mangadl_cli-1.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+mangadl_cli-1.1.0.dist-info/entry_points.txt,sha256=kHnLVJiPFwNS91CXriWmpm1mCryeGcksuG-EQv6wxqY,45
+mangadl_cli-1.1.0.dist-info/top_level.txt,sha256=QYyBQW5jyNN7kfHTEAdG5Sub3KjfcNYgnWPThzhBhDg,8
+mangadl_cli-1.1.0.dist-info/RECORD,,

mangadl_cli-1.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mangadl_cli-1.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mangadl = mangadl.cli:main

mangadl_cli-1.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mangadl