Add manga URL colorizer tab with cache preview and batch colorization

.gitignore

@@ -0,0 +1,9 @@
+cache/
+outputs/
+downloads/
+manga_cache/
+*.zip
+
+__pycache__/
+*.py[cod]
+.pytest_cache/

README.md

@@ -11,4 +11,10 @@ license: apache-2.0
 short_description: FireRed-Image-Edit × Qwen-Image-Edit-Rapid (Transformers)
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+## Manga URL Colorizer
+
+The Space now includes a second tab for manga page extraction and batch colorization from allowed URLs. It caches original pages under `cache/manga/<slug>/original/`, saves generated pages under `cache/manga/<slug>/colorized/`, and produces a downloadable `colorized_manga.zip`.
+
+Use only content you own or have permission to process. The URL fetcher is limited to configured allowed domains and does not bypass login, captcha, paywall, Cloudflare, or other access protections.

app.py

@@ -11,6 +11,17 @@ import html as html_lib
 from io import BytesIO
 from PIL import Image
 
+from manga_colorizer import (
+    MANGA_CACHE_ROOT,
+    MANGA_DEFAULT_PROMPT,
+    MANGA_NEGATIVE_PROMPT,
+    MangaColorizerError,
+    extract_and_cache_manga,
+    get_colorized_path,
+    load_manga_metadata,
+    make_colorized_zip,
+)
+
 MAX_SEED = np.iinfo(np.int32).max
 LANCZOS = getattr(Image, "Resampling", Image).LANCZOS
 
