138 lines
4.4 KiB
Python
138 lines
4.4 KiB
Python
"""Persistencia simple de preferencias de la GUI."""
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import logging
|
|
import re
|
|
from pathlib import Path
|
|
from typing import Any, Dict, Optional
|
|
|
|
from .config import DEFAULT_ALLOWED_DOCUMENT_TYPES
|
|
from .csv_cleaning import DEFAULT_MODERADORA_BY_YEAR, normalize_moderadora_by_year_dict
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
PREFS_FILE = Path(__file__).resolve().parent.parent / "app_prefs.json"
|
|
|
|
|
|
def moderadora_by_year_to_json_dict(
|
|
data: dict[int, set[int]],
|
|
) -> dict[str, list[int]]:
|
|
"""Serializa año → conjunto de cuotas a JSON (claves str, listas ordenadas)."""
|
|
out: dict[str, list[int]] = {}
|
|
for y in sorted(data.keys()):
|
|
out[str(y)] = sorted(data[y])
|
|
return out
|
|
|
|
|
|
def default_moderadora_by_year_payload() -> dict[str, list[int]]:
|
|
"""Valores por defecto persistibles para cuota moderadora."""
|
|
return moderadora_by_year_to_json_dict(DEFAULT_MODERADORA_BY_YEAR)
|
|
|
|
|
|
def merge_moderadora_prefs(raw: Any) -> dict[str, list[int]]:
|
|
"""Fusiona prefs guardadas con defaults; devuelve año(str) → lista."""
|
|
base = default_moderadora_by_year_payload()
|
|
if not isinstance(raw, dict):
|
|
return base
|
|
parsed = normalize_moderadora_by_year_dict(raw)
|
|
for y, vals in parsed.items():
|
|
base[str(y)] = sorted(vals)
|
|
return base
|
|
|
|
|
|
def format_moderadora_text_from_prefs(payload: dict[str, list[int]]) -> str:
|
|
"""Una línea por año: `2024: 4500, 18200, 47700`."""
|
|
lines: list[str] = []
|
|
for ks in sorted(payload.keys(), key=lambda x: int(x)):
|
|
nums = payload[ks]
|
|
lines.append(f"{ks}: {', '.join(str(n) for n in nums)}")
|
|
return "\n".join(lines)
|
|
|
|
|
|
def parse_moderadora_text(text: str) -> dict[str, list[int]]:
|
|
"""Parsea líneas `año: n1, n2` o `año = n1, n2`. Ignora vacías y errores."""
|
|
out: dict[str, list[int]] = {}
|
|
for line in (text or "").splitlines():
|
|
line = line.strip()
|
|
if not line or line.startswith("#"):
|
|
continue
|
|
m = re.match(r"^\s*(\d{4})\s*[:=]\s*(.+)$", line)
|
|
if not m:
|
|
continue
|
|
yk = m.group(1)
|
|
rest = m.group(2)
|
|
nums: list[int] = []
|
|
for part in re.split(r"[,;\s]+", rest):
|
|
part = part.strip()
|
|
if not part:
|
|
continue
|
|
try:
|
|
nums.append(int(round(float(part))))
|
|
except (TypeError, ValueError):
|
|
continue
|
|
if nums:
|
|
out[yk] = nums
|
|
return out
|
|
|
|
|
|
def load_cop_mod_preferences() -> tuple[dict[str, list[int]], str]:
|
|
"""Lee prefs para COP/MOD: mapa año→lista y nombre sugerido columna fecha."""
|
|
prefs = load_app_prefs()
|
|
merged = merge_moderadora_prefs(prefs.get("moderadora_by_year"))
|
|
fecha_default = str(prefs.get("fecha_servicio_column_default") or "").strip()
|
|
return merged, fecha_default
|
|
|
|
|
|
def build_cop_mod_config_for_apply(
|
|
moderadora_payload: Optional[dict[str, list[int]]] = None,
|
|
) -> dict[str, Any]:
|
|
"""Construye el dict opcional para `csv_cleaning.apply_rules(..., cop_mod_config=)`."""
|
|
if moderadora_payload is None:
|
|
prefs = load_app_prefs()
|
|
merged = merge_moderadora_prefs(prefs.get("moderadora_by_year"))
|
|
else:
|
|
merged = merge_moderadora_prefs(moderadora_payload)
|
|
return {"moderadora_by_year": merged}
|
|
|
|
|
|
def load_app_prefs() -> Dict[str, Any]:
|
|
"""Carga preferencias desde disco si existen."""
|
|
try:
|
|
if not PREFS_FILE.exists():
|
|
return {}
|
|
raw = PREFS_FILE.read_text(encoding="utf-8")
|
|
data = json.loads(raw)
|
|
return data if isinstance(data, dict) else {}
|
|
except Exception:
|
|
logger.exception("No se pudieron cargar las preferencias de la app")
|
|
return {}
|
|
|
|
|
|
def save_app_prefs(data: Dict[str, Any]) -> None:
|
|
"""Guarda preferencias de la app en JSON."""
|
|
try:
|
|
PREFS_FILE.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
|
|
except Exception:
|
|
logger.exception("No se pudieron guardar las preferencias de la app")
|
|
|
|
|
|
def normalize_document_types(values: Any) -> list[str]:
|
|
"""Normaliza una lista editable de tipos documentales."""
|
|
raw_values = values if isinstance(values, list) else []
|
|
normalized: list[str] = []
|
|
seen: set[str] = set()
|
|
for item in raw_values:
|
|
text = str(item or "").strip().upper()
|
|
if not text or text == "NIT" or text in seen:
|
|
continue
|
|
seen.add(text)
|
|
normalized.append(text)
|
|
return normalized or list(DEFAULT_ALLOWED_DOCUMENT_TYPES)
|
|
|
|
|
|
def get_allowed_document_types() -> tuple[str, ...]:
|
|
"""Devuelve la lista persistida de tipos documentales válidos."""
|
|
prefs = load_app_prefs()
|
|
return tuple(normalize_document_types(prefs.get("allowed_document_types")))
|