Spaces:

13ze
/

complex-html-to-markdown-llm

Sleeping

App Files Files Community

13ze commited on Apr 17, 2025

Commit

ccfa465

verified ·

1 Parent(s): dd5deef

Update app.py

Browse files

Files changed (1) hide show

app.py +103 -64

app.py CHANGED Viewed

@@ -1,15 +1,14 @@
 import gradio as gr
 import html2text
 from bs4 import BeautifulSoup
-import logging # Para mensagens informativas
-# Configurar logging básico para ver qual contêiner foi escolhido
 logging.basicConfig(level=logging.INFO)
-def extrair_limpar_html(html_bruto):
     """
-    Tenta extrair o conteúdo principal do HTML e depois o limpa,
-    removendo tags e atributos indesejados.
     :param html_bruto: String contendo o código HTML original.
     :return: String contendo o HTML limpo e focado no conteúdo principal.
@@ -21,81 +20,105 @@ def extrair_limpar_html(html_bruto):
     target_element = None
     # --- 1. Tentar Extrair o Conteúdo Principal ---
-    # Lista de seletores CSS em ordem de preferência
-    # (Mais específicos primeiro)
     main_content_selectors = [
         'main',                 # <main> tag
-        'article',              # <article> tag (primeiro encontrado)
         '[role="main"]',        # role="main" attribute
-        '#content',             # ID #content
-        '#main',                # ID #main
-        '.main-content',        # Classe .main-content
         '.post',                # Classe .post
-        '.entry-content',       # Classe .entry-content (comum em blogs)
-        '.post-body',           # Classe .post-body
         '.article-body',        # Classe .article-body
         '#bodyContent',         # ID específico da Wikipedia
-        # Adicione outros seletores comuns se necessário
     ]
     for selector in main_content_selectors:
-        # select_one retorna o primeiro elemento que corresponde ao seletor
         potential_match = soup.select_one(selector)
         if potential_match:
-            target_element = potential_match
-            logging.info(f"Conteúdo principal identificado usando o seletor: '{selector}'")
-            break # Para ao encontrar o primeiro match da lista
-    # Fallback: Se nenhum seletor específico funcionou, usar o <body>
     if not target_element:
         if soup.body:
             target_element = soup.body
             logging.info("Nenhum contêiner principal específico encontrado. Usando <body> como fallback.")
         else:
-            # Caso extremo: HTML sem body, usa o soup inteiro
             target_element = soup
             logging.warning("Nenhum contêiner principal ou <body> encontrado. Processando todo o input.")
-    # Se target_element for None (caso extremo), retorna vazio
     if not target_element:
          return ""
-    # --- 2. Limpar o Elemento Selecionado ---
-    # Agora aplicamos a limpeza *dentro* do target_element
-    # Tags para remover completamente (script, style, etc.)
-    tags_para_remover = ['script', 'style', 'header', 'footer', 'nav', 'aside', 'form', 'meta', 'link', 'noscript', 'button', 'input', 'select', 'textarea', 'label']
     for tag in target_element.find_all(tags_para_remover):
         tag.decompose()
-    # Tags permitidas e atributos permitidos (ajuste conforme necessário)
     tags_permitidas = {
         'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'br', 'a', 'strong', 'b',
         'em', 'i', 'u', 's', 'strike', 'del', 'ul', 'ol', 'li', 'img',
-        'table', 'thead', 'tbody', 'tr', 'th', 'td', 'blockquote', 'pre', 'code'
-        # Removi html, head, body, title daqui, pois estamos focando no conteúdo
     }
     atributos_permitidos = {
         'a': ['href', 'title'],
         'img': ['src', 'alt', 'title', 'width', 'height'],
-         # Remover '*' para ser mais restritivo? Ou manter class/id? Por enquanto, removido.
-         # '*': ['class', 'id']
     }
-    # Iterar por todas as tags DENTRO do target_element
-    # Usar list() para poder modificar a estrutura durante a iteração
     for tag in list(target_element.find_all(True)):
-        # Verifica se a tag ainda existe (pode ter sido removida por decompose)
-        if not tag.parent:
-            continue
         if tag.name not in tags_permitidas:
-            # Se a tag não é permitida, remove a tag mas mantém o conteúdo (unwrap)
-            # Evitar erro se tag já foi removida
             tag.unwrap()
         else:
-            # Se a tag é permitida, limpa os atributos não permitidos
-            atributos_para_manter = atributos_permitidos.get(tag.name, []) # + atributos_permitidos.get('*', []) # Removido '*'
             attrs_mantidos = {}
             for attr, value in tag.attrs.items():
                 if attr in atributos_para_manter:
@@ -103,54 +126,70 @@ def extrair_limpar_html(html_bruto):
             tag.attrs = attrs_mantidos
     # Retorna o HTML limpo e focado como string
     return str(target_element)
-# --- Função Principal (adaptada) ---
-def html_para_markdown_com_extracao_e_limpeza(html_input):
     """
