Upload convert_md.py

2c7e131 verified 9 months ago

10.7 kB

"""
Conversão otimizada de PDF → Markdown para grandes volumes de Doutrinas.
Dois modos:
  rapido   (padrão) - Extração direta via engine C do PyMuPDF, ~5-10x mais rápido
  completo          - Via pymupdf4llm, melhor para tabelas complexas
Usa ProcessPoolExecutor para paralelismo real (bypass GIL).
"""

import os
import sys
import argparse
import warnings
import time
from pathlib import Path
from typing import List, Dict, Optional, Tuple
from collections import Counter
from concurrent.futures import ProcessPoolExecutor, as_completed

from tqdm import tqdm

warnings.filterwarnings("ignore")

try:
    import pymupdf
except ImportError:
    print("ERRO: PyMuPDF não encontrado.")
    print("  pip install pymupdf pymupdf4llm")
    sys.exit(1)

# =============================================================================
# CONFIGURAÇÃO
# =============================================================================

BASE_DOUTRINAS_PATH = Path("data/Doutrinas")
OUTPUT_DIR = Path("data/pymupdf_output")


# =============================================================================
# EXTRAÇÃO RÁPIDA (PyMuPDF C-engine direto)
# =============================================================================

def _detectar_corpo(pages_data: list) -> float:
    """Descobre tamanho de fonte do corpo (mais frequente por nº de caracteres)."""
    size_chars: Counter = Counter()
    for data in pages_data:
        for block in data["blocks"]:
            if block["type"] != 0:
                continue
            for line in block["lines"]:
                for span in line["spans"]:
                    t = span["text"].strip()
                    if t:
                        size_chars[round(span["size"], 1)] += len(t)
    return size_chars.most_common(1)[0][0] if size_chars else 12.0


def _formatar_span(span: dict) -> str:
    """Aplica bold/itálico a um span."""
    texto = span["text"]
    t = texto.strip()
    if not t:
        return texto  # preserva espaços

    flags = span["flags"]
    is_bold = bool(flags & 16)    # bit 4
    is_italic = bool(flags & 2)   # bit 1

    if is_bold and is_italic:
        return f"***{t}*** "
    elif is_bold:
        return f"**{t}** "
    elif is_italic:
        return f"*{t}* "
    return texto


def _formatar_bloco(block: dict, body_size: float) -> Optional[str]:
    """Converte um bloco de texto em parágrafo markdown."""
    if block["type"] != 0:
        return None

    linhas_formatadas = []

    for line in block["lines"]:
        # Formatar cada span
        partes = [_formatar_span(s) for s in line["spans"]]
        linha = "".join(partes).strip()
        if not linha:
            continue

        # Detectar título pela fonte
        sizes = [round(s["size"], 1) for s in line["spans"] if s["text"].strip()]
        if sizes:
            ratio = max(sizes) / body_size if body_size > 0 else 1
            if ratio > 1.5:
                linha = f"# {linha}"
            elif ratio > 1.3:
                linha = f"## {linha}"
            elif ratio > 1.15:
                linha = f"### {linha}"

        linhas_formatadas.append(linha)

    if not linhas_formatadas:
        return None

    # Se é título, retorna direto
    if len(linhas_formatadas) == 1 and linhas_formatadas[0].startswith("#"):
        return linhas_formatadas[0]

    # Juntar linhas do parágrafo com dehyphenation
    resultado = linhas_formatadas[0]
    for proxima in linhas_formatadas[1:]:
        # Se termina com hífen (quebra de sílaba), remove e junta
        if resultado.endswith("­") or resultado.endswith("-"):
            # Não tratar traços que são realmente pontuação (ex: " - ")
            if not resultado.endswith(" -"):
                resultado = resultado[:-1] + proxima
                continue
        resultado = resultado + " " + proxima

    return resultado


def _extrair_rapido(caminho_str: str) -> Tuple[str, int]:
    """
    Extração rápida via engine C do PyMuPDF.
    Usa get_text("dict") que roda em C e faz formatação leve em Python.
    """
    doc = pymupdf.open(caminho_str)
    num_pages = len(doc)

    if num_pages == 0:
        doc.close()
        return "", 0

    # Extrair dicts estruturados de todas as páginas (C-level, muito rápido)
    pages_data = [page.get_text("dict") for page in doc]
    doc.close()

    # Detectar tamanho do corpo do texto
    body_size = _detectar_corpo(pages_data)

    # Formatar markdown
    page_parts = []

    for data in pages_data:
        blocos = []
        for block in data["blocks"]:
            formatado = _formatar_bloco(block, body_size)
            if formatado:
                blocos.append(formatado)

        if blocos:
            page_parts.append("\n\n".join(blocos))

    return "\n\n---\n\n".join(page_parts), num_pages


