Files
API-WINDNAS/app/busqueda.py

170 lines
7.6 KiB
Python
Raw Permalink Normal View History

"""Búsqueda por contenido en Elasticsearch (índice que arma FSCrawler).
Reglas (las mismas que antes, ahora como consulta de Elasticsearch):
- Cédula: con o sin puntos ("1234567", "1.234.567", "1,234,567") en el contenido,
o dentro de la ruta/nombre del archivo.
- Nombre, en cualquier orden:
* completo: aparecen TODOS los nombres y apellidos cerca entre sí.
* parcial: aparecen el primer nombre y el primer apellido juntos ("Juan Pérez", "Pérez, Juan").
Orden de los resultados: cédula + nombre > cédula > nombre completo > nombre parcial,
y dentro de cada grupo, el archivo modificado más recientemente primero.
Campos que usa (los que genera FSCrawler): content, file.filename, file.extension,
file.filesize, file.last_modified, path.virtual.
"""
import re
from dataclasses import dataclass
from datetime import datetime
from app import elastic
from app.config import get_settings
from app.utils import normalizar, solo_digitos
DISTANCIA_COMPLETO = 6 # máximo de palabras entre nombres/apellidos para "completo"
DISTANCIA_PARCIAL = 2 # "Juan Pérez", "Pérez, Juan", "Juan C. Pérez"
# Puntaje fijo por tipo de coincidencia: define el orden sin depender de la relevancia
PESO_CEDULA, PESO_COMPLETO, PESO_PARCIAL = 1000, 100, 10
CAMPOS = ["file.filename", "file.extension", "file.filesize", "file.last_modified", "path.virtual"]
@dataclass(frozen=True)
class Palabra:
original: str # como la escribió el usuario, en minúsculas ("pérez")
normal: str # sin tildes ("perez")
@dataclass
class Coincidencia:
doc_id: str
nombre: str
ruta_relativa: str
carpeta: str
extension: str
tamano_bytes: int
modificado_en: datetime | None
coincide_cedula: bool
coincide_nombre: str | None # "completo" | "parcial" | None
fragmento: str
def _palabras(texto: str | None) -> list[Palabra]:
# Solo letras y números: el texto del usuario nunca llega crudo a la consulta
return [Palabra(p, normalizar(p)) for p in re.split(r"[^\w]+", (texto or "").lower().replace("_", " ")) if p]
def validar(cedula: str | None, nombres: str | None,
apellidos: str | None) -> tuple[str, list[Palabra], list[Palabra]]:
"""Devuelve (cedula_limpia, palabras_nombres, palabras_apellidos) o lanza ValueError."""
ced = solo_digitos(cedula or "")
if cedula and len(ced) < 5:
raise ValueError("La cédula debe tener al menos 5 dígitos")
nom, ape = _palabras(nombres), _palabras(apellidos)
if (nom and not ape) or (ape and not nom):
raise ValueError("Para buscar por nombre enviá nombres y apellidos juntos")
if not ced and not nom:
raise ValueError("Enviá la cédula, o nombres y apellidos (o los tres)")
return ced, nom, ape
def variantes_cedula(cedula: str) -> list[str]:
"""'1234567' -> ['1234567', '1.234.567', '1,234,567'].
Elasticsearch guarda "1.234.567" como una sola palabra, por eso se buscan las tres formas."""
grupos, resto = [], cedula
while len(resto) > 3:
grupos.insert(0, resto[-3:])
resto = resto[:-3]
grupos.insert(0, resto)
return list(dict.fromkeys([cedula, ".".join(grupos), ",".join(grupos)]))
def _regla(p: Palabra) -> dict:
"""Busca la palabra con y sin tilde. Si el índice ya ignora tildes (asciifolding),
las dos formas dan lo mismo; si no, al menos coincide lo que se escribió igual."""
if p.original == p.normal:
return {"match": {"query": p.normal}}
return {"any_of": {"intervals": [{"match": {"query": p.original}}, {"match": {"query": p.normal}}]}}
def _cerca(palabras: list[Palabra], distancia: int) -> dict:
return {"intervals": {"content": {"all_of": {
"ordered": False, "max_gaps": distancia, "intervals": [_regla(p) for p in palabras]}}}}
def armar_consulta(cedula: str, nombres: list[Palabra], apellidos: list[Palabra], limite: int) -> dict:
"""Cuerpo de la búsqueda para Elasticsearch (función aparte para poder probarla)."""
should, resaltar = [], []
if cedula:
variantes = variantes_cedula(cedula)
filtro = {"bool": {"should": [{"match_phrase": {"content": v}} for v in variantes]
+ [{"wildcard": {"path.virtual": {"value": f"*{cedula}*"}}}]}}
should.append({"constant_score": {"filter": filtro, "boost": PESO_CEDULA, "_name": "cedula"}})
resaltar += [{"match_phrase": {"content": v}} for v in variantes]
if nombres:
todas = nombres + apellidos
should.append({"constant_score": {"filter": _cerca(todas, DISTANCIA_COMPLETO),
"boost": PESO_COMPLETO, "_name": "nombre_completo"}})
should.append({"constant_score": {"filter": _cerca([nombres[0], apellidos[0]], DISTANCIA_PARCIAL),
"boost": PESO_PARCIAL, "_name": "nombre_parcial"}})
palabras = " ".join(dict.fromkeys([p.original for p in todas] + [p.normal for p in todas]))
resaltar.append({"match": {"content": palabras}})
# Segunda barrera: carpetas que nunca se devuelven aunque FSCrawler las haya indexado
excluir = [{"prefix": {"path.virtual": f"/{c}/"}} for c in get_settings().carpetas_excluidas]
return {
"query": {"bool": {"should": should, "minimum_should_match": 1, "must_not": excluir}},
"sort": ["_score", {"file.last_modified": {"order": "desc", "unmapped_type": "date"}}],
"size": limite,
"track_total_hits": True,
"_source": CAMPOS, # nunca se trae "content": puede pesar megas por documento
"highlight": {
"pre_tags": ["«"], "post_tags": ["»"],
"fields": {"content": {"type": "unified", "fragment_size": 160, "number_of_fragments": 1,
"highlight_query": {"bool": {"should": resaltar}}}},
},
}
def a_ruta_relativa(path_virtual: str) -> str:
"""FSCrawler guarda '/IPS/planilla.xlsx' relativo a la carpeta que recorre (fs.url)."""
return path_virtual.lstrip("/")
def _extension(valor: str | None) -> str:
valor = (valor or "").lower()
return valor if not valor or valor.startswith(".") else f".{valor}" # FSCrawler guarda "pdf"
def buscar(cedula: str, nombres: list[Palabra], apellidos: list[Palabra],
limite: int) -> tuple[list[Coincidencia], int]:
"""Devuelve (las `limite` mejores coincidencias, total de archivos que coinciden)."""
respuesta = elastic.buscar(armar_consulta(cedula, nombres, apellidos, limite))
hits = respuesta.get("hits", {})
total = hits.get("total", {})
total = total.get("value", 0) if isinstance(total, dict) else int(total)
resultados = []
for h in hits.get("hits", []):
fuente = h.get("_source", {})
archivo, ruta = fuente.get("file", {}), fuente.get("path", {})
nombradas = h.get("matched_queries", []) # lista (o dict en versiones nuevas)
ruta_rel = a_ruta_relativa(ruta.get("virtual", ""))
resultados.append(Coincidencia(
doc_id=h["_id"],
nombre=archivo.get("filename") or ruta_rel.rsplit("/", 1)[-1],
ruta_relativa=ruta_rel,
carpeta=ruta_rel.rsplit("/", 1)[0] if "/" in ruta_rel else "",
extension=_extension(archivo.get("extension")),
tamano_bytes=int(archivo.get("filesize") or 0),
modificado_en=archivo.get("last_modified"),
coincide_cedula="cedula" in nombradas,
coincide_nombre=("completo" if "nombre_completo" in nombradas
else "parcial" if "nombre_parcial" in nombradas else None),
fragmento=" ".join(" ".join(h.get("highlight", {}).get("content", [""])).split()),
))
return resultados, total