Update app.py

app.py

@@ -1,17 +1,18 @@
 # -*- coding: utf-8 -*-
 import gradio as gr
 import html2text
-from bs4 import BeautifulSoup, Comment # Adicionado Comment para remover comentários HTML
+from bs4 import BeautifulSoup, Comment
 import logging
-import re # Para limpeza final do markdown
+import re
 
 logging.basicConfig(level=logging.INFO)
 
-def extrair_limpar_html_v4(html_bruto):
+def extrair_limpar_html_v5(html_bruto):
     """
-    Tenta extrair o conteúdo principal, remove seções finais comuns
-    (comentários, posts relacionados), limpa tags/atributos e retorna o HTML.
-    V4: Mantém lógica de limpeza V3, ajusta para melhor formato final.
+    Extrai o conteúdo principal (priorizando .entry-content), remove
+    elementos irmãos indesejados (tags, nav, comments, related), limpa
+    o conteúdo principal e retorna o HTML limpo.
+    V5: Adaptado para a estrutura HTML fornecida.
 
     :param html_bruto: String contendo o código HTML original.
     :return: String contendo o HTML limpo e focado no conteúdo principal.
@@ -26,138 +27,154 @@ def extrair_limpar_html_v4(html_bruto):
         comment.extract()
 
     target_element = None
+    main_container = None # Guarda o elemento que contém o target_element e os irmãos
 
-    # --- 1. Tentar Extrair o Conteúdo Principal ---
-    # Seletores reordenados, priorizando article e classes de conteúdo comuns
+    # --- 1. Encontrar o Contêiner Principal Específico (.entry-content) ---
+    # Seletores em ordem de preferência para este site
     main_content_selectors = [
-        'article', '.entry-content', '.post-content', '.post-body', '.article-body',
-        '.td-post-content', 'main', '[role="main"]', '.post',
-        '#content', '#main', '#bodyContent',
+        '.entry-content',           # O mais provável para o corpo do post neste HTML
+        '.wp-block-post-content',   # Alternativa
+        'article',                  # Fallback
+        'main',                     # Fallback mais amplo
+        # '[role="main"]',          # Menos provável neste tema
     ]
-    # Nota: A qualidade da extração depende muito da estrutura do site de origem.
-    # Seletores podem precisar de ajuste para sites específicos.
 
     for selector in main_content_selectors:
-        potential_match = soup.select_one(selector)
-        if potential_match:
-             # Heurística básica para evitar containers muito pequenos
-            if len(potential_match.get_text(strip=True)) > 150:
-                 target_element = potential_match
-                 logging.info(f"Conteúdo principal identificado usando o seletor: '{selector}'")
-                 break
-            else:
-                 logging.info(f"Seletor '{selector}' encontrado, mas conteúdo muito pequeno. Continuando busca.")
-
-
+        target_element = soup.select_one(selector)
+        if target_element:
+            logging.info(f"Conteúdo principal identificado usando o seletor: '{selector}'")
+            # Tenta encontrar um pai razoável para procurar irmãos
+            # Anda alguns níveis acima se necessário, mas não até o body/html se possível
+            potential_main_container = target_element.parent
+            levels_up = 0
+            while potential_main_container and potential_main_container.name in ['div', 'section'] and levels_up < 3:
+                 # Verifica se este pai contém os blocos indesejados como irmãos do target
+                 if potential_main_container.select_one('.wp-block-post-terms, .wp-block-comments, .wp-block-query'):
+                      main_container = potential_main_container
+                      logging.info(f"Container principal para busca de irmãos definido como: <{main_container.name}>")
+                      break
+                 potential_main_container = potential_main_container.parent
+                 levels_up += 1
+
+            # Se não encontrou um container com irmãos indesejados, usa o pai direto
+            if not main_container:
+                 main_container = target_element.parent
+                 if main_container:
+                      logging.info(f"Container principal para busca de irmãos definido como pai direto: <{main_container.name}>")
+
+
+            break # Para ao encontrar o primeiro target
+
+    # Fallback se nenhum seletor específico funcionou
     if not target_element:
+        logging.warning("Nenhum seletor de conteúdo principal específico (.entry-content, article, main) encontrado.")
+        # Tenta usar o body, mas a limpeza de irmãos não será eficaz
         if soup.body:
             target_element = soup.body
-            logging.info("Nenhum contêiner principal específico encontrado. Usando <body> como fallback.")
+            main_container = soup.body # Define main_container como body
+            logging.info("Usando <body> como target_element e main_container.")
         else:
-            target_element = soup
-            logging.warning("Nenhum contêiner principal ou <body> encontrado. Processando todo o input.")
-
-    if not target_element:
-         return ""
-
-    logging.info(f"Trabalhando dentro do elemento: <{target_element.name} id='{target_element.get('id', 'N/A')}' class='{' '.join(target_element.get('class', []))}'>")
-
-    # --- 2. Remover Seções Finais Indesejadas DENTRO do target_element ---
-    # Esta é a parte mais crítica e dependente do site.
-    # Adicione mais seletores se necessário para o site específico.
-    end_content_selectors = [
-        '#comments', '.comments-area', '#respond', '.comment-respond',
-        '.related-posts', '.jp-relatedposts', '.yarpp-related', '.wp_rp_content', # Posts relacionados
-        '.post-navigation', '.nav-links', '.pagination', # Navegação/Paginação
-        '.author-box', '.author-info', # Biografia do autor
-        '.share-buttons', '.social-sharing', '.shariff', # Compartilhamento
-        '#jp-post-flair', '.post-tags', '.entry-tags', # Tags/Flair
-        '.edit-link', # Links de edição (comum em WP)
-        '#disqus_thread', # Disqus comments
-        '.saboxplugin-wrap', # Simple Author Box plugin
-        # Heurística baseada no texto do seu exemplo: Elementos contendo esses H2/H3
-        # Isso é mais frágil, use com cuidado. Tenta encontrar o elemento PAI do Hx.
-        # 'h2:contains("Comentários")', 'h3:contains("Deixe um comentário")', 'h2:contains("Mais posts")',
-        # -- Se usar os seletores :contains acima, precisaria de lógica extra para pegar o PAI --
-        # Melhor usar IDs/Classes se disponíveis no HTML original.
-    ]
+            logging.error("Falha crítica: Nenhum elemento de conteúdo ou body encontrado.")
+            return "" # Não há nada para processar
+
+    # Se não conseguiu definir um main_container, não pode remover irmãos
+    if not main_container:
+         logging.warning("Não foi possível determinar um container válido para remover irmãos.")
+         # Prossegue limpando apenas o target_element encontrado
+
+    # --- 2. Remover Elementos Irmãos Indesejados (SE main_container foi definido) ---
+    if main_container and target_element is not main_container: # Só remove irmãos se o target não for o próprio container
+        logging.info(f"Procurando irmãos indesejados de <{target_element.name}> dentro de <{main_container.name}>...")
+        siblings_to_remove_selectors = [
+            '.wp-block-post-terms',       # Bloco de Tags
+            '.wp-container-core-group-is-layout-9b36172e', # Div que contém a navegação Prev/Next (baseado no HTML)
+            '.wp-block-comments',         # Bloco de comentários inteiro
+            '.wp-block-query',            # Bloco "Mais Posts" (Query Loop)
+            # Poderíamos ser mais específicos para "Mais Posts", mas .wp-block-query parece ok aqui
+            # Exemplo: 'div.wp-block-group:has(> h2:contains("Mais posts"))' # Requer análise mais complexa
+        ]
+        removed_siblings_count = 0
+        # Itera sobre os elementos DENTRO do main_container
+        for element in main_container.find_all(recursive=False): # Apenas filhos diretos ou netos? Melhor procurar em todo o container
+             # Verifica se o elemento atual NÃO é o target_element ou um de seus pais
+            if element is not target_element and not element.find(target_element):
+                for selector in siblings_to_remove_selectors:
+                     # Verifica se o elemento corresponde a um seletor indesejado
+                     # Usamos select_one para garantir que estamos testando o próprio elemento
+                     # Ou podemos usar element.matches(selector) se a versão do bs4 suportar bem
+                     if element.select_one(f':is({selector})'): # :is() para testar o próprio elemento
+                         logging.info(f"  Removendo irmão/elemento indesejado: <{element.name} class='{' '.join(element.get('class',[]))}'> (match com '{selector}')")
+                         element.decompose()
+                         removed_siblings_count += 1
+                         break # Sai do loop de seletores para este elemento
+
+        # Abordagem alternativa/complementar: Buscar DEPOIS do target_element
+        for sibling in target_element.find_next_siblings():
+             for selector in siblings_to_remove_selectors:
+                 # Verifica se o irmão corresponde a um seletor indesejado
+                 if sibling.select_one(f':is({selector})'): # :is() para testar o próprio irmão
+                     logging.info(f"  Removendo irmão SEGUINTE indesejado: <{sibling.name} class='{' '.join(sibling.get('class',[]))}'> (match com '{selector}')")
+                     sibling.decompose()
+                     removed_siblings_count += 1
+                     break # Vai para o próximo irmão
+
+
+        if removed_siblings_count > 0:
+            logging.info(f"Removidos {removed_siblings_count} elementos/irmãos indesejados.")
+        else:
+            logging.info("Nenhum elemento/irmão indesejado conhecido foi encontrado ou removido após o conteúdo principal.")
 
-    removed_end_count = 0
-    for selector in end_content_selectors:
-        # Usar select para encontrar todos os elementos que batem DENTRO do target_element
-        elements_to_remove = target_element.select(selector)
-        if elements_to_remove:
-            logging.info(f"Tentando remover elementos para o seletor final: '{selector}'")
-            for element in elements_to_remove:
-                # Verifica se o elemento ainda está na árvore e pertence ao target_element
-                # (evita remover algo fora ou já removido)
-                if element.find_parent(target_element.name,
-                                       attrs=target_element.attrs) is not None:
-                    logging.info(f"  Removendo: <{element.name} id='{element.get('id', 'N/A')}' class='{' '.join(element.get('class', []))}'>")
-                    element.decompose()
-                    removed_end_count += 1
-
-    if removed_end_count > 0:
-        logging.info(f"Removidas {removed_end_count} seções finais indesejadas.")
-    else:
-        logging.info("Nenhuma seção final indesejada conhecida foi encontrada ou removida.")
-
-    # --- 3. Limpeza Geral DENTRO do que sobrou do target_element ---
+    # --- 3. Limpeza Geral DENTRO do target_element isolado ---
+    logging.info(f"Iniciando limpeza geral DENTRO do target_element: <{target_element.name}>")
     tags_para_remover_geral = [
         'script', 'style', 'form', 'input', 'button', 'select', 'textarea', 'label',
         'footer', 'header', 'nav', 'aside', 'iframe', 'noscript', 'meta', 'link',
-        'canvas', 'svg', 'audio', 'video', # Elementos multimídia não textuais
-        'figure', # Remover figure se não quiser a imagem + legenda juntas
-        # Cuidado: Remover 'figure' pode quebrar a associação imagem/legenda se 'figcaption' for permitido.
-        # Se quiser manter imagens, mas não o container figure, descomente a linha abaixo
-        # e ajuste as tags permitidas/limpeza de atributos.
+        'canvas', 'svg', 'audio', 'video', 'figure', # Remover figure, manter figcaption permitido
+        # '.wp-block-button', # Remover botões? Pode ser útil manter alguns. Avaliar.
     ]
     removed_general_count = 0
+    # Importante: usar find_all DENTRO do target_element
     for tag_name in tags_para_remover_geral:
          for tag in target_element.find_all(tag_name):
             tag.decompose()
             removed_general_count +=1
     if removed_general_count > 0:
-        logging.info(f"Removidas {removed_general_count} tags gerais indesejadas (script, style, etc.).")
-
+        logging.info(f"Removidas {removed_general_count} tags gerais indesejadas dentro do target_element.")
 
-    # --- 4. Limpar Atributos e Tags Restantes ---
+    # --- 4. Limpar Atributos e Tags Restantes no target_element ---
     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',
-        'figcaption' # Permitir legenda se 'figure' for removido ou 'img' estiver dentro dela
+        'figcaption'
     }
     atributos_permitidos = {
         'a': ['href', 'title'],
-        'img': ['src', 'alt', 'title', 'width', 'height'], # Manter alt é importante
+        'img': ['src', 'alt', 'title', 'width', 'height'],
         'th': ['colspan', 'rowspan', 'scope'],
         'td': ['colspan', 'rowspan'],
         'blockquote': ['cite'],
         'ol': ['start'],
-        # Não permitir 'class' ou 'id' por padrão para limpeza máxima
+        'pre': [], # Geralmente não precisa de atributos
+        'code': ['class'], # Permitir classe para syntax highlighting (ex: class="language-python")
     }
 
-    # Iterar sobre uma cópia da lista de tags para poder modificar durante a iteração
+    # Iterar sobre uma cópia da lista de tags DENTRO do target_element
     for tag in list(target_element.find_all(True)):
-        # Se a tag foi decomposta em uma iteração anterior, pule
-        if not tag.parent:
-            continue
+        if not tag.parent: continue # Ignora tags já removidas
 
         if tag.name not in tags_permitidas:
-            # Se a tag não é permitida, remove a tag mas mantém o conteúdo
-            tag.unwrap()
+            tag.unwrap() # Remove tag, mantém conteúdo
         else:
-            # Se a tag é permitida, limpa os atributos não permitidos
+            # Limpa atributos
             atributos_para_manter = atributos_permitidos.get(tag.name, [])
             attrs_mantidos = {}
-            # Preserva atributos essenciais mesmo que não listados explicitamente (ex: href em 'a')
-            if tag.name == 'a' and 'href' in tag.attrs:
-                attrs_mantidos['href'] = tag.attrs['href']
-            if tag.name == 'img' and 'src' in tag.attrs:
-                attrs_mantidos['src'] = tag.attrs['src']
+            # Mantém atributos essenciais primeiro
+            if tag.name == 'a' and 'href' in tag.attrs: attrs_mantidos['href'] = tag.attrs['href']
+            if tag.name == 'img' and 'src' in tag.attrs: attrs_mantidos['src'] = tag.attrs['src']
+            if tag.name == 'img' and 'alt' in tag.attrs: attrs_mantidos['alt'] = tag.attrs['alt'] # Manter ALT
 
-            # Adiciona outros atributos permitidos
+            # Adiciona outros permitidos
             for attr, value in tag.attrs.items():
                 if attr in atributos_para_manter:
                     attrs_mantidos[attr] = value
@@ -165,86 +182,83 @@ def extrair_limpar_html_v4(html_bruto):
 
     # Retorna o HTML limpo e focado como string
     html_final = str(target_element)
-    # Pequena limpeza final do HTML antes de passar pro html2text
-    html_final = html_final.replace(' ', ' ') # Substitui non-breaking spaces
+    html_final = html_final.replace(' ', ' ')
+    # Remover divs vazios que podem sobrar após unwrap
+    soup_final = BeautifulSoup(html_final, 'html.parser')
+    for div in soup_final.find_all('div'):
+        if not div.get_text(strip=True) and not div.find(['img', 'br']): # Se não tem texto nem imagem/br
+             div.decompose()
+    html_final = str(soup_final)
+
+    logging.info("Limpeza final do HTML concluída.")
     return html_final
 
 
-def html_para_markdown_final_v4(html_input):
+def html_para_markdown_final_v5(html_input):
     """
