Update processador.py

processador.py

@@ -1,195 +1,101 @@
-# processador.py
-from pdf2image import convert_from_bytes
-from typing import List, Tuple, Optional
-from pathlib import Path
-import io
-import shutil
-import tempfile
-import platform
-import zipfile
-import time
-
-# --- Poppler ---
-# Windows costuma precisar do caminho do Poppler; no Hugging Face (Linux) já está no PATH.
-if platform.system() == "Windows":
-    POPPLER_PATH = r"C:\poppler-25.07.0\Library\bin"  # ajuste se necessário no seu PC
-else:
-    POPPLER_PATH = None  # no HF não precisa
-
-def _kwargs_poppler():
-    """Monta kwargs para o pdf2image dependendo da plataforma."""
-    return {"poppler_path": POPPLER_PATH} if POPPLER_PATH else {}
-
-# ------------------------------------------------------------
-# Helpers de conversão por PDF (mantidos para reuso)
-# ------------------------------------------------------------
-def extrair_todas_as_paginas(
-    pdf_bytes: bytes,
-    nome_pdf: str,
-    formato: str = "jpeg",
-    dpi: int = 300
-) -> Tuple[List[Tuple[int, io.BytesIO]], str]:
-    """
-    Converte TODAS as páginas do PDF para o formato escolhido.
-    Retorna lista [(numero_pagina, buffer), ...] e caminho de um ZIP contendo SÓ este PDF.
-    (No fluxo 'misto', o ZIP final será refeito juntando PDFs.)
-    """
-    pil_pages = convert_from_bytes(pdf_bytes, dpi=dpi, fmt="ppm", **_kwargs_poppler())
-
-    resultado: List[Tuple[int, io.BytesIO]] = []
-    for i, pil_img in enumerate(pil_pages, start=1):
-        buf = io.BytesIO()
-        img_rgb = pil_img.convert("RGB")
-        if formato.lower() == "ico":
-            img_rgb.save(buf, format="ICO")
-        else:
-            img_rgb.save(buf, format=formato.upper())
-        buf.seek(0)
-        resultado.append((i, buf))
-
-    # ZIP individual (não usado no 'misto', mas mantemos por compatibilidade)
-    zip_path = _salvar_e_zipar(resultado, nome_pdf, formato)
-    return resultado, zip_path
-
-def extrair_paginas_especificas(
-    pdf_bytes: bytes,
-    nome_pdf: str,
-    paginas: List[int],
-    formato: str = "jpeg",
-    dpi: int = 300
-) -> Tuple[List[Tuple[int, io.BytesIO]], str]:
-    """
-    Converte apenas páginas específicas (ex.: [3, 5, 10]).
-    Retorna lista [(numero_pagina, buffer), ...] e caminho de um ZIP só deste PDF.
-    """
-    paginas_ord = sorted(set(paginas))
-    first, last = min(paginas_ord), max(paginas_ord)
-
-    pil_interval = convert_from_bytes(
-        pdf_bytes, dpi=dpi, first_page=first, last_page=last, fmt="ppm", **_kwargs_poppler()
-    )
-
-    resultado: List[Tuple[int, io.BytesIO]] = []
-    for pagina in paginas_ord:
-        idx = pagina - first  # índice relativo dentro do intervalo
-        buf = io.BytesIO()
-        img_rgb = pil_interval[idx].convert("RGB")
-        if formato.lower() == "ico":
-            img_rgb.save(buf, format="ICO")
-        else:
-            img_rgb.save(buf, format=formato.upper())
-        buf.seek(0)
-        resultado.append((pagina, buf))
-
-    zip_path = _salvar_e_zipar(resultado, nome_pdf, formato)
-    return resultado, zip_path
-
-# ------------------------------------------------------------
-# ZIP utilitário (para um único PDF) — usado nos helpers acima
-# ------------------------------------------------------------
-def _salvar_e_zipar(
-    imagens: List[Tuple[int, io.BytesIO]],
-    nome_pdf: str,
-    formato: str
-) -> str:
-    temp_dir = tempfile.mkdtemp()
-    temp_path = Path(temp_dir)
-    ext = "ico" if formato == "ico" else formato.lower()
-
-    for pagina, img_io in imagens:
-        filename = f"{nome_pdf}_pagina_{pagina}.{ext}"
-        (temp_path / filename).write_bytes(img_io.getvalue())
-        img_io.seek(0)
-
-    base_name = Path.cwd() / nome_pdf  # zip ficará como <nome_pdf>.zip
-    zip_path = shutil.make_archive(str(base_name), "zip", temp_dir)
-    return zip_path
-
-# ------------------------------------------------------------
-# Coleta PDFs a partir de paths “mistos”: PDFs diretos e PDFs dentro de .zip
-# ------------------------------------------------------------
-def _coletar_pdfs(paths: List[Path]) -> List[Tuple[str, bytes]]:
-    """
-    Recebe caminhos de arquivos enviados (podem ser PDFs ou .zip).
-    Retorna uma lista de tuplas (nome_base_pdf, pdf_bytes) para cada PDF encontrado.
-    - Se for .zip, itera pelos itens *.pdf (case-insensitive) e lê os bytes sem extrair em disco.
-    - Se for .pdf, lê direto do disco.
-    """
-    coletados: List[Tuple[str, bytes]] = []
-    for p in paths:
-        suf = p.suffix.lower()
-        if suf == ".pdf":
-            coletados.append((p.stem, p.read_bytes()))
-        elif suf == ".zip":
-            with zipfile.ZipFile(p, "r") as zf:
-                for zi in zf.infolist():
-                    if zi.is_dir():
-                        continue
-                    if zi.filename.lower().endswith(".pdf"):
-                        base = Path(zi.filename).stem
-                        with zf.open(zi, "r") as f:
-                            coletados.append((base, f.read()))
-        else:
-            # Ignora outros tipos (p. ex., .txt) para este app
-            continue
-    return coletados
-
-# ------------------------------------------------------------
-# Pipeline “mistão”: processa 1..N PDFs (e PDFs dentro de .zip) de uma vez
-# ------------------------------------------------------------
-def processar_misto(
-    paths: List[Path],
-    modo: str,
-    paginas: Optional[List[int]],
-    formato: str
-) -> Tuple[List[Tuple[str, io.BytesIO]], str]:
-    """
-    Processa tudo em uma passada:
-    - Lê todos os PDFs enviados (diretos e dentro de .zip)
-    - Converte páginas segundo 'modo' e 'paginas'
-    - Escreve TODAS as imagens em uma mesma pasta temporária com nomes:
-        NomeDoPDF_pagina_X.<ext>
-    - Gera UM único ZIP com todas as imagens
-    - Retorna:
-        imagens_galeria -> [(legenda, BytesIO), ...]
-        zip_path        -> caminho do ZIP único
-    """
-    pdfs = _coletar_pdfs(paths)
-    if not pdfs:
-        raise RuntimeError("Nenhum PDF encontrado nos arquivos enviados.")
-
-    # Pasta temporária na qual vamos gravar TUDO
-    temp_dir = tempfile.mkdtemp()
-    temp_path = Path(temp_dir)
-    ext = "ico" if formato == "ico" else formato.lower()
-
-    imagens_galeria: List[Tuple[str, io.BytesIO]] = []
-
-    for base, pdf_bytes in pdfs:
-        if modo == "Extrair todas as páginas":
-            lista_paginas, _ = extrair_todas_as_paginas(pdf_bytes, base, formato)
-        elif modo == "Extrair páginas específicas":
-            if not paginas:
-                raise RuntimeError("Nenhuma página válida foi informada.")
-            lista_paginas, _ = extrair_paginas_especificas(pdf_bytes, base, paginas, formato)
-        else:
-            raise RuntimeError("Modo inválido.")
-
-        # Grava no diretório TEMP (um único ZIP final) e prepara galeria
-        for pagina, img_io in lista_paginas:
-            # nome do arquivo no ZIP final
-            filename = f"{base}_pagina_{pagina}.{ext}"
-            (temp_path / filename).write_bytes(img_io.getvalue())
-            img_io.seek(0)
-
-            # legenda para galeria
-            imagens_galeria.append((f"{base} — pág {pagina}", img_io))
-
-    # Nome do ZIP: se for 1 PDF, usa o nome dele; senão, nome genérico com timestamp
-    if len(pdfs) == 1:
-        base_zip = pdfs[0][0]
-    else:
-        base_zip = f"imagens_extraidas_{time.strftime('%Y%m%d-%H%M%S')}"
-
-    zip_path = shutil.make_archive(str(Path.cwd() / base_zip), "zip", temp_dir)
-    return imagens_galeria, zip_path
+# processador.py
+from __future__ import annotations
+from pathlib import Path
+from typing import List, Optional, Tuple
+import platform, shutil, tempfile, zipfile
+
+from pdf2image import convert_from_path, convert_from_bytes
+
+IS_WINDOWS = platform.system() == "Windows"
+# No Windows você aponta abaixo; no Linux (Hugging Face) deixe como None
+POPPLER_PATH = r"C:\poppler-25.07.0\Library\bin" if IS_WINDOWS else None
+
+
+def _ensure_poppler() -> None:
+    """Garante que o Poppler está disponível no ambiente."""
+    if IS_WINDOWS:
+        p = Path(POPPLER_PATH or "")
+        if not p.exists():
+            raise RuntimeError(
+                "Poppler não encontrado. Ajuste POPPLER_PATH para ...\\poppler-XX\\Library\\bin"
+            )
+    else:
+        # No Linux (HF) esperamos 'pdftoppm' no PATH via packages.txt (poppler-utils)
+        if shutil.which("pdftoppm") is None:
+            raise RuntimeError(
+                "pdftoppm não encontrado. No Hugging Face inclua 'packages.txt' com 'poppler-utils'."
+            )
+
+
+def _ext(formato: str) -> str:
+    """Normaliza a extensão."""
+    return "jpg" if formato.lower() in ("jpeg", "jpg") else formato.lower()
+
+
+def _convert_bytes(data: bytes, formato: str, paginas: Optional[List[int]]):
+    fmt = _ext(formato)
+    if not paginas:
+        return convert_from_bytes(data, dpi=200, fmt=fmt, poppler_path=POPPLER_PATH)
+    # páginas específicas: chamamos 1 a 1
+    out = []
+    for p in paginas:
+        img = convert_from_bytes(
+            data, dpi=200, fmt=fmt, first_page=p, last_page=p, poppler_path=POPPLER_PATH
+        )[0]
+        out.append(img)
+    return out
+
+
+def _convert_path(pdf_path: Path, formato: str, paginas: Optional[List[int]]):
+    fmt = _ext(formato)
+    if not paginas:
+        return convert_from_path(str(pdf_path), dpi=200, fmt=fmt, poppler_path=POPPLER_PATH)
+    out = []
+    for p in paginas:
+        img = convert_from_path(
+            str(pdf_path), dpi=200, fmt=fmt, first_page=p, last_page=p, poppler_path=POPPLER_PATH
+        )[0]
+        out.append(img)
+    return out
+
+
+def processar_misto(
+    paths: List[Path], modo: str, paginas: Optional[List[int]], formato: str
+) -> Tuple[List[Tuple[str, str]], str]:
+    """
+    paths: lista de caminhos (PDFs ou ZIPs contendo PDFs)
+    modo:   "Extrair todas as páginas" | "Extrair páginas específicas"
+    paginas: lista de ints (ou None) quando modo = específicas
+    formato: "jpeg" | "png" | "bmp" | "ico"
+    Retorna: [(caminho_imagem_temp, legenda)], caminho_zip_temp
+    """
+    _ensure_poppler()
+
+    usar_paginas = paginas if "Específicas" in modo else None
+    ext = _ext(formato)
+
+    galeria: List[Tuple[str, str]] = []
+    tmp_zip = tempfile.NamedTemporaryFile(delete=False, suffix=".zip")
+    with zipfile.ZipFile(tmp_zip.name, "w", compression=zipfile.ZIP_DEFLATED) as zout:
+        for path in paths:
+            if path.suffix.lower() == ".zip":
+                with zipfile.ZipFile(path, "r") as zin:
+                    for info in zin.infolist():
+                        if info.filename.lower().endswith(".pdf"):
+                            data = zin.read(info.filename)
+                            images = _convert_bytes(data, formato, usar_paginas)
+                            stem_zip = Path(info.filename).stem.replace("/", "_")
+                            for i, img in enumerate(images, 1):
+                                img_tmp = tempfile.NamedTemporaryFile(delete=False, suffix=f".{ext}")
+                                img.save(img_tmp.name)
+                                galeria.append((img_tmp.name, f"{stem_zip} — p{i}"))
+                                zout.write(img_tmp.name, arcname=f"{stem_zip}_p{i}.{ext}")
+            else:
+                images = _convert_path(path, formato, usar_paginas)
+                for i, img in enumerate(images, 1):
+                    img_tmp = tempfile.NamedTemporaryFile(delete=False, suffix=f".{ext}")
+                    img.save(img_tmp.name)
+                    galeria.append((img_tmp.name, f"{path.stem} — p{i}"))
+                    zout.write(img_tmp.name, arcname=f"{path.stem}_p{i}.{ext}")
+
+    return galeria, tmp_zip.name