libert 0.1.0__tar.gz

libert-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 HonoravelMacho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

libert-0.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: libert
+Version: 0.1.0
+Summary: CLI rápida para download de livros do welib
+Author: HonoravelMacho
+License: MIT
+Project-URL: Homepage, https://github.com/HonoravelMacho/libert
+Project-URL: Repository, https://github.com/HonoravelMacho/libert
+Keywords: welib,ebook,download,cli,livros
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Requires-Dist: beautifulsoup4>=4.11
+Requires-Dist: rich>=13
+Dynamic: license-file
+
+# libert
+
+CLI extremamente rápida e direta para download de livros do [welib](https://welib.st).
+
+Instale via PyPI:
+
+```bash
+pip install libert
+```
+
+## Uso
+
+```bash
+libert <URL_DO_WELIB>
+libert -f pdf <URL_DO_WELIB>
+libert --format epub <URL_DO_WELIB>
+```
+
+Exemplo:
+
+```bash
+libert https://pt.welib.st/md5/55d053185d2b4871c7a0549b997135f9
+```
+
+Fluxo no terminal:
+
+```
+[+] Conectando ao welib...
+[+] Livro encontrado: "Nome do Livro"
+[+] Formatos disponíveis:
+  [1] PDF  (15.4 MB)
+  [2] EPUB (2.1 MB)
+Escolha o formato desejado (1-2):
+```
+
+- Com apenas 1 formato disponível, o download começa automaticamente.
+- Com `-f/--format`, o modo é não-interativo.
+- Arquivos são salvos em `~/Downloads` (Linux) ou `~/storage/downloads` (Termux/Android).
+- Barra de progresso com tamanho total, porcentagem e velocidade.
+
+## Opções
+
+```
+libert [-f FORMATO] [-o PASTA] <URL>
+libert -V
+```
+
+## Desenvolvimento
+
+```bash
+pip install -e .
+python -m build
+```
+
+## Licença
+
+MIT

libert-0.1.0/README.md

@@ -0,0 +1,57 @@
+# libert
+
+CLI extremamente rápida e direta para download de livros do [welib](https://welib.st).
+
+Instale via PyPI:
+
+```bash
+pip install libert
+```
+
+## Uso
+
+```bash
+libert <URL_DO_WELIB>
+libert -f pdf <URL_DO_WELIB>
+libert --format epub <URL_DO_WELIB>
+```
+
+Exemplo:
+
+```bash
+libert https://pt.welib.st/md5/55d053185d2b4871c7a0549b997135f9
+```
+
+Fluxo no terminal:
+
+```
+[+] Conectando ao welib...
+[+] Livro encontrado: "Nome do Livro"
+[+] Formatos disponíveis:
+  [1] PDF  (15.4 MB)
+  [2] EPUB (2.1 MB)
+Escolha o formato desejado (1-2):
+```
+
+- Com apenas 1 formato disponível, o download começa automaticamente.
+- Com `-f/--format`, o modo é não-interativo.
+- Arquivos são salvos em `~/Downloads` (Linux) ou `~/storage/downloads` (Termux/Android).
+- Barra de progresso com tamanho total, porcentagem e velocidade.
+
+## Opções
+
+```
+libert [-f FORMATO] [-o PASTA] <URL>
+libert -V
+```
+
+## Desenvolvimento
+
+```bash
+pip install -e .
+python -m build
+```
+
+## Licença
+
+MIT

libert-0.1.0/libert/__init__.py

@@ -0,0 +1,3 @@
+"""libert - download de livros do welib via CLI."""
+
+__version__ = "0.1.0"

libert-0.1.0/libert/cli.py

@@ -0,0 +1,120 @@
+"""Interface de linha de comando do libert."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from libert import __version__
+from libert.downloader import download_file, filename_for, get_downloads_dir
+from libert.scraper import get_book_info, resolve_download_url
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="libert",
+        description="Baixe livros do welib direto pelo terminal. Ex: libert <URL_DO_WELIB>",
+    )
+    p.add_argument("url", nargs="?", help="URL da página do livro no welib (ex: https://pt.welib.st/md5/...)")
+    p.add_argument(
+        "-f",
+        "--format",
+        dest="fmt",
+        default=None,
+        help="Formato desejado (ex: pdf, epub, mobi). Evita a pergunta interativa.",
+    )
+    p.add_argument(
+        "-o",
+        "--output-dir",
+        dest="output_dir",
+        default=None,
+        help="Pasta de destino (padrão: ~/Downloads).",
+    )
+    p.add_argument(
+        "-V", "--version", action="store_true", help="Mostra a versão e sai."
+    )
+    return p
+
+
+def choose_format(formats, wanted: str | None):
+    if wanted:
+        w = wanted.strip().lower().lstrip(".")
+        for f in formats:
+            if f.fmt.lower() == w:
+                return f
+        validos = ", ".join(f.fmt for f in formats)
+        print(f'[!] Formato "{wanted}" não disponível para este livro. Formatos válidos: {validos}', file=sys.stderr)
+        sys.exit(2)
+    if len(formats) == 1:
+        return formats[0]
+    # Múltiplos formatos: pergunta interativa.
+    n = len(formats)
+    while True:
+        try:
+            ans = input(f"Escolha o formato desejado (1-{n}): ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\n[!] Operação cancelada.", file=sys.stderr)
+            sys.exit(130)
+        if ans.isdigit() and 1 <= int(ans) <= n:
+            return formats[int(ans) - 1]
+        print(f"[!] Escolha inválida. Digite um número entre 1 e {n}.", file=sys.stderr)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.version:
+        print(f"libert {__version__}")
+        return 0
+
+    if not args.url:
+        parser.print_usage(sys.stderr)
+        print("Erro: informe a URL do livro. Ex: libert https://pt.welib.st/md5/<hash>", file=sys.stderr)
+        return 2
+
+    url = args.url.strip()
+    if "welib" not in url and "/md5/" not in url:
+        print("[!] URL inválida. Esperado algo como: https://pt.welib.st/md5/<hash>", file=sys.stderr)
+        return 2
+
+    print("[+] Conectando ao welib...")
+    try:
+        book = get_book_info(url)
+    except RuntimeError as e:
+        print(f"[!] Erro: {e}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        print("\n[!] Operação cancelada.", file=sys.stderr)
+        return 130
+
+    print(f'[+] Livro encontrado: "{book.title}"')
+    print("[+] Formatos disponíveis:")
+    for i, f in enumerate(book.formats, start=1):
+        if f.size:
+            print(f"  [{i}] {f.fmt}  ({f.size})")
+        else:
+            print(f"  [{i}] {f.fmt}")
+
+    chosen = choose_format(book.formats, args.fmt)
+
+    from pathlib import Path
+
+    out_dir = Path(args.output_dir).expanduser() if args.output_dir else get_downloads_dir()
+    dest = out_dir / filename_for(book.title, chosen.fmt, resolve_download_url(chosen))
+
+    try:
+        final = download_file(resolve_download_url(chosen), dest, referer=book.source_url)
+    except RuntimeError as e:
+        print(f"[!] Erro no download: {e}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        print("\n[!] Download cancelado.", file=sys.stderr)
+        return 130
+
+    print(f"[+] Download concluído: {final}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

libert-0.1.0/libert/downloader.py

@@ -0,0 +1,139 @@
+"""Download de arquivos com barra de progresso (rich)."""
+
+from __future__ import annotations
+
+import os
+import re
+import time
+from pathlib import Path
+from urllib.parse import urlparse, unquote
+
+import requests
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    TaskProgressColumn,
+    TimeRemainingColumn,
+    TransferSpeedColumn,
+)
+
+BROWSER_HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
+        "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    ),
+    "Accept": "*/*",
+    "Accept-Language": "pt-BR,pt;q=0.9,en;q=0.8",
+    "Referer": "https://welib.st/",
+}
+
+
+def get_downloads_dir() -> Path:
+    """Pasta de Downloads do sistema (Linux desktop e Android/Termux)."""
+    home = Path.home()
+    candidates = [
+        home / "storage" / "downloads",  # Termux
+        home / "Downloads",  # Linux desktop / Termux (novo)
+        Path("/sdcard/Download"),  # Android alternativo
+    ]
+    for c in candidates:
+        try:
+            if c.exists() and c.is_dir():
+                return c
+        except OSError:
+            continue
+    # Fallback: cria ~/Downloads; se impossível, usa o cwd.
+    try:
+        (home / "Downloads").mkdir(parents=True, exist_ok=True)
+        return home / "Downloads"
+    except OSError:
+        cwd = Path.cwd()
+        return cwd
+
+
+def sanitize_filename(name: str) -> str:
+    name = re.sub(r'[<>:"/\\|?*\x00-\x1f]', "_", name).strip()
+    name = re.sub(r"\s+", " ", name)
+    name = name.strip(" .")
+    return name[:180] if len(name) > 180 else (name or "livro")
+
+
+def filename_for(title: str, fmt: str, url: str) -> str:
+    # Tenta extrair nome do Content-Disposition/URL depois; aqui o palpite inicial.
+    ext = fmt.lower().lstrip(".")
+    parsed = urlparse(url)
+    base = os.path.basename(unquote(parsed.path))
+    if base and "." in base and len(base) < 120:
+        return sanitize_filename(base)
+    return sanitize_filename(f"{title}.{ext}")
+
+
+def _filename_from_response(resp: requests.Response, fallback: str) -> str:
+    cd = resp.headers.get("Content-Disposition", "")
+    m = re.search(r'filename\*?=(?:UTF-8\'\')?"?([^";]+)"?', cd)
+    if m:
+        cand = sanitize_filename(unquote(m.group(1)))
+        if cand:
+            return cand
+    # Tenta pela URL final (após redirects).
+    parsed = urlparse(str(resp.url))
+    base = os.path.basename(unquote(parsed.path))
+    if base and "." in base and len(base) < 120 and "md5" not in base.lower():
+        return sanitize_filename(base)
+    return fallback
+
+
+def download_file(url: str, dest: Path, referer: str | None = None, timeout: int = 60) -> Path:
+    """Baixa `url` para `dest` com barra de progresso rich.
+
+    Mostra tamanho total, porcentagem e velocidade instantânea.
+    Retorna o caminho final (pode mudar via Content-Disposition).
+    """
+    headers = dict(BROWSER_HEADERS)
+    if referer:
+        headers["Referer"] = referer
+    dest.parent.mkdir(parents=True, exist_ok=True)
+
+    with requests.get(url, headers=headers, stream=True, timeout=timeout, allow_redirects=True) as resp:
+        if resp.status_code in (401, 403):
+            raise RuntimeError(
+                f"Download bloqueado (HTTP {resp.status_code}). "
+                "O welib pode exigir login/conta gratuita para downloads. "
+                "Abra a URL no navegador e verifique."
+            )
+        if resp.status_code == 404:
+            raise RuntimeError("Arquivo de download não encontrado (HTTP 404).")
+        resp.raise_for_status()
+
+        total = int(resp.headers.get("Content-Length", 0) or 0)
+        final_name = _filename_from_response(resp, dest.name)
+        final_dest = dest.parent / final_name
+        # Evita sobrescrever: adiciona (1), (2)...
+        if final_dest.exists() and final_dest != dest:
+            stem, suffix = final_dest.stem, final_dest.suffix
+            i = 1
+            while (dest.parent / f"{stem} ({i}){suffix}").exists():
+                i += 1
+            final_dest = dest.parent / f"{stem} ({i}){suffix}"
+
+        start = time.time()
+        downloaded = 0
+        with Progress(
+            "[progress.description]{task.description}",
+            BarColumn(),
+            TaskProgressColumn(),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+            TimeRemainingColumn(),
+        ) as progress:
+            task = progress.add_task(f"[cyan]Baixando {final_dest.name}", total=total or None)
+            with open(final_dest, "wb") as f:
+                for chunk in resp.iter_content(chunk_size=1024 * 64):
+                    if not chunk:
+                        continue
+                    f.write(chunk)
+                    downloaded += len(chunk)
+                    elapsed = max(time.time() - start, 0.001)
+                    progress.update(task, advance=len(chunk))
+        return final_dest

libert-0.1.0/libert/scraper.py

@@ -0,0 +1,386 @@
+"""Scraper para páginas de livros do welib (ex: https://pt.welib.st/md5/<hash>)."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from urllib.parse import urljoin, urlparse
+
+import requests
+from bs4 import BeautifulSoup
+
+BROWSER_HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
+        "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    ),
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+    "Accept-Language": "pt-BR,pt;q=0.9,en;q=0.8",
+    "Referer": "https://welib.st/",
+    "Upgrade-Insecure-Requests": "1",
+    "Sec-Fetch-Dest": "document",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": "same-origin",
+    "Cache-Control": "max-age=0",
+}
+
+MD5_RE = re.compile(r"/md5/([a-fA-F0-9]{32})")
+SIZE_RE = re.compile(r"(\d+(?:[.,]\d+)?\s*(?:B|KB|MB|GB))", re.IGNORECASE)
+# Formatos de e-book mais comuns no welib / Anna's Archive.
+KNOWN_EXTS = ["pdf", "epub", "mobi", "azw3", "djvu", "fb2", "txt", "doc", "docx", "cbr", "cbz"]
+
+
+@dataclass
+class BookFormat:
+    fmt: str  # ex: "PDF"
+    size: str  # ex: "15.4 MB" (pode ser "" se desconhecido)
+    url: str  # URL direta (ou intermediária) de download
+    label: str = ""  # descrição extra (idioma, ano...)
+
+
+@dataclass
+class BookInfo:
+    title: str
+    formats: list[BookFormat]
+    source_url: str
+
+
+def extract_md5(url: str) -> str | None:
+    m = MD5_RE.search(url)
+    return m.group(1).lower() if m else None
+
+
+def candidate_urls(url: str) -> list[str]:
+    """Gera URLs candidatas para contornar bloqueios/idiomas.
+
+    Tenta a URL original primeiro e depois espelhos do mesmo md5.
+    """
+    md5 = extract_md5(url)
+    if not md5:
+        return [url]
+    path = f"/md5/{md5}"
+    cands = [url]
+    for base in (
+        "https://welib.st",
+        "https://welib.org",
+        "https://pt.welib.st",
+        "https://en.welib.st",
+        "https://es.welib.st",
+    ):
+        full = base + path
+        if full not in cands:
+            cands.append(full)
+    return cands
+
+
+def fetch_page(url: str, timeout: int = 30) -> tuple[str, str]:
+    """Baixa o HTML da página do livro. Retorna (html, url_final).
+
+    Tenta a URL original e espelhos. Levanta RuntimeError com mensagem
+    amigável em caso de bloqueio (Cloudflare 403) ou 404.
+    """
+    last_err: Exception | None = None
+    for cand in candidate_urls(url):
+        try:
+            resp = requests.get(cand, headers=BROWSER_HEADERS, timeout=timeout, allow_redirects=True)
+        except requests.RequestException as e:
+            last_err = e
+            continue
+        if resp.status_code == 404:
+            last_err = RuntimeError(f"Página não encontrada (404): {cand}")
+            continue
+        if resp.status_code == 403:
+            # Provável desafio Cloudflare.
+            last_err = RuntimeError(
+                f"Acesso bloqueado (403) em {cand}. "
+                "O welib usa proteção Cloudflare; tente novamente em alguns segundos, "
+                "troque de rede ou use VPN."
+            )
+            continue
+        if resp.status_code != 200:
+            last_err = RuntimeError(f"HTTP {resp.status_code} ao acessar {cand}")
+            continue
+        ctype = resp.headers.get("Content-Type", "")
+        if "html" not in ctype and len(resp.text) < 500:
+            last_err = RuntimeError(f"Resposta inesperada de {cand} (HTTP {resp.status_code})")
+            continue
+        return resp.text, str(resp.url)
+    raise RuntimeError(str(last_err) if last_err else f"Não foi possível acessar {url}")
+
+
+def _clean_title(raw: str) -> str:
+    raw = re.sub(r"\s+", " ", raw).strip()
+    # Remove sufixos comuns: " - WeLib", " | WeLib", etc.
+    raw = re.sub(r"\s*[-|–—]\s*WeLib.*$", "", raw, flags=re.IGNORECASE).strip()
+    raw = re.sub(r"\s*[-|–—]\s*welib.*$", "", raw, flags=re.IGNORECASE).strip()
+    return raw
+
+
+def extract_title(soup: BeautifulSoup) -> str:
+    # 1. og:title
+    meta = soup.find("meta", attrs={"property": "og:title"})
+    if meta and meta.get("content"):
+        t = _clean_title(meta["content"])
+        if t:
+            return t
+    # 2. h1
+    h1 = soup.find("h1")
+    if h1 and h1.get_text(strip=True):
+        t = _clean_title(h1.get_text(" ", strip=True))
+        if t and len(t) > 2:
+            return t
+    # 3. <title>
+    if soup.title and soup.title.get_text(strip=True):
+        t = _clean_title(soup.title.get_text(" ", strip=True))
+        if t and t.lower() not in ("just a moment...", "welib", "welib.st"):
+            return t
+    # 4. primeiro elemento com cara de título
+    for sel in ("div.text-2xl", "div.text-xl", "div.font-bold", "h2"):
+        el = soup.select_one(sel)
+        if el and el.get_text(strip=True) and len(el.get_text(strip=True)) > 3:
+            return _clean_title(el.get_text(" ", strip=True))
+    return "Livro sem título"
+
+
+def _size_near(tag) -> str:
+    """Procura tamanho (ex: 15.4 MB) no texto do link e no elemento pai."""
+    texts = []
+    try:
+        texts.append(tag.get_text(" ", strip=True))
+    except Exception:
+        pass
+    parent = getattr(tag, "parent", None)
+    if parent is not None:
+        try:
+            texts.append(parent.get_text(" ", strip=True)[:500])
+        except Exception:
+            pass
+    for t in texts:
+        m = SIZE_RE.search(t or "")
+        if m:
+            return m.group(1).replace(",", ".").upper().strip()
+    return ""
+
+
+def _fmt_from_text(text: str) -> str | None:
+    low = (text or "").lower()
+    for ext in KNOWN_EXTS:
+        if re.search(r"\b" + re.escape(ext) + r"\b", low):
+            return ext.upper()
+    return None
+
+
+def _page_format_size(soup: BeautifulSoup) -> tuple[str, str]:
+    """Infere (formato, tamanho) principal da página.
+
+    Ex: <title>God's Festivals ... ( PDF, 1.2 MB ) - WeLib</title>
+    ou filepath '.../livro.pdf' + 'pdf, 1.2 MB' no texto.
+    """
+    texts: list[str] = []
+    if soup.title:
+        texts.append(soup.title.get_text(" ", strip=True))
+    h1 = soup.find("h1")
+    if h1:
+        texts.append(h1.get_text(" ", strip=True))
+    # Cabeçalho com "( PDF, 1.2 MB )"
+    for t in texts:
+        m = re.search(
+            r"\(\s*([A-Za-z0-9]{2,5})\s*,\s*(\d+(?:[.,]\d+)?\s*(?:B|KB|MB|GB))\s*\)",
+            t,
+            re.IGNORECASE,
+        )
+        if m and m.group(1).lower() in KNOWN_EXTS:
+            return m.group(1).upper(), m.group(2).replace(",", ".").upper().strip()
+    full = soup.get_text(" ", strip=True)
+    # "pdf, 1.2 MB" perto do início (evita listas de livros relacionados).
+    head = full[:4000]
+    m = re.search(
+        r"\b(pdf|epub|mobi|azw3|djvu|fb2|txt|docx?|cbr|cbz)\b\s*,\s*(\d+(?:[.,]\d+)?\s*(?:B|KB|MB|GB))",
+        head,
+        re.IGNORECASE,
+    )
+    if m:
+        return m.group(1).upper(), m.group(2).replace(",", ".").upper().strip()
+    # filepath ... .pdf
+    m = re.search(r"filepath:\S+\.(pdf|epub|mobi|azw3|djvu|fb2|txt|docx?|cbr|cbz)\b", full, re.IGNORECASE)
+    if m:
+        fmt = m.group(1).upper()
+        ms = SIZE_RE.search(head)
+        size = ms.group(1).replace(",", ".").upper().strip() if ms else ""
+        return fmt, size
+    return "", ""
+
+
+def extract_formats(soup: BeautifulSoup, page_url: str) -> list[BookFormat]:
+    """Extrai formatos de download da página do welib.
+
+    Numa página /md5/* real, todas as opções de download ("All download
+    options have the same file") correspondem ao MESMO arquivo: retorna
+    1 formato. Se a página listar extensões distintas, retorna uma
+    entrada por formato (para satisfazer o modo interativo da CLI).
+    """
+    IGNORE_PREFIX = (
+        "/search", "/member_codes", "/datasets", "/account", "/donate",
+        "/login", "/giftcards", "/torrents", "/member", "/db/",
+    )
+
+    def _ignored(href: str) -> bool:
+        h = href.strip()
+        if not h or h.startswith(("javascript:", "mailto:", "#")):
+            return True
+        low = h.lower()
+        # .torrent não é formato de e-book.
+        if low.endswith(".torrent") or "/torrents" in low:
+            return True
+        for p in IGNORE_PREFIX:
+            if low.startswith(p):
+                return True
+        return False
+
+    page_fmt, page_size = _page_format_size(soup)
+
+    # Coleta links reais de download, na ordem de preferência.
+    slow: list[str] = []
+    auto: list[str] = []
+    fast: list[str] = []
+    libgen: list[str] = []
+    ipfs: list[str] = []
+    other: list[str] = []
+
+    for a in soup.find_all("a", href=True):
+        href = (a.get("href") or "").strip()
+        if _ignored(href):
+            continue
+        low = href.lower()
+        text = a.get_text(" ", strip=True)
+        abs_url = urljoin(page_url, href)
+
+        if low.startswith("ipfs://"):
+            # Converte ipfs://CID -> https://ipfs.io/ipfs/CID
+            cid = href[len("ipfs://"):].split("?")[0].split("#")[0]
+            if cid:
+                ipfs.append(f"https://ipfs.io/ipfs/{cid}")
+            continue
+        if "/slow_download/" in low:
+            slow.append(abs_url)
+            continue
+        if "/auto_download/" in low:
+            auto.append(abs_url)
+            continue
+        if "/fast_download/" in low:
+            fast.append(abs_url)
+            continue
+        if "libgen" in low and "file.php" in low:
+            libgen.append(abs_url)
+            continue
+        if "ipfs" in low and ("/ipfs/" in low or "gateway" in low):
+            ipfs.append(abs_url)
+            continue
+        # Link direto para arquivo (.pdf/.epub/...), fora de /search.
+        m = re.search(r"\.(pdf|epub|mobi|azw3|djvu|fb2|txt|docx?|cbr|cbz)(\?|#|$)", low)
+        if m and ("/download" in low or "download" in text.lower() or low.startswith("https://")):
+            other.append(abs_url)
+
+    ordered_urls = slow + auto + fast + libgen + ipfs + other
+    # Dedup preservando ordem.
+    seen_u: set[str] = set()
+    uniq_urls: list[str] = []
+    for u in ordered_urls:
+        if u not in seen_u:
+            seen_u.add(u)
+            uniq_urls.append(u)
+
+    # Tenta detectar múltiplos formatos distintos na página
+    # (ex: badges "PDF (15.4 MB)" / "EPUB (2.1 MB)" como links diferentes).
+    multi: dict[str, tuple[str, str]] = {}  # fmt -> (size, url)
+    for a in soup.find_all("a", href=True):
+        href = (a.get("href") or "").strip()
+        if _ignored(href):
+            continue
+        low = href.lower()
+        if not any(k in low for k in ("/slow_download/", "/auto_download/", "/fast_download/", "/ipfs/", "file.php", ".pdf", ".epub", ".mobi", ".azw3", ".djvu", ".fb2")):
+            continue
+        text = a.get_text(" ", strip=True)
+        fmt = _fmt_from_text(text)
+        ext_in_href = re.search(r"\.(pdf|epub|mobi|azw3|djvu|fb2|txt|docx?|cbr|cbz)(\?|#|$)", low)
+        if fmt and ("/download" in low or ext_in_href or "ipfs" in low or "file.php" in low):
+            # Evita o falso positivo do link de busca "Search WeLib for filepath:..."
+            # (esses já foram ignorados via IGNORE_PREFIX, mas garante aqui).
+            size = _size_near(a)
+            if fmt not in multi:
+                multi[fmt] = (size, urljoin(page_url, href))
+
+    if len(multi) > 1:
+        out: list[BookFormat] = []
+        for fmt, (size, u) in multi.items():
+            out.append(BookFormat(fmt=fmt, size=size or page_size, url=u))
+        return out
+
+    # Caso comum: um único arquivo por página md5.
+    if uniq_urls:
+        fmt = page_fmt
+        if not fmt:
+            # Infere pela URL ou pelo texto geral (limitado ao head).
+            for u in uniq_urls:
+                f = _fmt_from_text(u)
+                if f:
+                    fmt = f
+                    break
+        if not fmt:
+            head = soup.get_text(" ", strip=True)[:4000]
+            fmt = _fmt_from_text(head) or "PDF"
+        return [BookFormat(fmt=fmt.upper(), size=page_size, url=uniq_urls[0])]
+
+    # Fallback sem links: menções textuais de formato + tamanho.
+    full_text = soup.get_text(" ", strip=True)
+    found: list[BookFormat] = []
+    for m in re.finditer(
+        r"([A-Za-z]{2,5}(?:\s*[·,|/]\s*[A-Za-z]{2,5})*)\s*[·,|]\s*[^·|]{0,60}?\s*(\d+(?:[.,]\d+)?\s*(?:B|KB|MB|GB))",
+        full_text[:8000],
+    ):
+        fmts_raw = m.group(1)
+        size = m.group(2).replace(",", ".").upper().strip()
+        for part in re.split(r"[·,|/]", fmts_raw):
+            f = part.strip().upper()
+            if f.lower() in KNOWN_EXTS:
+                found.append(BookFormat(fmt=f, size=size, url=page_url, label=m.group(0)[:120]))
+        if found:
+            break
+    if found:
+        dedup: dict[str, BookFormat] = {}
+        for f in found:
+            if f.fmt not in dedup:
+                dedup[f.fmt] = f
+        return list(dedup.values())
+
+    if page_fmt:
+        return [BookFormat(fmt=page_fmt, size=page_size, url=page_url)]
+    return []
+
+
+def get_book_info(url: str) -> BookInfo:
+    html, final_url = fetch_page(url)
+    soup = BeautifulSoup(html, "html.parser")
+
+    # Detecta desafio Cloudflare que passou como 200 com "Just a moment".
+    title_tag = (soup.title.get_text() if soup.title else "") or ""
+    if "just a moment" in title_tag.lower() and len(html) < 30000 and "challenge-platform" in html:
+        raise RuntimeError(
+            "O welib bloqueou a requisição (desafio Cloudflare). "
+            "Aguarde alguns segundos e tente novamente, ou acesse a URL no navegador primeiro."
+        )
+
+    title = extract_title(soup)
+    formats = extract_formats(soup, final_url)
+    if not formats:
+        raise RuntimeError(
+            f'Nenhum formato de download encontrado na página "{title}". '
+            "A página pode exigir login ou estar protegida. "
+            "Abra a URL no navegador para verificar os downloads disponíveis."
+        )
+    return BookInfo(title=title, formats=formats, source_url=final_url)
+
+
+def resolve_download_url(fmt: BookFormat) -> str:
+    """Por ora o href extraído já é a URL de download (segue redirects no GET)."""
+    return fmt.url

libert-0.1.0/libert.egg-info/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: libert
+Version: 0.1.0
+Summary: CLI rápida para download de livros do welib
+Author: HonoravelMacho
+License: MIT
+Project-URL: Homepage, https://github.com/HonoravelMacho/libert
+Project-URL: Repository, https://github.com/HonoravelMacho/libert
+Keywords: welib,ebook,download,cli,livros
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Requires-Dist: beautifulsoup4>=4.11
+Requires-Dist: rich>=13
+Dynamic: license-file
+
+# libert
+
+CLI extremamente rápida e direta para download de livros do [welib](https://welib.st).
+
+Instale via PyPI:
+
+```bash
+pip install libert
+```
+
+## Uso
+
+```bash
+libert <URL_DO_WELIB>
+libert -f pdf <URL_DO_WELIB>
+libert --format epub <URL_DO_WELIB>
+```
+
+Exemplo:
+
+```bash
+libert https://pt.welib.st/md5/55d053185d2b4871c7a0549b997135f9
+```
+
+Fluxo no terminal:
+
+```
+[+] Conectando ao welib...
+[+] Livro encontrado: "Nome do Livro"
+[+] Formatos disponíveis:
+  [1] PDF  (15.4 MB)
+  [2] EPUB (2.1 MB)
+Escolha o formato desejado (1-2):
+```
+
+- Com apenas 1 formato disponível, o download começa automaticamente.
+- Com `-f/--format`, o modo é não-interativo.
+- Arquivos são salvos em `~/Downloads` (Linux) ou `~/storage/downloads` (Termux/Android).
+- Barra de progresso com tamanho total, porcentagem e velocidade.
+
+## Opções
+
+```
+libert [-f FORMATO] [-o PASTA] <URL>
+libert -V
+```
+
+## Desenvolvimento
+
+```bash
+pip install -e .
+python -m build
+```
+
+## Licença
+
+MIT

libert-0.1.0/libert.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+libert/__init__.py
+libert/cli.py
+libert/downloader.py
+libert/scraper.py
+libert.egg-info/PKG-INFO
+libert.egg-info/SOURCES.txt
+libert.egg-info/dependency_links.txt
+libert.egg-info/entry_points.txt
+libert.egg-info/requires.txt
+libert.egg-info/top_level.txt

libert-0.1.0/libert.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

libert-0.1.0/libert.egg-info/entry_points.txt

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

libert-0.1.0/libert.egg-info/requires.txt

@@ -0,0 +1,3 @@
+requests>=2.28
+beautifulsoup4>=4.11
+rich>=13

libert-0.1.0/libert.egg-info/top_level.txt

@@ -0,0 +1 @@
+libert

libert-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "libert"
+version = "0.1.0"
+description = "CLI rápida para download de livros do welib"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "HonoravelMacho" }]
+keywords = ["welib", "ebook", "download", "cli", "livros"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Environment :: Console",
+  "Intended Audience :: End Users/Desktop",
+  "Topic :: Utilities",
+]
+dependencies = [
+  "requests>=2.28",
+  "beautifulsoup4>=4.11",
+  "rich>=13",
+]
+
+[project.scripts]
+libert = "libert.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/HonoravelMacho/libert"
+Repository = "https://github.com/HonoravelMacho/libert"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["libert*"]

libert-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+