-    Pipeline completo V4: Extrai, limpa (com foco na formatação V2) e converte.
+    Pipeline completo V5: Extrai .entry-content, remove irmãos, limpa, converte.
     """
     if not html_input:
         return "Por favor, insira algum código HTML."
 
     try:
-        # 1. Extrai, remove seções finais e limpa HTML
-        logging.info("--- Iniciando Extração e Limpeza do HTML ---")
-        html_processado = extrair_limpar_html_v4(html_input)
-        logging.info("--- Extração e Limpeza do HTML Concluída ---")
+        # 1. Extrai, remove irmãos indesejados e limpa HTML
+        logging.info("--- Iniciando Extração e Limpeza V5 ---")
+        html_processado = extrair_limpar_html_v5(html_input)
+        logging.info("--- Extração e Limpeza V5 Concluída ---")
 
-        # Verifica se o resultado tem conteúdo textual significativo
         soup_check = BeautifulSoup(html_processado, 'html.parser')
         if not html_processado or not soup_check.get_text(strip=True):
-             logging.warning("HTML resultante após limpeza está vazio ou sem texto.")
-             # Opcional: retornar o HTML limpo para depuração
-             # return f"HTML resultante vazio ou sem texto.\nHTML limpo (para depuração):\n{html_processado}"
+             logging.warning("HTML resultante V5 após limpeza está vazio ou sem texto.")
              return "HTML resultante após extração e limpeza está vazio ou não contém texto."
 
-        # 2. Converte o HTML processado para Markdown
-        logging.info("--- Iniciando Conversão para Markdown ---")
+        # 2. Converte o HTML processado para Markdown (Config V4/V2)
+        logging.info("--- Iniciando Conversão para Markdown V5 ---")
         converter = html2text.HTML2Text()
-        # Configurações para tentar replicar a formatação "boa" anterior (V2)
-        converter.body_width = 0        # Sem quebra de linha automática por largura
+        converter.body_width = 0
         converter.ignore_links = False
         converter.ignore_images = False
-        converter.ignore_emphasis = False # Manter negrito/itálico
-        # Remover opções que podem afetar espaçamento/parágrafos (como single_line_break)
-        # converter.single_line_break = True # Removido - Deixar html2text tratar <p>
-        converter.use_automatic_links = True # Tentar detectar links
-        converter.unicode_snob = True      # Usar caracteres unicode para listas, etc.
-        converter.escape_snob = True       # Escapar caracteres markdown
+        converter.ignore_emphasis = False
+        converter.use_automatic_links = True
+        converter.unicode_snob = True
+        converter.escape_snob = True
 
         markdown_output = converter.handle(html_processado)
-        logging.info("--- Conversão para Markdown Concluída ---")
+        logging.info("--- Conversão para Markdown V5 Concluída ---")
 
-        # 3. Pós-processamento do Markdown (Simplificado - mais próximo da V2)
-        logging.info("--- Iniciando Pós-processamento do Markdown ---")
-        # Remover espaços em branco no início/fim de cada linha
+        # 3. Pós-processamento do Markdown (Simplificado - V4/V2)
+        logging.info("--- Iniciando Pós-processamento do Markdown V5 ---")
         linhas = [line.strip() for line in markdown_output.splitlines()]
-        # Remover linhas completamente vazias
         linhas_filtradas = [line for line in linhas if line]
-        # Juntar com duas quebras de linha para parágrafos (Markdown padrão)
         markdown_output = "\n\n".join(linhas_filtradas)
 
-        # Limpeza final extra (opcional): Remover múltiplos espaços dentro das linhas
-        markdown_output = re.sub(r' +', ' ', markdown_output)
-        # Remover espaços antes de quebras de linha
-        markdown_output = re.sub(r' +\n', '\n', markdown_output)
+        # Limpeza final extra
+        markdown_output = re.sub(r' +', ' ', markdown_output) # Múltiplos espaços
+        markdown_output = re.sub(r' +\n', '\n', markdown_output) # Espaços antes de \n
+        # Remover marcadores de lista vazios ou estranhos que podem sobrar
+        markdown_output = re.sub(r'\n\n[-*+]\s*\n\n', '\n\n', markdown_output)
+        markdown_output = re.sub(r'^\s*[-*+]\s*\n\n', '', markdown_output) # No início
 
-        logging.info("--- Pós-processamento do Markdown Concluído ---")
+        logging.info("--- Pós-processamento do Markdown V5 Concluído ---")
         return markdown_output.strip()
 
     except Exception as e:
-        logging.error(f"Erro durante o processo V4: {e}", exc_info=True)
-        # Tentar retornar o HTML processado em caso de erro na conversão/pós-processamento
-        try:
-            html_on_error = html_processado
-        except NameError:
-            html_on_error = "(HTML não disponível)"
-        return (f"Ocorreu um erro: {str(e)}\n\n"
-                f"Verifique os logs do Space para detalhes.\n\n"
-                f"HTML processado antes do erro (para depuração):\n"
-                f"{html_on_error[:2000]}...") # Limita o tamanho
+        logging.error(f"Erro durante o processo V5: {e}", exc_info=True)
+        try: html_on_error = html_processado
+        except NameError: html_on_error = "(HTML não disponível)"
+        return (f"Ocorreu um erro V5: {str(e)}\n\n"
+                f"Verifique os logs do Space.\n\n"
+                f"HTML processado antes do erro:\n"
+                f"{html_on_error[:2000]}...")
 
 
 # --- Cria a interface Gradio ---
 iface = gr.Interface(
-    fn=html_para_markdown_final_v4, # Usando a função V4
+    fn=html_para_markdown_final_v5, # Usando a função V5
     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 - V4)", show_copy_button=True),
-    title="Conversor HTML para Markdown (V4 - Foco Conteúdo + Formatação)",
-    description="Cole o HTML. O script tenta isolar o artigo principal, remove comentários/relacionados/etc. (melhor resultado com IDs/classes padrão), limpa o HTML restante e converte para Markdown, buscando boa formatação.",
+    outputs=gr.Textbox(lines=20, label="Markdown Resultante (Conteúdo Principal Limpo - V5)", show_copy_button=True),
+    title="Conversor HTML para Markdown (V5 - Específico para Estrutura WP)",
+    description="Cole o HTML. O script tenta isolar '.entry-content', remove tags/comentários/relacionados/nav que vêm *depois* dele, limpa o HTML restante e converte para Markdown (formatação V2/V4).",
     allow_flagging='never'
 )