-    Extrai o conteúdo principal do HTML, limpa-o e converte para Markdown.
     """
     if not html_input:
         return "Por favor, insira algum código HTML."
     try:
-        # 1. Extrai o conteúdo principal e limpa
-        html_limpo_e_focado = extrair_limpar_html(html_input)
-        if not html_limpo_e_focado or html_limpo_e_focado.strip() == "":
-             return "HTML resultante após extração e limpeza está vazio ou contém apenas espaços."
-        # 2. Converte o HTML limpo para Markdown
         converter = html2text.HTML2Text()
         converter.ignore_links = False
         converter.ignore_images = False
-        converter.body_width = 0 # Desativa quebra de linha baseada em largura
-        # Outras opções úteis do html2text:
-        # converter.protect_links = True # Tenta proteger links que podem ser quebrados
-        # converter.single_line_break = True # Usa quebra de linha única para <br>
-        # converter.use_automatic_links = True # Detecta links automaticamente
-        markdown_output = converter.handle(html_limpo_e_focado)
-        # Pequeno pós-processamento para remover linhas vazias excessivas
         linhas = markdown_output.splitlines()
-        linhas_filtradas = [linha for linha in linhas if linha.strip()]
-        markdown_output = "\n\n".join(linhas_filtradas) # Junta com parágrafos separados
-        return markdown_output.strip()
     except Exception as e:
-        # Logar o erro completo pode ser útil para depuração no servidor
         logging.error(f"Erro durante o processo: {e}", exc_info=True)
-        return f"Ocorreu um erro durante o processo: {str(e)}. Verifique os logs para mais detalhes."
 # --- Cria a interface Gradio ---
 iface = gr.Interface(
-    fn=html_para_markdown_com_extracao_e_limpeza, # Função principal atualizada
     inputs=gr.Textbox(lines=20, label="Insira o HTML bruto aqui", placeholder="Cole o código-fonte HTML completo da página..."),
-    outputs=gr.Textbox(lines=20, label="Markdown Resultante (Conteúdo Principal)"),
-    title="Conversor HTML para Markdown (Foco no Conteúdo Principal)",
-    description="Cole o HTML completo. O script tentará identificar o conteúdo principal (usando tags como <main>, <article> ou IDs/classes comuns como #content, .post-body), removerá elementos irrelevantes (scripts, navegação, rodapés, etc.) e atributos desnecessários, e então converterá o conteúdo limpo para Markdown.",
     allow_flagging='never'
 )

 import gradio as gr
 import html2text
 from bs4 import BeautifulSoup
+import logging
 logging.basicConfig(level=logging.INFO)
+def extrair_limpar_html_v2(html_bruto):
     """
