Document Processing Pipeline

def slugify_ascii(name: str) -> str:
    normalized = unicodedata.normalize("NFKD", name)
    ascii_only = normalized.encode("ascii", "ignore").decode("ascii")
    collapsed  = re.sub(r"[\s\-/]+", "_", ascii_only.lower())
    cleaned    = re.sub(r"[^a-z0-9_]", "", collapsed)
    cleaned    = re.sub(r"_+", "_", cleaned).strip("_")
    return cleaned or "sin_nombre"

def make_unique_columns(columns: list[str]) -> list[str]:
    used:   dict[str, int] = {}
    unique: list[str]      = []
    for col in columns:
        base  = col or "columna"
        count = used.get(base, 0) + 1
        used[base] = count
        unique.append(base if count == 1 else f"{base}_{count}")
    return unique

CHUNK_SIZE             = 800    # Maximum chars per chunk
CHUNK_OVERLAP          = 300    # Chars shared between chunks (37.5%)
MAX_CHUNKS_CONTEXTO    = 3      # Max chunks sent to model per document

def _ultimo_encabezado(texto: str) -> str:
    """Encuentra el último encabezado Markdown en un texto."""
    encabezados = re.findall(r'^#{1,3}\s+(.+)$', texto, re.MULTILINE)
    if encabezados:
        return re.sub(r'[*_`]', '', encabezados[-1]).strip().upper()
    return "INICIO"

print(f"  [KW]  TF-IDF '{nombre_col}' ({len(docs_col)} docs)...")
keywords_col = calcular_tfidf_coleccion(docs_col)

for nd, kws in list(keywords_col.items())[:2]:
    print(f"  [KW]  {nd}: {kws[:6]}")

nuevas_colecciones[nombre_col] = {
    "docs":     docs_col,
    "keywords": keywords_col,
}

nuevo_indice = defaultdict(list)
for nombre_doc, doc in todos_los_docs.items():
    total = doc["total_tokens"]
    if total == 0:
        continue
    for termino, freq in doc["token_count"].items():
        if len(termino) >= MIN_LEN_KEYWORD:
            nuevo_indice[termino].append((freq / total, nombre_doc))

for t in nuevo_indice:
    nuevo_indice[t].sort(reverse=True)

chunks = chunking_con_solapamiento(contenido)
nuevos_chunks[nombre_clave] = chunks

def cargar_documentos():
    global documentos_cargados, colecciones, indice_densidad, chunks_por_doc

    if not os.path.exists(CARPETA_FUENTES):
        os.makedirs(CARPETA_FUENTES, exist_ok=True)
        return

    nuevas_colecciones = {}
    todos_los_docs     = {}
    nuevos_chunks      = {}

    # Scan folders (general + subcarpetas)
    subcarpetas = [("general", CARPETA_FUENTES)]
    try:
        for entrada in os.scandir(CARPETA_FUENTES):
            if entrada.is_dir():
                subcarpetas.append((entrada.name.lower(), entrada.path))
    except Exception as e:
        print(f"  [Docs] Error escaneando: {e}")

    for nombre_col, ruta_col in subcarpetas:
        # Load .md and .txt files
        archivos = [
            os.path.join(ruta_col, f)
            for f in os.listdir(ruta_col)
            if f.lower().endswith(('.md', '.txt'))
        ]
        
        for ruta in archivos:
            # Read content
            with open(ruta, "r", encoding="utf-8", errors="ignore") as f:
                contenido = f.read()

            # Tokenize
            palabras     = set(tokenizar(contenido))
            tokens       = tokenizar(contenido)
            token_count  = Counter(tokens)

            # Pre-calculate chunks
            chunks = chunking_con_solapamiento(contenido)
            nuevos_chunks[nombre_clave] = chunks

            doc_entry = {
                "ruta":            ruta,
                "nombre_original": nombre_original,
                "contenido":       contenido,
                "palabras":        palabras,
                "tamano":          len(contenido),
                "coleccion":       nombre_col,
                "token_count":     token_count,
                "total_tokens":    len(tokens),
                "tokens_nombre":   _tokens_nombre_archivo(nombre_clave),
                "num_chunks":      len(chunks),
            }
            todos_los_docs[nombre_clave] = doc_entry

        # Build TF-IDF index
        keywords_col = calcular_tfidf_coleccion(docs_col)
        nuevas_colecciones[nombre_col] = {
            "docs":     docs_col,
            "keywords": keywords_col,
        }

    # Build density index
    nuevo_indice = defaultdict(list)
    for nombre_doc, doc in todos_los_docs.items():
        for termino, freq in doc["token_count"].items():
            nuevo_indice[termino].append((freq / doc["total_tokens"], nombre_doc))

    # Update global state (thread-safe)
    with colecciones_lock:
        colecciones = nuevas_colecciones
    with documentos_lock:
        documentos_cargados = todos_los_docs
    with indice_densidad_lock:
        indice_densidad = dict(nuevo_indice)
    with chunks_lock:
        chunks_por_doc = nuevos_chunks

    print(f"  [Doc] Total: {len(todos_los_docs)} docs ✓")
    print(f"  [IDX] Índice densidad: {len(nuevo_indice):,} términos ✓")
    print(f"  [CHK] Chunks pre-calculados: {sum(len(v) for v in nuevos_chunks.values())} total ✓")

DEFAULT_ORIGEN  = Path("/opt/siaa/instructivos")    # Word + PDF + Excel
DEFAULT_DEST_MD = Path("/opt/siaa/fuentes")         # Output .md files
DEFAULT_DB      = Path("/opt/siaa/institucional.db") # SQLite database
DEFAULT_LOG     = Path("/opt/siaa/logs/conversion_errores.log")
TEMP_DIR        = Path("/tmp/siaa_temp")             # Temp .docx files

# Recargar índice SIAA automáticamente
if RECARGAR_AUTO and any(r.md_ok for r in results):
    try:
        import requests
        resp  = requests.get(PROXY_RECARGAR, timeout=15)
        total = resp.json().get("total_docs", "?")
        print(f"  [Proxy] Índice recargado: {total} documentos ✓")
    except Exception:
        print(f"  [Proxy] Recarga manual: curl {PROXY_RECARGAR}")

def _write_error_md(md_path: Path, folder_name: str, archivo: str, detalle: str) -> None:
    """Escribe un Markdown de error cuando la conversión falla."""
    contenido = (
        f"# {folder_name}\n\n"
        "## Estado de conversion\n\n"
        f"- Archivo detectado: `{archivo}`\n"
        "- Resultado: ERROR\n"
        f"- Detalle: {detalle}\n"
    )
    md_path.write_text(contenido, encoding="utf-8")