@@ -215,6 +226,126 @@ def infer(images_b64_json, prompt, seed, randomize_seed, guidance_scale, steps,
         torch.cuda.empty_cache()
 
 
+def extract_manga_for_ui(url, max_pages):
+    try:
+        status, original_paths, metadata_json = extract_and_cache_manga(url, max_pages)
+        choices = [f"{idx:03d}" for idx in range(1, len(original_paths) + 1)]
+        default_selection = choices[:1]
+        return (
+            status,
+            original_paths,
+            metadata_json,
+            gr.update(choices=choices, value=default_selection),
+        )
+    except MangaColorizerError as exc:
+        raise gr.Error(str(exc)) from exc
+
+
+def _parse_selected_page_indexes(selected_pages, total_pages):
+    if isinstance(selected_pages, str):
+        selected_pages = [selected_pages]
+    indexes = []
+    for page in selected_pages or []:
+        try:
+            page_number = int(str(page).split()[0])
+        except (TypeError, ValueError):
+            continue
+        index = page_number - 1
+        if 0 <= index < total_pages and index not in indexes:
+            indexes.append(index)
+    return indexes
+
+
+def colorize_manga_page(image_path: str, prompt: str, seed: int, guidance_scale: float, steps: int) -> Image.Image:
+    input_image = Image.open(image_path).convert("RGB")
+    width, height = update_dimensions_on_upload(input_image)
+    generator = torch.Generator(device=device).manual_seed(int(seed))
+    result_image = pipe(
+        image=[input_image],
+        prompt=prompt,
+        negative_prompt=MANGA_NEGATIVE_PROMPT,
+        height=height,
+        width=width,
+        num_inference_steps=int(steps),
+        generator=generator,
+        true_cfg_scale=float(guidance_scale),
+    ).images[0]
+    output_path = get_colorized_path(image_path)
+    result_image.save(output_path)
+    return result_image
+
+
+@spaces.GPU
+def colorize_cached_manga(
+    metadata_json,
+    prompt,
+    selected_pages,
+    colorize_all,
+    seed,
+    randomize_seed,
+    guidance_scale,
+    steps,
+    max_color_pages,
+    progress=gr.Progress(track_tqdm=True),
+):
+    if not torch.cuda.is_available():
+        raise gr.Error("No hay GPU disponible para colorear manga.")
+
+    try:
+        metadata = load_manga_metadata(metadata_json)
+    except MangaColorizerError as exc:
+        raise gr.Error(str(exc)) from exc
+
+    original_paths = metadata.get("original_paths") or []
+    existing_paths = [path for path in original_paths if path and os.path.exists(path)]
+    if not existing_paths:
+        raise gr.Error("No hay imagenes en cache. Extrae las paginas primero.")
+
+    try:
+        limit = int(max_color_pages)
+    except (TypeError, ValueError):
+        limit = 5
+    limit = max(1, min(limit, 30))
+
+    if colorize_all:
+        page_indexes = list(range(min(len(existing_paths), limit)))
+    else:
+        page_indexes = _parse_selected_page_indexes(selected_pages, len(existing_paths))[:limit]
+
+    if not page_indexes:
+        raise gr.Error("Selecciona al menos una pagina o activa colorear todas.")
+
+    prompt = (prompt or MANGA_DEFAULT_PROMPT).strip() or MANGA_DEFAULT_PROMPT
+    try:
+        base_seed = int(seed)
+    except (TypeError, ValueError):
+        base_seed = 0
+
+    colorized_paths = []
+    total = len(page_indexes)
+    for progress_index, page_index in enumerate(page_indexes, start=1):
+        page_seed = random.randint(0, MAX_SEED) if randomize_seed else base_seed
+        page_path = existing_paths[page_index]
+        progress(progress_index / total, desc=f"Colorizing page {page_index + 1:03d}")
+        try:
+            colorize_manga_page(page_path, prompt, page_seed, guidance_scale, steps)
+        finally:
+            gc.collect()
+            torch.cuda.empty_cache()
+        colorized_paths.append(str(get_colorized_path(page_path)))
+
+    try:
+        zip_path = make_colorized_zip(colorized_paths)
+    except MangaColorizerError as exc:
+        raise gr.Error(str(exc)) from exc
+
+    status = (
+        f"Listo: {len(colorized_paths)} pagina(s) coloreada(s). "
+        f"ZIP generado. Solo usar con contenido propio o con permiso."
+    )
+    return status, colorized_paths, zip_path
+
+
 css = r"""
 @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&family=JetBrains+Mono:wght@400;500;600&display=swap');
 *{box-sizing:border-box;margin:0;padding:0}
@@ -225,6 +356,20 @@ body,.gradio-container{
 .dark body,.dark .gradio-container{background:#0f0f13!important;color:#e4e4e7!important}
 footer{display:none!important}
 .hidden-input{display:none!important;height:0!important;overflow:hidden!important;margin:0!important;padding:0!important}
+.manga-colorizer-shell{
+    max-width:1200px;margin:12px auto 24px;padding:18px;background:#18181b;
+    border:1px solid #27272a;border-radius:12px;box-shadow:0 18px 36px rgba(0,0,0,.34);
+}
+.manga-colorizer-shell h2{color:#ffffff!important;font-size:22px!important;margin-bottom:6px!important}
+.manga-colorizer-shell p,.manga-colorizer-shell label,.manga-colorizer-shell span{
+    color:#d4d4d8!important;
+}
+.manga-colorizer-shell textarea,.manga-colorizer-shell input{
+    background:#09090b!important;color:#f4f4f5!important;border-color:#3f3f46!important;
+}
+.manga-colorizer-shell button{
+    border-radius:8px!important;font-weight:700!important;
+}
 #example-load-btn{
     position:absolute!important;left:-9999px!important;top:-9999px!important;
     width:1px!important;height:1px!important;opacity:0.01!important;
@@ -988,7 +1133,9 @@ with gr.Blocks() as demo:
     example_result = gr.Textbox(value="", elem_id="example-result-data", elem_classes="hidden-input", container=False)
     example_load_btn = gr.Button("Load Example", elem_id="example-load-btn")
 
-    gr.HTML(f"""
+    with gr.Tabs(elem_id="main-tabs"):
+        with gr.Tab("Image Editor"):
+            gr.HTML(f"""
     <div class="app-shell">
         <div class="app-header">
             <div class="app-header-left">
@@ -1133,6 +1280,96 @@ with gr.Blocks() as demo:
     </div>
     """)
 
+        with gr.Tab("Manga URL Colorizer"):
+            with gr.Column(elem_classes="manga-colorizer-shell"):
+                gr.Markdown(
+                    "## Manga URL Colorizer\n"
+                    "Extrae paginas desde una URL permitida, guarda originales en cache, "
+                    "previsualiza y colorea por lotes usando el mismo modelo cargado. "
+                    "**Solo usar con contenido propio o con permiso.**"
+                )
+                with gr.Row():
+                    manga_url = gr.Textbox(
+                        label="Manga URL",
+                        placeholder="https://hmanga.asia/porque-eres-tu-enano/#all",
+                        scale=4,
+                    )
+                    manga_max_pages = gr.Slider(
+                        label="Maximo de paginas a descargar",
+                        minimum=1,
+                        maximum=120,
+                        step=1,
+                        value=10,
+                        scale=1,
+                    )
+                manga_extract_btn = gr.Button("1. Extraer imagenes", variant="primary")
+                manga_status = gr.Markdown("Ready.")
+                manga_original_gallery = gr.Gallery(
+                    label="Preview de paginas originales",
+                    columns=5,
+                    height=420,
+                    object_fit="contain",
+                )
+                manga_metadata = gr.Textbox(label="Manga metadata", visible=False)
+
+                with gr.Row():
+                    manga_selected_pages = gr.CheckboxGroup(
+                        label="Paginas a colorear",
+                        choices=[],
+                        value=[],
+                        scale=3,
+                    )
+                    manga_colorize_all = gr.Checkbox(
+                        label="Colorear todas las paginas descargadas",
+                        value=False,
+                        scale=1,
+                    )
+
+                manga_prompt = gr.Textbox(
+                    label="Prompt de colorizacion",
+                    value=MANGA_DEFAULT_PROMPT,
+                    lines=6,
+                )
+                with gr.Row():
+                    manga_seed = gr.Slider(
+                        label="Seed",
+                        minimum=0,
+                        maximum=MAX_SEED,
+                        step=1,
+                        value=0,
+                    )
+                    manga_randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+                with gr.Row():
+                    manga_guidance_scale = gr.Slider(
+                        label="Guidance scale",
+                        minimum=1.0,
+                        maximum=10.0,
+                        step=0.1,
+                        value=1.0,
+                    )
+                    manga_steps = gr.Slider(
+                        label="Steps",
+                        minimum=1,
+                        maximum=50,
+                        step=1,
+                        value=4,
+                    )
+                    manga_max_color_pages = gr.Slider(
+                        label="Maximo de paginas a colorear",
+                        minimum=1,
+                        maximum=30,
+                        step=1,
+                        value=5,
+                    )
+                manga_colorize_btn = gr.Button("2. Colorear manga", variant="primary")
+                manga_colorized_gallery = gr.Gallery(
+                    label="Resultados coloreados",
+                    columns=5,
+                    height=420,
+                    object_fit="contain",
+                )
+                manga_zip = gr.File(label="Descargar ZIP coloreado")
+
     run_btn = gr.Button("Run", elem_id="gradio-run-btn")
 
     demo.load(fn=None, js=gallery_js)
@@ -1159,11 +1396,34 @@ with gr.Blocks() as demo:
         queue=False,
     )
 