# =============================================================================
# EXTRAÇÃO COMPLETA (pymupdf4llm - mais lenta, melhor para tabelas)
# =============================================================================

def _extrair_completo(caminho_str: str) -> Tuple[str, int]:
    """Extração via pymupdf4llm (Python pesado, melhor qualidade em tabelas)."""
    import pymupdf4llm as p4l

    doc = pymupdf.open(caminho_str)
    num_pages = len(doc)
    conteudo = p4l.to_markdown(doc, write_images=False)
    doc.close()
    return conteudo, num_pages


# =============================================================================
# WORKERS (rodam em processos separados)
# =============================================================================

def _worker(args: Tuple[str, str, str]) -> Dict:
    """Worker genérico para ProcessPoolExecutor."""
    caminho_str, base_str, modo = args
    caminho = Path(caminho_str)

    try:
        pasta_rel = str(caminho.parent.relative_to(base_str))
    except ValueError:
        pasta_rel = caminho.parent.name

    resultado = {
        "nome": caminho.name,
        "pasta_relativa": pasta_rel,
        "sucesso": False,
        "erro": None,
        "num_paginas": 0,
        "conteudo": None,
        "tempo": 0,
    }

    t0 = time.perf_counter()
    try:
        if modo == "rapido":
            conteudo, npages = _extrair_rapido(caminho_str)
        else:
            conteudo, npages = _extrair_completo(caminho_str)

        resultado["conteudo"] = conteudo
        resultado["num_paginas"] = npages
        resultado["sucesso"] = True
    except Exception as e:
        resultado["erro"] = f"{type(e).__name__}: {str(e)[:200]}"

    resultado["tempo"] = time.perf_counter() - t0
    return resultado


# =============================================================================
# FUNÇÕES AUXILIARES
# =============================================================================

def listar_pdfs(pasta_base: Path, pasta_especifica: Optional[str] = None) -> List[Path]:
    if pasta_especifica:
        pasta_alvo = pasta_base / pasta_especifica
        if not pasta_alvo.exists():
            return []
        pasta_base = pasta_alvo
    return sorted(p for p in pasta_base.rglob("*") if p.suffix.lower() == ".pdf")


def salvar_resultado(resultado: Dict, output_dir: Path):
    if not resultado["sucesso"] or not resultado.get("conteudo"):
        return
    pasta_saida = output_dir / resultado["pasta_relativa"]
    pasta_saida.mkdir(parents=True, exist_ok=True)
    arquivo = pasta_saida / f"{Path(resultado['nome']).stem}.md"
    arquivo.write_text(resultado["conteudo"], encoding="utf-8")


# =============================================================================
# MAIN
# =============================================================================