+    Tenta extrair o conteúdo principal, remove seções finais comuns
+    (comentários, posts relacionados), limpa tags/atributos e retorna o HTML.
     :param html_bruto: String contendo o código HTML original.
     :return: String contendo o HTML limpo e focado no conteúdo principal.
     target_element = None
     # --- 1. Tentar Extrair o Conteúdo Principal ---
     main_content_selectors = [
+        'article',              # <article> tag (mais comum para posts individuais)
         'main',                 # <main> tag
         '[role="main"]',        # role="main" attribute
         '.post',                # Classe .post
+        '.entry-content',       # Classe .entry-content
+        '.post-content',        # Classe .post-content
+        '.td-post-content',     # Comum em alguns temas WP
         '.article-body',        # Classe .article-body
+        '#content',             # ID #content
+        '#main',                # ID #main
         '#bodyContent',         # ID específico da Wikipedia
     ]
     for selector in main_content_selectors:
         potential_match = soup.select_one(selector)
         if potential_match:
+            # Verifica se o match não é apenas um container vazio ou muito pequeno
+            # (Pode precisar de ajuste)
+            if len(potential_match.get_text(strip=True)) > 100: # Heurística simples
+                 target_element = potential_match
+                 logging.info(f"Conteúdo principal identificado usando o seletor: '{selector}'")
+                 break
     if not target_element:
         if soup.body:
             target_element = soup.body
             logging.info("Nenhum contêiner principal específico encontrado. Usando <body> como fallback.")
         else:
             target_element = soup
             logging.warning("Nenhum contêiner principal ou <body> encontrado. Processando todo o input.")
     if not target_element:
          return ""
+    # --- 2. Remover Seções Finais Indesejadas DENTRO do target_element ---
+    # Lista de seletores para comentários, posts relacionados, formulários de resposta, etc.
+    end_content_selectors = [
+        '#comments',            # ID comum para seção de comentários
+        '.comments-area',       # Classe comum para seção de comentários
+        '#respond',             # ID comum para formulário de resposta
+        '.comment-respond',     # Classe comum para formulário de resposta
+        '.related-posts',       # Classe comum para posts relacionados
+        '.jp-relatedposts',     # Classe do Jetpack para posts relacionados
+        '.post-navigation',     # Navegação entre posts
+        '.author-box',          # Caixa de biografia do autor
+        '.share-buttons',       # Botões de compartilhamento social
+        '#jp-post-flair',       # Jetpack flair (pode incluir compartilhamento/relacionados)
+        '.yarpp-related',       # Yet Another Related Posts Plugin
+        # Adicione seletores específicos do site/tema se necessário
+        # Exemplo baseado no HTML do usuário:
+        # Procurar por um h2 com texto "Comentários" ou "Mais posts" e remover seu container? (Mais frágil)
+        # Ou identificar os containers pelos IDs/classes se disponíveis.
+        # Se "Mais posts" estiver numa section ou div específica:
+        # '.mais-posts-section-class' # Substitua pelo seletor real
+    ]
+    logging.info(f"Procurando por seções finais indesejadas dentro do elemento '{target_element.name}'...")
+    removed_count = 0
+    for selector in end_content_selectors:
+        # Encontra TODOS os elementos que correspondem dentro do target_element
+        elements_to_remove = target_element.select(selector)
+        for element in elements_to_remove:
+            # Verifica se o elemento ainda existe (pode ter sido removido como filho de outro)
+            if element.parent:
+                logging.info(f"Removendo seção final indesejada encontrada com seletor: '{selector}' (Tag: {element.name}, ID: {element.get('id', 'N/A')}, Classes: {element.get('class', [])})")
+                element.decompose() # Remove o elemento e todo o seu conteúdo
+                removed_count += 1
+    if removed_count > 0:
+        logging.info(f"Removidas {removed_count} seções finais indesejadas.")
+    else:
+        logging.info("Nenhuma seção final indesejada conhecida foi encontrada para remoção.")
+    # --- 3. Limpar o Restante do Elemento Selecionado ---
+    tags_para_remover = ['script', 'style', 'form', 'input', 'button', 'select', 'textarea', 'label', 'footer', 'header', 'nav', 'aside', 'iframe', 'noscript', 'meta', 'link']
     for tag in target_element.find_all(tags_para_remover):
         tag.decompose()
     tags_permitidas = {
         'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'br', 'a', 'strong', 'b',
         'em', 'i', 'u', 's', 'strike', 'del', 'ul', 'ol', 'li', 'img',
+        'table', 'thead', 'tbody', 'tr', 'th', 'td', 'blockquote', 'pre', 'code',
+        'figure', 'figcaption' # Adicionado figure/figcaption, comum para imagens com legendas
     }
     atributos_permitidos = {
         'a': ['href', 'title'],
         'img': ['src', 'alt', 'title', 'width', 'height'],
+        'th': ['colspan', 'rowspan'], # Útil para tabelas
+        'td': ['colspan', 'rowspan'],
     }
     for tag in list(target_element.find_all(True)):