+    manga_extract_btn.click(
+        fn=extract_manga_for_ui,
+        inputs=[manga_url, manga_max_pages],
+        outputs=[manga_status, manga_original_gallery, manga_metadata, manga_selected_pages],
+        queue=False,
+    )
+
+    manga_colorize_btn.click(
+        fn=colorize_cached_manga,
+        inputs=[
+            manga_metadata,
+            manga_prompt,
+            manga_selected_pages,
+            manga_colorize_all,
+            manga_seed,
+            manga_randomize_seed,
+            manga_guidance_scale,
+            manga_steps,
+            manga_max_color_pages,
+        ],
+        outputs=[manga_status, manga_colorized_gallery, manga_zip],
+    )
+
 if __name__ == "__main__":
     demo.queue(max_size=50).launch(
         css=css,
         mcp_server=True,
         ssr_mode=False,
         show_error=True,
-        allowed_paths=["examples"],
-    )
+        allowed_paths=["examples", str(MANGA_CACHE_ROOT)],
+    )

manga_colorizer.py

@@ -0,0 +1,360 @@
+import hashlib
+import ipaddress
+import json
+import re
+import zipfile
+from pathlib import Path
+from urllib.parse import unquote, urljoin, urlparse, urlunparse
+
+import requests
+from bs4 import BeautifulSoup
+
+
+ALLOWED_DOMAINS = ["hmanga.asia"]
+MANGA_CACHE_ROOT = Path("cache") / "manga"
+MANGA_IMAGE_EXTENSIONS = (".webp", ".jpg", ".jpeg", ".png")
+MAX_MANGA_PAGES = 120
+MAX_IMAGE_BYTES = 35 * 1024 * 1024
+MAX_REDIRECTS = 5
+
+MANGA_DEFAULT_PROMPT = (
+    "Colorize this black and white manga page into a clean modern anime/manhwa color style. "
+    "Preserve the original line art, panel layout, speech bubbles, text, character identity, "
+    "clothing, pose, anatomy, camera angle, background, and composition. Do not crop, redraw, "
+    "remove, or add panels. Keep all text readable and unchanged. Apply natural skin tones, "
+    "soft shadows, vibrant but controlled colors, clean cel shading, subtle highlights, detailed "
+    "hair coloring, and harmonious background colors. Maintain the original manga style and avoid "
+    "overpainting the ink lines. Do not sexualize the characters, do not add nudity, do not change "
+    "clothing coverage, and do not alter the body proportions."
+)
+
+MANGA_NEGATIVE_PROMPT = (
+    "worst quality, low quality, blurry, cropped, extra panels, missing panels, unreadable text, "
+    "changed text, watermark, signature, deformed anatomy, extra limbs, missing limbs, overpainted "
+    "lineart, messy colors, nudity, sexualized, changed outfit, changed pose"
+)
+
+REQUEST_HEADERS = {
+    "User-Agent": "Mozilla/5.0",
+    "Referer": "https://hmanga.asia/",
+}
+
+
+class MangaColorizerError(ValueError):
+    pass
+
+
+def _normalize_host(hostname):
+    if not hostname:
+        return ""
+    return hostname.strip().strip("[]").lower().rstrip(".")
+
+
+def _is_blocked_host(hostname):
+    host = _normalize_host(hostname)
+    if host in {"localhost", "local", "0", "0.0.0.0"}:
+        return True
+    try:
+        ip = ipaddress.ip_address(host)
+    except ValueError:
+        return False
+    return any(
+        [
+            ip.is_loopback,
+            ip.is_private,
+            ip.is_link_local,
+            ip.is_multicast,
+            ip.is_reserved,
+            ip.is_unspecified,
+        ]
+    )
+
+
+def _is_allowed_domain(hostname):
+    host = _normalize_host(hostname)
+    return any(host == domain or host.endswith(f".{domain}") for domain in ALLOWED_DOMAINS)
+
+
+def sanitize_url(url: str) -> str:
+    if not url or not str(url).strip():
+        raise MangaColorizerError("URL invalida: pega una URL http/https.")
+
+    parsed = urlparse(str(url).strip())
+    if parsed.scheme not in {"http", "https"}:
+        raise MangaColorizerError("URL invalida: solo se permite http o https.")
+    if parsed.username or parsed.password:
+        raise MangaColorizerError("URL invalida: no uses credenciales embebidas.")
+
+    host = _normalize_host(parsed.hostname)
+    if _is_blocked_host(host):
+        raise MangaColorizerError("URL bloqueada por seguridad.")
+    if not _is_allowed_domain(host):
+        allowed = ", ".join(ALLOWED_DOMAINS)
+        raise MangaColorizerError(f"Dominio no permitido. Dominios permitidos: {allowed}.")
+
+    if parsed.port and parsed.port not in {80, 443}:
+        raise MangaColorizerError("URL invalida: puerto no permitido.")
+
+    path = parsed.path or "/"
+    netloc = host
+    if parsed.port:
+        netloc = f"{netloc}:{parsed.port}"
+    return urlunparse((parsed.scheme, netloc, path, "", parsed.query, parsed.fragment))
+
+
+def get_manga_slug(url: str) -> str:
+    clean_url = sanitize_url(url)
+    parsed = urlparse(clean_url)
+    parts = [part for part in unquote(parsed.path).split("/") if part]
+    base = parts[-1] if parts else "manga"
+    slug = re.sub(r"[^a-zA-Z0-9]+", "-", base).strip("-").lower() or "manga"
+    slug = slug[:80].strip("-") or "manga"
+    short_hash = hashlib.sha256(clean_url.encode("utf-8")).hexdigest()[:8]
+    return f"{slug}-{short_hash}"
+
+
+def _looks_like_blocked_page(html: str) -> bool:
+    lowered = html.lower()
+    hard_markers = [
+        "cf-chl",
+        "cloudflare",
+        "turnstile",
+        "captcha",
+        "verify you are human",
+        "attention required",
+        "just a moment",
+        "please enable cookies",
+    ]
+    if any(marker in lowered for marker in hard_markers):
+        return True
+    has_login_form = "<form" in lowered and ("login" in lowered or "password" in lowered)
+    has_manga_images = "/wp-content/uploads/mangas/" in lowered
+    return has_login_form and not has_manga_images
+
+
+def _get_with_validated_redirects(url, *, headers=None, stream=False, timeout=20):
+    current_url = sanitize_url(url)
+    request_headers = headers or REQUEST_HEADERS
+    for _ in range(MAX_REDIRECTS + 1):
+        response = requests.get(
+            current_url,
+            headers=request_headers,
+            timeout=timeout,
+            allow_redirects=False,
+            stream=stream,
+        )
+        if response.is_redirect or response.is_permanent_redirect:
+            location = response.headers.get("Location")
+            response.close()
+            if not location:
+                raise MangaColorizerError("Redireccion sin destino valido.")
+            current_url = sanitize_url(urljoin(current_url, location))
+            continue
+        return response, current_url
+    raise MangaColorizerError("Demasiadas redirecciones.")
+
+
+def fetch_manga_html(url: str) -> str:
+    clean_url = sanitize_url(url)
+    try:
+        response, _ = _get_with_validated_redirects(clean_url, headers=REQUEST_HEADERS, timeout=20)
+    except requests.Timeout as exc:
+        raise MangaColorizerError("Timeout al descargar la pagina del manga.") from exc
+    except requests.RequestException as exc:
+        raise MangaColorizerError(f"Error de red al descargar la pagina: {exc}") from exc
+
+    try:
+        if response.status_code == 403:
+            raise MangaColorizerError("El sitio devolvio 403. Puede requerir login, captcha o bloqueo.")
+        if response.status_code == 404:
+            raise MangaColorizerError("El sitio devolvio 404. Revisa que la URL exista.")
+        if response.status_code >= 400:
+            raise MangaColorizerError(f"El sitio devolvio HTTP {response.status_code}.")
+
+        html = response.text or ""
+        if not html.strip():
+            raise MangaColorizerError("La pagina descargada esta vacia.")
+        if _looks_like_blocked_page(html):
+            raise MangaColorizerError("La pagina parece estar protegida por login, captcha o Cloudflare.")
+        return html
+    finally:
+        response.close()
+
+
+def _candidate_image_values(img):
+    for attr in ("src", "data-src", "data-lazy-src", "data-original"):
+        value = img.get(attr)
+        if value:
+            yield value.strip()
+
+
+def _natural_image_sort_key(url):
+    parsed = urlparse(url)
+    path = unquote(parsed.path)
+    dirname = path.rsplit("/", 1)[0]
+    filename = path.rsplit("/", 1)[-1]
+    stem = filename.rsplit(".", 1)[0]
+    numbers = [int(num) for num in re.findall(r"\d+", stem)]
+    return (dirname, 0 if numbers else 1, numbers, filename.lower())
+
+
+def extract_manga_image_urls(html: str, base_url: str) -> list[str]:
+    if not html or not html.strip():
+        return []
+
+    clean_base_url = sanitize_url(base_url)
+    soup = BeautifulSoup(html, "html.parser")
+    candidates = []
+    for selector in ("img.img-fluid.no-lazy", "div[id] img", "img"):
+        candidates.extend(soup.select(selector))
+
+    seen = set()
+    image_urls = []
+    for img in candidates:
+        for raw_value in _candidate_image_values(img):
+            if not raw_value or raw_value.startswith("data:"):
+                continue
+            try:
+                absolute_url = sanitize_url(urljoin(clean_base_url, raw_value))
+            except MangaColorizerError:
+                continue
+            parsed = urlparse(absolute_url)
+            path_lower = parsed.path.lower()
+            if "/wp-content/uploads/mangas/" not in path_lower:
+                continue
+            if not path_lower.endswith(MANGA_IMAGE_EXTENSIONS):
+                continue
+            if absolute_url in seen:
+                continue
+            seen.add(absolute_url)
+            image_urls.append(absolute_url)
+
+    return sorted(image_urls, key=_natural_image_sort_key)
+
+
+def download_manga_images(image_urls: list[str], cache_dir: Path, referer: str) -> list[str]:
+    cache_dir = Path(cache_dir)
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    local_paths = []
+
+    for index, image_url in enumerate(image_urls, start=1):
+        clean_url = sanitize_url(image_url)
+        parsed = urlparse(clean_url)
+        ext = Path(parsed.path).suffix.lower()
+        if ext not in MANGA_IMAGE_EXTENSIONS:
+            ext = ".webp"
+        target_path = cache_dir / f"{index:03d}{ext}"
+        local_paths.append(str(target_path))
+
+        if target_path.exists() and target_path.stat().st_size > 0:
+            continue
+
+        headers = dict(REQUEST_HEADERS)
+        headers["Referer"] = sanitize_url(referer)
+        try:
+            response, _ = _get_with_validated_redirects(clean_url, headers=headers, stream=True, timeout=30)
+        except requests.Timeout as exc:
+            raise MangaColorizerError(f"Timeout al descargar imagen {index:03d}.") from exc
+        except requests.RequestException as exc:
+            raise MangaColorizerError(f"Error de red al descargar imagen {index:03d}: {exc}") from exc
+
+        try:
+            if response.status_code >= 400:
+                raise MangaColorizerError(f"HTTP {response.status_code} al descargar imagen {index:03d}.")
+            content_length = int(response.headers.get("Content-Length") or 0)
+            if content_length > MAX_IMAGE_BYTES:
+                raise MangaColorizerError(f"Imagen {index:03d} excede el limite de tamano.")
+
+            tmp_path = target_path.with_suffix(target_path.suffix + ".part")
+            total_bytes = 0
+            with tmp_path.open("wb") as handle:
+                for chunk in response.iter_content(chunk_size=1024 * 256):
+                    if not chunk:
+                        continue
+                    total_bytes += len(chunk)
+                    if total_bytes > MAX_IMAGE_BYTES:
+                        tmp_path.unlink(missing_ok=True)
+                        raise MangaColorizerError(f"Imagen {index:03d} excede el limite de tamano.")
+                    handle.write(chunk)
+            tmp_path.replace(target_path)
+        finally:
+            response.close()
+
+    return local_paths
+
+
+def extract_and_cache_manga(url: str, max_pages: int):
+    clean_url = sanitize_url(url)
+    try:
+        page_limit = int(max_pages)
+    except (TypeError, ValueError):
+        page_limit = 10
+    page_limit = max(1, min(page_limit, MAX_MANGA_PAGES))
+
+    html = fetch_manga_html(clean_url)
+    image_urls = extract_manga_image_urls(html, clean_url)
+    if not image_urls:
+        raise MangaColorizerError("No se encontraron imagenes de manga en la pagina.")
+
+    limited_urls = image_urls[:page_limit]
+    slug = get_manga_slug(clean_url)
+    manga_root = MANGA_CACHE_ROOT / slug
+    original_dir = manga_root / "original"
+    colorized_dir = manga_root / "colorized"
+    colorized_dir.mkdir(parents=True, exist_ok=True)
+    original_paths = download_manga_images(limited_urls, original_dir, clean_url)
+
+    metadata = {
+        "url": clean_url,
+        "slug": slug,
+        "original_dir": str(original_dir),
+        "colorized_dir": str(colorized_dir),
+        "image_urls": limited_urls,
+        "original_paths": original_paths,
+    }
+    status = (
+        f"Listo: {len(original_paths)} imagen(es) en cache. "
+        f"Detectadas en total: {len(image_urls)}. Solo usar con contenido propio o con permiso."
+    )
+    return status, original_paths, json.dumps(metadata, indent=2)
+
+
+def load_manga_metadata(metadata_json: str):
+    if not metadata_json or not str(metadata_json).strip():
+        raise MangaColorizerError("Primero extrae imagenes para crear metadata.")
+    try:
+        metadata = json.loads(metadata_json)
+    except json.JSONDecodeError as exc:
+        raise MangaColorizerError("Metadata invalida. Vuelve a extraer las imagenes.") from exc
+    original_paths = metadata.get("original_paths") or []
+    if not original_paths:
+        raise MangaColorizerError("No hay imagenes en cache.")
+    return metadata
+
+
+def get_colorized_path(original_path: str) -> Path:
+    source = Path(original_path)
+    colorized_dir = source.parent.parent / "colorized"
+    colorized_dir.mkdir(parents=True, exist_ok=True)
+    return colorized_dir / f"{source.stem}_colorized.png"
+
+
+def make_colorized_zip(colorized_paths: list[str]) -> str:
+    valid_paths = [Path(path) for path in colorized_paths if path and Path(path).exists()]
+    if not valid_paths:
+        raise MangaColorizerError("No hay imagenes coloreadas para comprimir.")
+
+    zip_path = valid_paths[0].parent / "colorized_manga.zip"
+    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zip_file:
+        for path in valid_paths:
+            zip_file.write(path, arcname=path.name)
+    return str(zip_path)
+
+
+def sample_extract_manga_image_urls_test() -> list[str]:
+    sample_html = """
+    <div id="1" style="height: 1280px;">
+      <img class="img-fluid no-lazy" src="https://hmanga.asia/wp-content/uploads/mangas/methonium-porque-eres-tu-enano/02.webp">
+    </div>
+    """
+    return extract_manga_image_urls(sample_html, "https://hmanga.asia/porque-eres-tu-enano/#all")

requirements.txt

@@ -11,4 +11,6 @@ hf_xet
 gradio
 torch==2.11.0
 numpy
-av
+av
+beautifulsoup4
+requests