def main():
    parser = argparse.ArgumentParser(
        description="Conversão PDF → Markdown (otimizada para grandes volumes)"
    )
    parser.add_argument("--limite", "-l", type=int, default=None)
    parser.add_argument("--pasta", "-p", type=str, default=None)
    parser.add_argument("--salvar", "-s", action="store_true")
    parser.add_argument(
        "--workers", "-w", type=int,
        default=max(1, os.cpu_count() or 4),
        help="Processos paralelos (padrão: todos os CPUs)",
    )
    parser.add_argument(
        "--modo", "-m", choices=["rapido", "completo"], default="rapido",
        help="rapido = PyMuPDF direto (~5-10x mais rápido) | completo = pymupdf4llm",
    )
    args = parser.parse_args()

    if not BASE_DOUTRINAS_PATH.exists():
        print(f"[ERRO] {BASE_DOUTRINAS_PATH} não existe.")
        sys.exit(1)

    pdfs = listar_pdfs(BASE_DOUTRINAS_PATH, args.pasta)
    if args.limite:
        pdfs = pdfs[:args.limite]

    if not pdfs:
        print("[!] Nenhum PDF encontrado.")
        sys.exit(0)

    if args.salvar:
        OUTPUT_DIR.mkdir(parents=True, exist_ok=True)

    modo_label = (
        "RÁPIDO (PyMuPDF C-engine direto)"
        if args.modo == "rapido"
        else "COMPLETO (pymupdf4llm)"
    )

    print(f"[*] Modo: {modo_label}")
    print(f"[*] PDFs: {len(pdfs)} | Workers: {args.workers}")
    print()
    sys.stdout.flush()

    base_str = str(BASE_DOUTRINAS_PATH)
    worker_args = [(str(pdf), base_str, args.modo) for pdf in pdfs]

    sucessos = 0
    falhas = []
    t_inicio = time.perf_counter()

    with ProcessPoolExecutor(max_workers=args.workers) as executor:
        futures = {executor.submit(_worker, a): a for a in worker_args}

        with tqdm(total=len(pdfs), desc="Convertendo", unit="pdf") as pbar:
            for future in as_completed(futures):
                res = future.result()

                if res["sucesso"]:
                    sucessos += 1
                    if args.salvar:
                        salvar_resultado(res, OUTPUT_DIR)
                else:
                    falhas.append({"nome": res["nome"], "erro": res.get("erro")})

                res.pop("conteudo", None)  # liberar memória
                pbar.update(1)

    t_total = time.perf_counter() - t_inicio
    total = len(pdfs)

    print(f"\n{'='*50}")
    print(f" Modo:   {modo_label}")
    print(f" Tempo:  {t_total:.1f}s")
    print(f" OK:     {sucessos}/{total}")
    print(f" Falhas: {len(falhas)}/{total}")
    print(f" Média:  {t_total/max(total,1):.2f}s/PDF")
    print(f" Veloc.: {total/max(t_total,0.01):.1f} PDFs/s")
    print(f"{'='*50}")

    if falhas:
        erros = Counter()
        for f in falhas:
            tipo = (f["erro"] or "").split(":")[0] or "?"
            erros[tipo] += 1

        print(f"\nErros ({len(falhas)}):")
        for tipo, n in erros.most_common():
            print(f"  {tipo}: {n}x")

        print()
        for f in falhas[:5]:
            print(f"  {f['nome']} → {f['erro']}")


