471 lines
17 KiB
Python
Executable File
471 lines
17 KiB
Python
Executable File
"""
|
|
structure_content_local.py - Estruturação LOCAL com regex/heurísticas (SEM custos API)
|
|
|
|
Author: Descomplicar® Crescimento Digital
|
|
Link: https://descomplicar.pt
|
|
Copyright: 2025 Descomplicar®
|
|
"""
|
|
|
|
import os
|
|
import json
|
|
import logging
|
|
import re
|
|
from pathlib import Path
|
|
from typing import Dict, List, Optional
|
|
from collections import Counter
|
|
|
|
# Configurações
|
|
INPUT_DIR = "/media/ealmeida/Dados/GDrive/Cloud/Clientes_360/CTF_Carstuff/KB/Scrapper/sites/output_md"
|
|
OUTPUT_DIR = "/media/ealmeida/Dados/GDrive/Cloud/Clientes_360/CTF_Carstuff/KB/Scrapper/sites/formatted"
|
|
|
|
# Configurar logging
|
|
logging.basicConfig(
|
|
level=logging.INFO,
|
|
format='%(asctime)s - %(levelname)s - %(message)s',
|
|
handlers=[
|
|
logging.FileHandler('structure_local_execution.log'),
|
|
logging.StreamHandler()
|
|
]
|
|
)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class LocalContentStructurer:
|
|
"""Estruturador local usando regex e heurísticas."""
|
|
|
|
def __init__(self):
|
|
# Padrões para detecção de secções
|
|
self.problem_keywords = [
|
|
r'\b(problem|issue|erro|falha|defeito|dificuldade|challenge)\b',
|
|
r'\b(não funciona|not working|broken|fail)\b',
|
|
r'\b(como resolver|how to fix|solução para)\b'
|
|
]
|
|
|
|
self.solution_keywords = [
|
|
r'\b(solução|solution|fix|repair|resolver|corrigir)\b',
|
|
r'\b(método|technique|process|procedimento)\b',
|
|
r'\b(usar|utilizar|aplicar|seguir|fazer)\b'
|
|
]
|
|
|
|
self.result_keywords = [
|
|
r'\b(resultado|result|outcome|conclusão)\b',
|
|
r'\b(sucesso|success|funcionou|worked)\b',
|
|
r'\b(melhorou|improved|fixed|resolvido)\b'
|
|
]
|
|
|
|
# Categorias por palavras-chave
|
|
self.category_patterns = {
|
|
'tutorial': [r'\bpasso\b', r'\bstep\b', r'\bguide\b', r'\bcomo fazer\b', r'\bhow to\b'],
|
|
'problema-tecnico': [r'\bproblema\b', r'\berro\b', r'\bfalha\b', r'\bissue\b'],
|
|
'showcase': [r'\bprojeto\b', r'\bproject\b', r'\bgaleria\b', r'\bgallery\b'],
|
|
'dica': [r'\bdica\b', r'\btip\b', r'\btruque\b', r'\btrick\b'],
|
|
'recurso': [r'\bferramenta\b', r'\btool\b', r'\bmaterial\b', r'\bsupply\b']
|
|
}
|
|
|
|
# Tópicos automotivos
|
|
self.automotive_topics = {
|
|
'estofamento': r'\b(upholstery|estofamento|estofar|tapeçaria)\b',
|
|
'couro': r'\b(leather|couro|pele)\b',
|
|
'tecido': r'\b(fabric|tecido|vinyl|vinil)\b',
|
|
'costura': r'\b(sewing|stitch|costura|coser)\b',
|
|
'bancos': r'\b(seat|banco|assento)\b',
|
|
'volante': r'\b(steering wheel|volante)\b',
|
|
'painel': r'\b(dashboard|painel|interior)\b',
|
|
'restauração': r'\b(restoration|restauração|restauro|renovação)\b'
|
|
}
|
|
|
|
def extract_title(self, content: str) -> str:
|
|
"""Extrai título do conteúdo."""
|
|
lines = content.strip().split('\n')
|
|
|
|
# Procurar por markdown headers
|
|
for line in lines[:10]:
|
|
if line.startswith('# '):
|
|
return line.replace('# ', '').strip()
|
|
if line.startswith('## '):
|
|
return line.replace('## ', '').strip()
|
|
|
|
# Fallback: primeira linha não-vazia
|
|
for line in lines:
|
|
if line.strip():
|
|
return line.strip()[:100]
|
|
|
|
return "Sem Título"
|
|
|
|
def classify_category(self, content: str) -> str:
|
|
"""Classifica categoria do conteúdo."""
|
|
content_lower = content.lower()
|
|
scores = {}
|
|
|
|
for category, patterns in self.category_patterns.items():
|
|
score = 0
|
|
for pattern in patterns:
|
|
score += len(re.findall(pattern, content_lower, re.IGNORECASE))
|
|
scores[category] = score
|
|
|
|
# Retornar categoria com maior score
|
|
if scores:
|
|
best_category = max(scores.items(), key=lambda x: x[1])
|
|
if best_category[1] > 0:
|
|
return best_category[0]
|
|
|
|
return "recurso" # Default
|
|
|
|
def extract_topics(self, content: str) -> List[str]:
|
|
"""Extrai tópicos relevantes."""
|
|
topics = []
|
|
content_lower = content.lower()
|
|
|
|
for topic, pattern in self.automotive_topics.items():
|
|
if re.search(pattern, content_lower, re.IGNORECASE):
|
|
topics.append(topic)
|
|
|
|
return topics if topics else ["estofamento automotivo"]
|
|
|
|
def extract_keywords(self, content: str) -> List[str]:
|
|
"""Extrai palavras-chave por frequência."""
|
|
# Remover pontuação e split
|
|
words = re.findall(r'\b[a-záàâãéêíóôõúçA-ZÁÀÂÃÉÊÍÓÔÕÚÇ]{4,}\b', content.lower())
|
|
|
|
# Contar frequências
|
|
word_freq = Counter(words)
|
|
|
|
# Filtrar stop words comuns
|
|
stop_words = {'para', 'com', 'sem', 'sobre', 'mais', 'pode', 'como', 'quando', 'onde', 'the', 'and', 'for', 'with'}
|
|
keywords = [word for word, freq in word_freq.most_common(20) if word not in stop_words]
|
|
|
|
return keywords[:10]
|
|
|
|
def detect_sections(self, content: str) -> Dict[str, List[str]]:
|
|
"""Detecta secções por padrões regex."""
|
|
sections = {
|
|
'problema': [],
|
|
'solucao': [],
|
|
'resultado': [],
|
|
'info': []
|
|
}
|
|
|
|
lines = content.split('\n')
|
|
current_section = 'info'
|
|
current_block = []
|
|
|
|
for line in lines:
|
|
line = line.strip()
|
|
|
|
if not line:
|
|
if current_block:
|
|
sections[current_section].append(' '.join(current_block))
|
|
current_block = []
|
|
continue
|
|
|
|
# Detectar mudança de secção
|
|
line_lower = line.lower()
|
|
|
|
is_problem = any(re.search(pattern, line_lower, re.IGNORECASE) for pattern in self.problem_keywords)
|
|
is_solution = any(re.search(pattern, line_lower, re.IGNORECASE) for pattern in self.solution_keywords)
|
|
is_result = any(re.search(pattern, line_lower, re.IGNORECASE) for pattern in self.result_keywords)
|
|
|
|
if is_problem:
|
|
if current_block:
|
|
sections[current_section].append(' '.join(current_block))
|
|
current_section = 'problema'
|
|
current_block = [line]
|
|
elif is_solution:
|
|
if current_block:
|
|
sections[current_section].append(' '.join(current_block))
|
|
current_section = 'solucao'
|
|
current_block = [line]
|
|
elif is_result:
|
|
if current_block:
|
|
sections[current_section].append(' '.join(current_block))
|
|
current_section = 'resultado'
|
|
current_block = [line]
|
|
else:
|
|
current_block.append(line)
|
|
|
|
# Adicionar último bloco
|
|
if current_block:
|
|
sections[current_section].append(' '.join(current_block))
|
|
|
|
return sections
|
|
|
|
def extract_list_items(self, text: str) -> List[str]:
|
|
"""Extrai itens de lista do texto."""
|
|
# Procurar por listas markdown ou numeradas
|
|
lines = text.split('\n')
|
|
items = []
|
|
|
|
for line in lines:
|
|
line = line.strip()
|
|
# Markdown list
|
|
if line.startswith('- ') or line.startswith('* '):
|
|
items.append(line[2:].strip())
|
|
# Numbered list
|
|
elif re.match(r'^\d+\.\s+', line):
|
|
items.append(re.sub(r'^\d+\.\s+', '', line))
|
|
|
|
return items if items else [text]
|
|
|
|
def structure_content(self, content: str, source_file: str) -> Dict:
|
|
"""Estrutura conteúdo usando heurísticas."""
|
|
|
|
# Extrair informações básicas
|
|
title = self.extract_title(content)
|
|
category = self.classify_category(content)
|
|
topics = self.extract_topics(content)
|
|
keywords = self.extract_keywords(content)
|
|
sections = self.detect_sections(content)
|
|
|
|
# Montar fonte
|
|
fonte = source_file.split('_')[0].replace('.md', '')
|
|
|
|
# Criar estrutura JSON
|
|
structured = {
|
|
"metadata": {
|
|
"titulo": title,
|
|
"categoria": category,
|
|
"topicos": topics,
|
|
"fonte": fonte
|
|
},
|
|
"conteudo": [],
|
|
"keywords": keywords,
|
|
"aplicabilidade": ["Veículos diversos", "Estofamento automotivo"]
|
|
}
|
|
|
|
# Adicionar secções detectadas
|
|
for secao_tipo, blocos in sections.items():
|
|
if not blocos:
|
|
continue
|
|
|
|
for i, bloco in enumerate(blocos, 1):
|
|
if len(bloco) < 50: # Ignorar blocos muito pequenos
|
|
continue
|
|
|
|
# Extrair primeira frase como descrição
|
|
sentences = bloco.split('. ')
|
|
descricao = sentences[0] + '.' if sentences else bloco[:200]
|
|
|
|
# Extrair detalhes (listas)
|
|
detalhes = self.extract_list_items(bloco)
|
|
if len(detalhes) == 1 and detalhes[0] == bloco:
|
|
detalhes = [] # Sem lista, usar só descrição
|
|
|
|
item = {
|
|
"tipo": secao_tipo,
|
|
"titulo": f"{secao_tipo.capitalize()} {i}" if len(blocos) > 1 else secao_tipo.capitalize(),
|
|
"descricao": descricao,
|
|
"detalhes": detalhes[:5], # Máximo 5 itens
|
|
"relevancia": "alta" if len(bloco) > 200 else "media"
|
|
}
|
|
|
|
structured["conteudo"].append(item)
|
|
|
|
return structured
|
|
|
|
def format_structured_md(self, structured_data: Dict, original_file: str) -> str:
|
|
"""Converte dados estruturados em Markdown formatado (compatível com versão AI)."""
|
|
md_lines = []
|
|
|
|
# Metadata
|
|
meta = structured_data.get('metadata', {})
|
|
md_lines.append(f"# {meta.get('titulo', 'Sem Título')}")
|
|
md_lines.append("")
|
|
md_lines.append(f"**Categoria**: {meta.get('categoria', 'Geral')}")
|
|
md_lines.append(f"**Fonte**: {meta.get('fonte', original_file)}")
|
|
|
|
if meta.get('topicos'):
|
|
md_lines.append(f"**Tópicos**: {', '.join(meta['topicos'])}")
|
|
|
|
md_lines.append("")
|
|
md_lines.append("---")
|
|
md_lines.append("")
|
|
|
|
# Conteúdo estruturado
|
|
conteudo = structured_data.get('conteudo', [])
|
|
|
|
# Agrupar por tipo
|
|
problemas = [c for c in conteudo if c.get('tipo') == 'problema']
|
|
solucoes = [c for c in conteudo if c.get('tipo') == 'solucao']
|
|
resultados = [c for c in conteudo if c.get('tipo') == 'resultado']
|
|
info = [c for c in conteudo if c.get('tipo') == 'info']
|
|
|
|
# Problemas
|
|
if problemas:
|
|
md_lines.append("## 🔍 Problemas Identificados")
|
|
md_lines.append("")
|
|
for p in problemas:
|
|
md_lines.append(f"### {p.get('titulo', 'Problema')}")
|
|
md_lines.append("")
|
|
md_lines.append(p.get('descricao', ''))
|
|
md_lines.append("")
|
|
if p.get('detalhes'):
|
|
for detalhe in p['detalhes']:
|
|
md_lines.append(f"- {detalhe}")
|
|
md_lines.append("")
|
|
|
|
# Soluções
|
|
if solucoes:
|
|
md_lines.append("## 💡 Soluções")
|
|
md_lines.append("")
|
|
for s in solucoes:
|
|
md_lines.append(f"### {s.get('titulo', 'Solução')}")
|
|
md_lines.append("")
|
|
md_lines.append(s.get('descricao', ''))
|
|
md_lines.append("")
|
|
if s.get('detalhes'):
|
|
for i, detalhe in enumerate(s['detalhes'], 1):
|
|
md_lines.append(f"{i}. {detalhe}")
|
|
md_lines.append("")
|
|
|
|
# Resultados
|
|
if resultados:
|
|
md_lines.append("## ✅ Resultados")
|
|
md_lines.append("")
|
|
for r in resultados:
|
|
md_lines.append(f"### {r.get('titulo', 'Resultado')}")
|
|
md_lines.append("")
|
|
md_lines.append(r.get('descricao', ''))
|
|
md_lines.append("")
|
|
if r.get('detalhes'):
|
|
for detalhe in r['detalhes']:
|
|
md_lines.append(f"- {detalhe}")
|
|
md_lines.append("")
|
|
|
|
# Informação adicional
|
|
if info:
|
|
md_lines.append("## 📋 Informação Adicional")
|
|
md_lines.append("")
|
|
for inf in info:
|
|
md_lines.append(f"### {inf.get('titulo', 'Info')}")
|
|
md_lines.append("")
|
|
md_lines.append(inf.get('descricao', ''))
|
|
md_lines.append("")
|
|
if inf.get('detalhes'):
|
|
for detalhe in inf['detalhes']:
|
|
md_lines.append(f"- {detalhe}")
|
|
md_lines.append("")
|
|
|
|
# Keywords e aplicabilidade
|
|
md_lines.append("---")
|
|
md_lines.append("")
|
|
|
|
if structured_data.get('keywords'):
|
|
md_lines.append(f"**Palavras-chave**: {', '.join(structured_data['keywords'])}")
|
|
md_lines.append("")
|
|
|
|
if structured_data.get('aplicabilidade'):
|
|
md_lines.append("**Aplicabilidade**:")
|
|
for app in structured_data['aplicabilidade']:
|
|
md_lines.append(f"- {app}")
|
|
md_lines.append("")
|
|
|
|
return '\n'.join(md_lines)
|
|
|
|
def process_file(self, input_file: Path, output_dir: Path) -> bool:
|
|
"""Processa um ficheiro."""
|
|
try:
|
|
output_file = output_dir / f"structured_{input_file.name}"
|
|
|
|
# Skip se já existe (compatibilidade com versão AI)
|
|
if output_file.exists():
|
|
logger.info(f"⏭️ Já existe: {output_file.name}")
|
|
return True
|
|
|
|
# Verificar tamanho
|
|
file_size = input_file.stat().st_size
|
|
if file_size < 500:
|
|
logger.warning(f"⚠️ Ficheiro muito pequeno ({file_size}B): {input_file.name}")
|
|
return False
|
|
|
|
# Ler conteúdo
|
|
with open(input_file, 'r', encoding='utf-8') as f:
|
|
content = f.read()
|
|
|
|
logger.info(f"📄 Processando: {input_file.name} ({file_size/1024:.1f}KB)")
|
|
|
|
# Estruturar com heurísticas LOCAL
|
|
structured_data = self.structure_content(content, input_file.name)
|
|
|
|
# Converter para MD formatado
|
|
formatted_md = self.format_structured_md(structured_data, input_file.name)
|
|
|
|
# Guardar MD
|
|
with open(output_file, 'w', encoding='utf-8') as f:
|
|
f.write(formatted_md)
|
|
|
|
# Guardar JSON
|
|
json_file = output_dir / f"structured_{input_file.stem}.json"
|
|
with open(json_file, 'w', encoding='utf-8') as f:
|
|
json.dump(structured_data, f, indent=2, ensure_ascii=False)
|
|
|
|
logger.info(f"✅ Guardado: {output_file.name}")
|
|
|
|
return True
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Erro ao processar {input_file.name}: {e}")
|
|
return False
|
|
|
|
|
|
def main():
|
|
"""Função principal."""
|
|
input_path = Path(INPUT_DIR)
|
|
output_path = Path(OUTPUT_DIR)
|
|
|
|
if not input_path.exists():
|
|
logger.error(f"❌ Diretório não existe: {INPUT_DIR}")
|
|
return
|
|
|
|
output_path.mkdir(parents=True, exist_ok=True)
|
|
|
|
# Encontrar TODOS os ficheiros .md
|
|
all_files = list(input_path.glob('*.md'))
|
|
|
|
logger.info(f"📊 Encontrados {len(all_files)} ficheiros para processar")
|
|
|
|
# Contar já processados
|
|
existing = list(output_path.glob('structured_*.md'))
|
|
logger.info(f"✅ Já processados: {len(existing)} ficheiros")
|
|
logger.info(f"⏳ Restantes: {len(all_files) - len(existing)} ficheiros")
|
|
|
|
# Processar
|
|
structurer = LocalContentStructurer()
|
|
successful = 0
|
|
skipped = 0
|
|
failed = 0
|
|
|
|
for i, md_file in enumerate(all_files, 1):
|
|
logger.info(f"\n[{i}/{len(all_files)}]")
|
|
|
|
result = structurer.process_file(md_file, output_path)
|
|
|
|
if result:
|
|
if (output_path / f"structured_{md_file.name}").stat().st_mtime > md_file.stat().st_mtime:
|
|
successful += 1
|
|
else:
|
|
skipped += 1
|
|
else:
|
|
failed += 1
|
|
|
|
logger.info("")
|
|
logger.info("═══════════════════════════════════════════════════════════")
|
|
logger.info(f"✅ Concluído!")
|
|
logger.info(f" • Processados: {successful}")
|
|
logger.info(f" • Já existiam: {skipped}")
|
|
logger.info(f" • Falhados: {failed}")
|
|
logger.info(f" • Total: {len(all_files)}")
|
|
logger.info(f"📁 Output: {output_path}")
|
|
logger.info("═══════════════════════════════════════════════════════════")
|
|
|
|
|
|
if __name__ == '__main__':
|
|
print("═══════════════════════════════════════════════════════════")
|
|
print(" 🔧 CTF CARSTUFF - ESTRUTURAÇÃO LOCAL (SEM CUSTOS)")
|
|
print(" Método: Regex + Heurísticas")
|
|
print(" Formato: Problema → Solução → Resultado")
|
|
print("═══════════════════════════════════════════════════════════")
|
|
print("")
|
|
main()
|
|
print("")
|
|
print("✅ Processo concluído!")
|