Upload 5 files

README.md

@@ -1,14 +1,42 @@
----
-title: Extrator Pdf Web
-emoji: 📈
-colorFrom: pink
-colorTo: purple
-sdk: gradio
-sdk_version: 5.44.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: Converte PDFs em imagens por página
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Extrator de Imagens de PDF (Gradio)
+
+Converta um ou vários **PDFs** (inclusive dentro de **.zip**) em **imagens por página**. Interface simples, tema escuro e saída em **galeria** + **ZIP**.
+
+> Tecnologias: **Python**, **Gradio 4**, **pdf2image** (Poppler), **Pillow**.
+
+## Demonstração
+- **App online (HF Space):** _adicione o link do seu Space aqui_
+- **Repositório (código):** _este repositório_
+
+## Recursos
+- ✅ Suporta PDF *ou* `.zip` com vários PDFs.
+- ✅ Dois modos: **todas as páginas** ou **páginas específicas** (ex.: `3 - 5 - 10`).
+- ✅ Gera **galeria** para pré-visualizar e **ZIP** com todas as imagens.
+- ✅ Formatos: **JPEG**, **PNG**, **BMP**, **ICO**.
+
+## Como funciona (resumo)
+- Usa **pdf2image** (Poppler) para rasterizar cada página do PDF.
+- Salva as imagens no formato escolhido e empacota tudo em **ZIP**.
+- Mostra prévias na **Gallery** do Gradio.
+
+## Instalação local
+Requisitos: Python 3.10+.
+
+1. **(Windows) Poppler**  
+   Baixe o Poppler (ex.: `poppler-XX`) e aponte para `...\Library\bin` dentro do `processador.py` (constante `POPPLER_PATH`).  
+   No Linux/macOS, não precisa setar (usa do sistema).
+
+2. **Instalar dependências**
+   ```bash
+   python -m venv .venv
+   # Windows
+   .venv\Scripts\activate
+   # macOS/Linux
+   # source .venv/bin/activate
+
+   python -m pip install -U pip
+   python -m pip install -r requirements.txt
+
+
+2. **Executar**
+   python app.py

app.py

@@ -0,0 +1,194 @@
+# app.py — versão com tema/estilo padronizado
+import gradio as gr
+import tempfile
+from pathlib import Path
+from processador import processar_misto  # pipeline que aceita PDF(s) e ZIP(s)
+
+# -------------------- Tema + CSS do portfólio --------------------
+CUSTOM_CSS = """
+:root{
+  --bg:#000;           /* fundo geral */
+  --panel:#0b0b0b;     /* blocos/painéis */
+  --panel-2:#0e0e0e;   /* inputs/dropdowns */
+  --border:#2a2a2a;    /* borda padrão */
+  --text:#e5e5e5;      /* texto branco suave */
+  --muted:#a3a3a3;     /* texto secundário */
+  --accent:#6ee7b7;    /* cor do foco/seleção (verde menta) */
+}
+
+/* fonte geral (system UI) */
+html, body, .gradio-container {
+  background: var(--bg)!important;
+  color: var(--text)!important;
+  font-family: ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, Inter, "Helvetica Neue", Arial, "Noto Sans", "Liberation Sans", sans-serif !important;
+}
+
+/* blocos/painéis */
+.gradio-container .block,
+.gradio-container .gr-box,
+.gradio-container .gr-panel {
+  background: var(--panel) !important;
+  border: 1px solid var(--border) !important;
+  border-radius: 12px !important;
+}
+
+/* remover o bloco atrás do TÍTULO (qualquer .block que contenha h1) */
+.gradio-container .block:has(h1){
+  background: transparent !important;
+  border: 0 !important;
+  box-shadow: none !important;
+}
+
+/* botões estilo "pílula" */
+button, .gr-button{
+  border-radius: 9999px !important;
+  border: 1px solid var(--border) !important;
+  background: var(--panel-2) !important;
+}
+button:hover{ border-color:#4a4a4a !important; }
+
+/* inputs/textarea/file/dropdown: mesmo tom escuro */
+input, textarea, select,
+.gradio-container .gr-textbox,
+.gradio-container .gr-input,
+.gradio-container .gradio-dropdown,
+.gradio-container .gr-file,
+.gradio-container .gr-file-download,
+.gradio-container .gr-select-container,
+.gradio-container .wrap .items-center select {
+  background: var(--panel-2) !important;
+  border: 1px solid var(--border) !important;
+  color: var(--text) !important;
+  border-radius: 12px !important;
+}
+
+/* opções do select */
+select > option { background: var(--panel-2); color: var(--text); }
+
+/* foco/seleção visível (inputs, selects, file, etc.) */
+input:focus, textarea:focus, select:focus,
+.gradio-container .gr-textbox:focus-within,
+.gradio-container .gr-input:focus-within,
+.gradio-container .gradio-dropdown:focus-within,
+.gradio-container .gr-file:focus-within,
+.gradio-container .gr-select-container:focus-within {
+  outline: none !important;
+  border-color: var(--accent) !important;
+  box-shadow: 0 0 0 2px rgba(110,231,183,0.18) !important; /* halo */
+}
+
+/* uploader QUADRADO (remove círculo/arredondamento exagerado) */
+.gradio-container [data-testid="file"] .rounded-full,
+.gradio-container [data-testid="files"] .rounded-full { border-radius:12px !important; }
+.gradio-container [data-testid="file"] [class*="aspect-"],
+.gradio-container [data-testid="files"] [class*="aspect-"] { aspect-ratio:auto !important; }
+.gradio-container [data-testid="file"] .h-full.w-full,
+.gradio-container [data-testid="files"] .h-full.w-full { border-radius:12px !important; }
+
+/* gallery e saídas de arquivo */
+.gradio-container .gr-gallery,
+.gradio-container .gr-file-download{
+  background: var(--panel-2) !important;
+  border: 1px solid var(--border) !important;
+  border-radius: 12px !important;
+}
+
+/* badges/labels */
+.badge, .token { background:#0f0f0f !important; border-radius:9999px !important; }
+
+.gradio-container .fixed.bottom-0,
+.gradio-container div[class*="fixed"][class*="bottom-0"],
+.gradio-container footer,
+body > div.fixed.bottom-0,
+div.fixed.bottom-0 {
+  display: none !important;
+  visibility: hidden !important;
+  height: 0 !important;
+  overflow: hidden !important;
+  pointer-events: none !important;
+}
+"""
+
+THEME = gr.themes.Soft(primary_hue="zinc", neutral_hue="zinc")
+
+# -----------------------------------------------------------
+
+# Converte buffers em arquivos temporários para a Gallery
+def _galeria_temp(imagens, formato):
+    gal = []
+    ext = "ico" if formato == "ico" else formato.lower()
+    for legenda, img_io in imagens:
+        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=f".{ext}")
+        tmp.write(img_io.read())
+        tmp.close()
+        img_io.seek(0)
+        gal.append((tmp.name, legenda))
+    return gal
+
+# Função chamada pelo submit
+def processar(arquivos, modo, paginas_input, formato_opcao):
+    if not arquivos:
+        return "Por favor, envie ao menos um PDF (ou .zip contendo PDFs).", None
+
+    # gr.Files pode vir string ou lista:
+    paths = [Path(arquivos)] if isinstance(arquivos, str) else [Path(p) for p in arquivos]
+
+    # Do dropdown “jpeg [Recomendado …]” pegamos só o formato:
+    formato = formato_opcao.split(" [")[0].lower()
+
+    # Interpreta páginas quando necessário
+    paginas = None
+    if modo == "Extrair páginas específicas":
+        try:
+            paginas = [int(p.strip()) for p in paginas_input.split("-") if p.strip().isdigit()]
+            if not paginas:
+                return "Nenhuma página válida foi informada.", None
+        except Exception as e:
+            return f"Erro ao interpretar as páginas: {e}", None
+
+    try:
+        imagens, zip_path = processar_misto(paths, modo, paginas, formato)
+    except Exception as e:
+        return f"Erro ao processar: {e}", None
+
+    galeria = _galeria_temp(imagens, formato)
+    return galeria, zip_path
+
+FORMATOS = [
+    "  jpeg [Recomendado - compacto e boa qualidade]",
+    "  png [Alta qualidade, suporta transparência]",
+    "  bmp [Sem compressão - ideal para edição bruta]",
+    "  ico [Favicon para sites, atalhos e apps]",
+]
+
+demo = gr.Interface(
+    fn=processar,
+    inputs=[
+        gr.Files(
+            label="Envie PDF(s) ou .zip com PDFs",
+            file_count="multiple",
+            file_types=[".pdf", ".zip"],
+        ),
+        gr.Radio(
+            ["Extrair todas as páginas", "Extrair páginas específicas"],
+            label="Modo",
+            value="Extrair todas as páginas",
+        ),
+        gr.Textbox(
+            label="Páginas (se usar 'Específicas')",
+            placeholder="Ex.: 3 - 5 - 10",
+        ),
+        gr.Dropdown(choices=FORMATOS, value=FORMATOS[0], label="Formato das imagens"),
+    ],
+    outputs=[
+        gr.Gallery(label="Imagens"),
+        gr.File(label="ZIP com as imagens"),
+    ],
+    title="Extrator de Imagens de PDF",
+    allow_flagging="never",
+    theme=THEME,
+    css=CUSTOM_CSS,
+)
+
+if __name__ == "__main__":
+    demo.launch()

packages.txt

@@ -0,0 +1 @@
+poppler-utils

processador.py

@@ -0,0 +1,195 @@
+# 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

requirements.txt

@@ -0,0 +1,3 @@
+gradio
+pdf2image
+pillow