if __name__ == "__main__":
    main()

	"""
	Conversão otimizada de PDF → Markdown para grandes volumes de Doutrinas.

	Dois modos:
	rapido (padrão) - Extração direta via engine C do PyMuPDF, ~5-10x mais rápido
	completo - Via pymupdf4llm, melhor para tabelas complexas

	Usa ProcessPoolExecutor para paralelismo real (bypass GIL).
	"""

	import os
	import sys
	import argparse
	import warnings
	import time
	from pathlib import Path
	from typing import List, Dict, Optional, Tuple
	from collections import Counter
	from concurrent.futures import ProcessPoolExecutor, as_completed

	from tqdm import tqdm

	warnings.filterwarnings("ignore")

	try:
	import pymupdf
	except ImportError:
	print("ERRO: PyMuPDF não encontrado.")
	print(" pip install pymupdf pymupdf4llm")
	sys.exit(1)

	# =============================================================================
	# CONFIGURAÇÃO
	# =============================================================================

	BASE_DOUTRINAS_PATH = Path("data/Doutrinas")
	OUTPUT_DIR = Path("data/pymupdf_output")


	# =============================================================================
	# EXTRAÇÃO RÁPIDA (PyMuPDF C-engine direto)
	# =============================================================================

	def _detectar_corpo(pages_data: list) -> float:
	"""Descobre tamanho de fonte do corpo (mais frequente por nº de caracteres)."""
	size_chars: Counter = Counter()
	for data in pages_data:
	for block in data["blocks"]:
	if block["type"] != 0:
	continue
	for line in block["lines"]:
	for span in line["spans"]:
	t = span["text"].strip()
	if t:
	size_chars[round(span["size"], 1)] += len(t)
	return size_chars.most_common(1)[0][0] if size_chars else 12.0


	def _formatar_span(span: dict) -> str:
	"""Aplica bold/itálico a um span."""
	texto = span["text"]
	t = texto.strip()
	if not t:
	return texto # preserva espaços

	flags = span["flags"]
	is_bold = bool(flags & 16) # bit 4
	is_italic = bool(flags & 2) # bit 1

	if is_bold and is_italic:
	return f"*{t}* "
	elif is_bold:
	return f"{t} "
	elif is_italic:
	return f"{t} "
	return texto


	def _formatar_bloco(block: dict, body_size: float) -> Optional[str]:
	"""Converte um bloco de texto em parágrafo markdown."""
	if block["type"] != 0:
	return None

	linhas_formatadas = []

	for line in block["lines"]:
	# Formatar cada span
	partes = [_formatar_span(s) for s in line["spans"]]
	linha = "".join(partes).strip()
	if not linha:
	continue

	# Detectar título pela fonte
	sizes = [round(s["size"], 1) for s in line["spans"] if s["text"].strip()]
	if sizes:
	ratio = max(sizes) / body_size if body_size > 0 else 1
	if ratio > 1.5:
	linha = f"# {linha}"
	elif ratio > 1.3:
	linha = f"## {linha}"
	elif ratio > 1.15:
	linha = f"### {linha}"

	linhas_formatadas.append(linha)

	if not linhas_formatadas:
	return None

	# Se é título, retorna direto
	if len(linhas_formatadas) == 1 and linhas_formatadas[0].startswith("#"):
	return linhas_formatadas[0]

	# Juntar linhas do parágrafo com dehyphenation
	resultado = linhas_formatadas[0]
	for proxima in linhas_formatadas[1:]:
	# Se termina com hífen (quebra de sílaba), remove e junta
	if resultado.endswith("") or resultado.endswith("-"):
	# Não tratar traços que são realmente pontuação (ex: " - ")
	if not resultado.endswith(" -"):
	resultado = resultado[:-1] + proxima
	continue
	resultado = resultado + " " + proxima

	return resultado


	def _extrair_rapido(caminho_str: str) -> Tuple[str, int]:
	"""
	Extração rápida via engine C do PyMuPDF.
	Usa get_text("dict") que roda em C e faz formatação leve em Python.
	"""
	doc = pymupdf.open(caminho_str)
	num_pages = len(doc)

	if num_pages == 0:
	doc.close()
	return "", 0

	# Extrair dicts estruturados de todas as páginas (C-level, muito rápido)
	pages_data = [page.get_text("dict") for page in doc]
	doc.close()

	# Detectar tamanho do corpo do texto
	body_size = _detectar_corpo(pages_data)

	# Formatar markdown
	page_parts = []

	for data in pages_data:
	blocos = []
	for block in data["blocks"]:
	formatado = _formatar_bloco(block, body_size)
	if formatado:
	blocos.append(formatado)

	if blocos:
	page_parts.append("\n\n".join(blocos))

	return "\n\n---\n\n".join(page_parts), num_pages


	# =============================================================================
	# EXTRAÇÃO COMPLETA (pymupdf4llm - mais lenta, melhor para tabelas)
	# =============================================================================

	def _extrair_completo(caminho_str: str) -> Tuple[str, int]:
	"""Extração via pymupdf4llm (Python pesado, melhor qualidade em tabelas)."""
	import pymupdf4llm as p4l

	doc = pymupdf.open(caminho_str)
	num_pages = len(doc)
	conteudo = p4l.to_markdown(doc, write_images=False)
	doc.close()
	return conteudo, num_pages


	# =============================================================================
	# WORKERS (rodam em processos separados)
	# =============================================================================

	def _worker(args: Tuple[str, str, str]) -> Dict:
	"""Worker genérico para ProcessPoolExecutor."""
	caminho_str, base_str, modo = args
	caminho = Path(caminho_str)

	try:
	pasta_rel = str(caminho.parent.relative_to(base_str))
	except ValueError:
	pasta_rel = caminho.parent.name

	resultado = {
	"nome": caminho.name,
	"pasta_relativa": pasta_rel,
	"sucesso": False,
	"erro": None,
	"num_paginas": 0,
	"conteudo": None,
	"tempo": 0,
	}

	t0 = time.perf_counter()
	try:
	if modo == "rapido":
	conteudo, npages = _extrair_rapido(caminho_str)
	else:
	conteudo, npages = _extrair_completo(caminho_str)

	resultado["conteudo"] = conteudo
	resultado["num_paginas"] = npages
	resultado["sucesso"] = True
	except Exception as e:
	resultado["erro"] = f"{type(e).__name__}: {str(e)[:200]}"

	resultado["tempo"] = time.perf_counter() - t0
	return resultado


	# =============================================================================
	# FUNÇÕES AUXILIARES
	# =============================================================================

	def listar_pdfs(pasta_base: Path, pasta_especifica: Optional[str] = None) -> List[Path]:
	if pasta_especifica:
	pasta_alvo = pasta_base / pasta_especifica
	if not pasta_alvo.exists():
	return []
	pasta_base = pasta_alvo
	return sorted(p for p in pasta_base.rglob("*") if p.suffix.lower() == ".pdf")


	def salvar_resultado(resultado: Dict, output_dir: Path):
	if not resultado["sucesso"] or not resultado.get("conteudo"):
	return
	pasta_saida = output_dir / resultado["pasta_relativa"]
	pasta_saida.mkdir(parents=True, exist_ok=True)
	arquivo = pasta_saida / f"{Path(resultado['nome']).stem}.md"
	arquivo.write_text(resultado["conteudo"], encoding="utf-8")


	# =============================================================================
	# MAIN
	# =============================================================================

	def main():
	parser = argparse.ArgumentParser(
	description="Conversão PDF → Markdown (otimizada para grandes volumes)"
	)
	parser.add_argument("--limite", "-l", type=int, default=None)
	parser.add_argument("--pasta", "-p", type=str, default=None)
	parser.add_argument("--salvar", "-s", action="store_true")
	parser.add_argument(
	"--workers", "-w", type=int,
	default=max(1, os.cpu_count() or 4),
	help="Processos paralelos (padrão: todos os CPUs)",
	)
	parser.add_argument(
	"--modo", "-m", choices=["rapido", "completo"], default="rapido",
	help="rapido = PyMuPDF direto (~5-10x mais rápido) \| completo = pymupdf4llm",
	)
	args = parser.parse_args()

	if not BASE_DOUTRINAS_PATH.exists():
	print(f"[ERRO] {BASE_DOUTRINAS_PATH} não existe.")
	sys.exit(1)

	pdfs = listar_pdfs(BASE_DOUTRINAS_PATH, args.pasta)
	if args.limite:
	pdfs = pdfs[:args.limite]

	if not pdfs:
	print("[!] Nenhum PDF encontrado.")
	sys.exit(0)

	if args.salvar:
	OUTPUT_DIR.mkdir(parents=True, exist_ok=True)

	modo_label = (
	"RÁPIDO (PyMuPDF C-engine direto)"
	if args.modo == "rapido"
	else "COMPLETO (pymupdf4llm)"
	)

	print(f"[*] Modo: {modo_label}")
	print(f"[*] PDFs: {len(pdfs)} \| Workers: {args.workers}")
	print()
	sys.stdout.flush()

	base_str = str(BASE_DOUTRINAS_PATH)
	worker_args = [(str(pdf), base_str, args.modo) for pdf in pdfs]

	sucessos = 0
	falhas = []
	t_inicio = time.perf_counter()

	with ProcessPoolExecutor(max_workers=args.workers) as executor:
	futures = {executor.submit(_worker, a): a for a in worker_args}

	with tqdm(total=len(pdfs), desc="Convertendo", unit="pdf") as pbar:
	for future in as_completed(futures):
	res = future.result()

	if res["sucesso"]:
	sucessos += 1
	if args.salvar:
	salvar_resultado(res, OUTPUT_DIR)
	else:
	falhas.append({"nome": res["nome"], "erro": res.get("erro")})

	res.pop("conteudo", None) # liberar memória
	pbar.update(1)

	t_total = time.perf_counter() - t_inicio
	total = len(pdfs)

	print(f"\n{'='*50}")
	print(f" Modo: {modo_label}")
	print(f" Tempo: {t_total:.1f}s")
	print(f" OK: {sucessos}/{total}")
	print(f" Falhas: {len(falhas)}/{total}")
	print(f" Média: {t_total/max(total,1):.2f}s/PDF")
	print(f" Veloc.: {total/max(t_total,0.01):.1f} PDFs/s")
	print(f"{'='*50}")

	if falhas:
	erros = Counter()
	for f in falhas:
	tipo = (f["erro"] or "").split(":")[0] or "?"
	erros[tipo] += 1

	print(f"\nErros ({len(falhas)}):")
	for tipo, n in erros.most_common():
	print(f" {tipo}: {n}x")

	print()
	for f in falhas[:5]:
	print(f" {f['nome']} → {f['erro']}")


	if __name__ == "__main__":
	main()