Spaces:

13ze
/

complex-html-to-markdown-llm

Sleeping

App Files Files Community

13ze commited on Apr 17, 2025

Commit

dd5deef

verified ·

1 Parent(s): cb892f1

Update app.py

Browse files

Files changed (1) hide show

app.py +102 -65

app.py CHANGED Viewed

@@ -1,119 +1,156 @@
 import gradio as gr
 import html2text
 from bs4 import BeautifulSoup
-# --- Função de Limpeza de HTML ---
-def limpar_html(html_bruto):
     """
-    Limpa o HTML, mantendo tags específicas e removendo outras,
-    incluindo scripts, estilos e atributos desnecessários.
     :param html_bruto: String contendo o código HTML original.
-    :return: String contendo o HTML limpo.
     """
     if not html_bruto:
         return ""
     soup = BeautifulSoup(html_bruto, 'html.parser')
-    # 1. Tags para remover completamente (incluindo conteúdo)
-    tags_para_remover = ['script', 'style', 'header', 'footer', 'nav', 'aside', 'form', 'meta', 'link', 'noscript']
-    for tag_nome in tags_para_remover:
-        for tag in soup.find_all(tag_nome):
-            tag.decompose() # Remove a tag e seu conteúdo
-    # 2. Tags permitidas (vamos manter estas e seus conteúdos)
-    #    Todas as outras tags serão removidas, mas seu conteúdo será mantido (unwrap)
     tags_permitidas = {
-        'html', 'body', 'head', 'title', # Estrutura básica (head/title podem ser removidos pelo html2text depois)
-        'h1', 'h2', 'h3', 'h4', 'h5', 'h6', # Cabeçalhos
-        'p', 'br', # Parágrafos e quebras de linha
-        'a', # Links
-        'strong', 'b', 'em', 'i', 'u', 's', 'strike', 'del', # Ênfase/Formatação
-        'ul', 'ol', 'li', # Listas
-        'img', # Imagens
-        'table', 'thead', 'tbody', 'tr', 'th', 'td', # Tabelas
-        'blockquote', # Citações
-        'pre', 'code' # Código
     }
-    # 3. Atributos permitidos por tag (outros serão removidos)
     atributos_permitidos = {
         'a': ['href', 'title'],
-        'img': ['src', 'alt', 'title', 'width', 'height'], # Manter width/height pode ser útil
-        '*': ['class', 'id'] # Permitir class e id em qualquer tag pode ser útil para CSS/JS, mas para conversão para Markdown talvez não. Remova se não precisar.
-        # Adicione mais tags e seus atributos permitidos aqui se necessário
     }
-    # Itera por todas as tags no documento
-    for tag in soup.find_all(True): # True encontra todas as tags
         if tag.name not in tags_permitidas:
-            # Se a tag não é permitida, remove a tag mas mantém o conteúdo
             tag.unwrap()
         else:
             # Se a tag é permitida, limpa os atributos não permitidos
-            atributos_para_manter = atributos_permitidos.get(tag.name, []) + atributos_permitidos.get('*', [])
-            # Cria um dicionário apenas com os atributos permitidos
             attrs_mantidos = {}
             for attr, value in tag.attrs.items():
                 if attr in atributos_para_manter:
                     attrs_mantidos[attr] = value
-            # Define os atributos da tag para serem apenas os mantidos
             tag.attrs = attrs_mantidos
-    # Retorna o HTML limpo como string
-    # O pretty print pode ajudar na depuração, mas str(soup) é mais direto
-    return str(soup)
 # --- Função Principal (adaptada) ---
-def html_para_markdown_com_limpeza(html_input):
     """
-    Limpa o HTML e depois converte para Markdown.
-    :param html_input: String contendo o código HTML vindo da interface Gradio.
-    :return: String convertida para Markdown.
     """
     if not html_input:
         return "Por favor, insira algum código HTML."
     try:
-        # 1. Limpa o HTML primeiro
-        html_limpo = limpar_html(html_input)
-        if not html_limpo:
-             return "O HTML resultante após a limpeza está vazio."
         # 2. Converte o HTML limpo para Markdown
         converter = html2text.HTML2Text()
         converter.ignore_links = False
-        # Configurações adicionais do html2text (opcional):
-        converter.ignore_images = False # Garante que imagens sejam processadas
-        converter.body_width = 0 # Evita quebra de linha automática baseada na largura
-        # converter.skip_internal_links = True
-        # converter.inline_links = True # Usa links inline em vez de referências no final
-        markdown_output = converter.handle(html_limpo)
-        # html2text pode incluir o conteúdo de <title> por padrão.
-        # Se quiser remover especificamente o conteúdo do <title> do Markdown final:
-        # (Isso é um pós-processamento, pode ser necessário ajustar)
-        soup_limpo = BeautifulSoup(html_limpo, 'html.parser')
-        titulo = soup_limpo.title
-        if titulo and titulo.string:
-             markdown_output = markdown_output.replace(titulo.string, '', 1).strip()
-        return markdown_output
     except Exception as e:
-        return f"Ocorreu um erro durante o processo: {str(e)}"
 # --- Cria a interface Gradio ---
 iface = gr.Interface(
-    fn=html_para_markdown_com_limpeza, # Função principal atualizada
-    inputs=gr.Textbox(lines=15, label="Insira o HTML bruto aqui", placeholder="<html><head><title>Título</title><script>...</script></head><body><h1>Cabeçalho</h1>...</body></html>"),
-    outputs=gr.Textbox(lines=15, label="Markdown Resultante (após limpeza)"),
-    title="Conversor HTML para Markdown com Limpeza",
-    description="Cole seu código HTML na caixa da esquerda. O código será limpo (removendo scripts, estilos, tags e atributos desnecessários) e depois convertido para Markdown na caixa da direita. Tags como <h1>, <p>, <a> e <img> (com src/alt) são preservadas.",
     allow_flagging='never'
 )

 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.
     """
     if not html_bruto:
         return ""
     soup = BeautifulSoup(html_bruto, 'html.parser')
+    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:
                     attrs_mantidos[attr] = value
             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'
 )