+        if not tag.parent: continue
         if tag.name not in tags_permitidas:
             tag.unwrap()
         else:
+            atributos_para_manter = atributos_permitidos.get(tag.name, [])
             attrs_mantidos = {}
             for attr, value in tag.attrs.items():
                 if attr in atributos_para_manter:
             tag.attrs = attrs_mantidos
     # Retorna o HTML limpo e focado como string
+    # Usar .prettify() pode ajudar na depuração, mas str() é mais direto
     return str(target_element)
+def html_para_markdown_final(html_input):
     """
+    Pipeline completo: Extrai conteúdo, limpa seções indesejadas e converte para Markdown.
     """
     if not html_input:
         return "Por favor, insira algum código HTML."
     try:
+        # 1. Extrai, remove seções finais e limpa HTML
+        html_processado = extrair_limpar_html_v2(html_input)
+        if not html_processado or not BeautifulSoup(html_processado, 'html.parser').get_text(strip=True):
+             return "HTML resultante após extração e limpeza está vazio ou não contém texto."
+        # 2. Converte o HTML processado para Markdown
         converter = html2text.HTML2Text()
         converter.ignore_links = False
         converter.ignore_images = False
+        converter.body_width = 0
+        converter.single_line_break = True # Trata <br> como uma única quebra de linha
+        # Outras opções podem ser úteis:
+        # converter.unicode_snob = True # Usa caracteres unicode para listas, etc.
+        # converter.escape_snob = True # Escapa caracteres especiais do Markdown
+        markdown_output = converter.handle(html_processado)
+        # 3. Pós-processamento do Markdown (opcional, mas útil)
+        # Remover linhas excessivas em branco
         linhas = markdown_output.splitlines()
+        linhas_filtradas = []
+        espacos_consecutivos = 0
+        for linha in linhas:
+            linha_strip = linha.strip()
+            if not linha_strip:
+                espacos_consecutivos += 1
+                if espacos_consecutivos <= 2: # Permitir no máximo uma linha em branco entre blocos
+                    linhas_filtradas.append(linha_strip)
+            else:
+                espacos_consecutivos = 0
+                linhas_filtradas.append(linha)
+        markdown_output = "\n".join(linhas_filtradas).strip()
+        # Remover possíveis artefatos de tabelas vazias ou listas vazias se necessário
+        # markdown_output = re.sub(r"\n\s*\n", "\n\n", markdown_output) # Exemplo de limpeza extra
+        return markdown_output
     except Exception as e:
         logging.error(f"Erro durante o processo: {e}", exc_info=True)
+        return f"Ocorreu um erro durante o processo: {str(e)}. Verifique os logs do Space para detalhes."
 # --- Cria a interface Gradio ---
 iface = gr.Interface(
+    fn=html_para_markdown_final, # Usando a função principal atualizada
     inputs=gr.Textbox(lines=20, label="Insira o HTML bruto aqui", placeholder="Cole o código-fonte HTML completo da página..."),
+    outputs=gr.Textbox(lines=20, label="Markdown Resultante (Conteúdo Principal Limpo)"),
+    title="Conversor HTML para Markdown (Foco no Conteúdo Principal + Remoção de Comentários/Relacionados)",
+    description="Cole o HTML completo. O script tentará identificar o conteúdo principal, removerá seções comuns como comentários e posts relacionados no final do artigo, limpará tags/atributos irrelevantes e converterá para Markdown.",
     allow_flagging='never'
 )