141 lines
4.2 KiB
Python
141 lines
4.2 KiB
Python
"""Reglas de normalización de fechas a DD/MM/AAAA."""
|
|
from __future__ import annotations
|
|
|
|
from typing import Any, Optional
|
|
|
|
import pandas as pd
|
|
|
|
from ..dates import (
|
|
_detect_compact_date_formats,
|
|
_normalize_messy_date_to_compact,
|
|
_parse_any_date_to_tuple,
|
|
_parse_date_with_format,
|
|
detect_date_format,
|
|
)
|
|
from ..nullish import _is_nullish_scalar
|
|
|
|
|
|
def _rule_date_to_ddmmyyyy(series: pd.Series) -> pd.Series:
|
|
"""Normaliza fechas numéricas, alfanuméricas, con meses en texto y con ruido."""
|
|
stripped = series.astype(str).str.replace(r"[\s\/\-\.]", "", regex=True)
|
|
stripped = stripped.where(series.notna(), other=pd.NA)
|
|
sep_fmt = detect_date_format(series) or detect_date_format(stripped)
|
|
compact8_fmt, compact6_fmt = _detect_compact_date_formats(series)
|
|
|
|
def _fn(x: Any):
|
|
if pd.isna(x) or str(x).strip() == "":
|
|
return x
|
|
parsed = _parse_any_date_to_tuple(
|
|
x,
|
|
sep_fmt=sep_fmt,
|
|
compact8_fmt=compact8_fmt,
|
|
compact6_fmt=compact6_fmt,
|
|
)
|
|
if parsed is None:
|
|
return x
|
|
d, m, y = parsed
|
|
return f"{d:02d}/{m:02d}/{y:04d}"
|
|
|
|
return series.map(_fn)
|
|
|
|
|
|
def _rule_date_numeric_to_ddmmyyyy(series: pd.Series) -> pd.Series:
|
|
"""Entrada: fechas en formato numérico (ej. 20240315 o 15032024).
|
|
|
|
Salida: "DD/MM/AAAA" tras detectar el formato predominante.
|
|
"""
|
|
# Para esta regla consideramos los valores "numéricos" (quitamos separadores
|
|
# comunes si los hay para detectar un YYYYMMDD/DDMMYYYY confiable).
|
|
stripped = series.astype(str).str.replace(r"[\s\/\-\.]", "", regex=True)
|
|
stripped = stripped.where(series.notna(), other=pd.NA)
|
|
fmt = detect_date_format(stripped)
|
|
if fmt is None:
|
|
# fallback: intentar con detector normal
|
|
fmt = detect_date_format(series)
|
|
return _format_dates_to_ddmmyyyy(series, fmt)
|
|
|
|
|
|
def _rule_date_alpha_to_ddmmyyyy(series: pd.Series) -> pd.Series:
|
|
"""Entrada: fechas en formato alfanumérico con separadores.
|
|
|
|
Salida: "DD/MM/AAAA".
|
|
"""
|
|
fmt = detect_date_format(series)
|
|
return _format_dates_to_ddmmyyyy(series, fmt)
|
|
|
|
|
|
def _format_dates_to_ddmmyyyy(series: pd.Series, fmt: Optional[str]) -> pd.Series:
|
|
"""Convierte cada valor al formato DD/MM/AAAA usando `fmt` como layout de
|
|
entrada detectado. La parte de hora (si existe) se descarta. Mantiene el
|
|
valor original si no puede parsear la fecha.
|
|
"""
|
|
if fmt is None:
|
|
return series.copy()
|
|
|
|
def _fn(x):
|
|
if pd.isna(x) or str(x).strip() == "":
|
|
return x
|
|
raw = str(x)
|
|
date_part, _time_part = _split_date_time(raw)
|
|
target = date_part if date_part else raw
|
|
parsed = _parse_date_with_format(target, fmt)
|
|
if parsed is None:
|
|
return x
|
|
d, m, y = parsed
|
|
return f"{d:02d}/{m:02d}/{y:04d}"
|
|
|
|
return series.map(_fn)
|
|
|
|
|
|
def _rule_date_messy_text_to_ddmmyyyy(series: pd.Series) -> pd.Series:
|
|
"""Fechas con símbolos y basura entre cifras → DD/MM/AAAA.
|
|
|
|
Normaliza a solo 6/8 dígitos, vota el formato con `detect_date_format` por
|
|
separado en compact8 y compact6; si el detector no devuelve nada, usa
|
|
`DDMMYYYY` / `DDMMYY` (alineado con la preferencia hispana en fechas
|
|
numéricas).
|
|
"""
|
|
cser = series.map(_normalize_messy_date_to_compact)
|
|
c8s = pd.Series(
|
|
[x for x in cser.tolist() if isinstance(x, str) and len(x) == 8]
|
|
)
|
|
c6s = pd.Series(
|
|
[x for x in cser.tolist() if isinstance(x, str) and len(x) == 6]
|
|
)
|
|
if c8s.empty and c6s.empty:
|
|
return series.copy()
|
|
|
|
fmt8: Optional[str] = None
|
|
fmt6: Optional[str] = None
|
|
if not c8s.empty:
|
|
fmt8 = detect_date_format(c8s) or "DDMMYYYY"
|
|
if not c6s.empty:
|
|
fmt6 = detect_date_format(c6s) or "DDMMYY"
|
|
|
|
def _one(x: Any, c: Any) -> Any:
|
|
if _is_nullish_scalar(x):
|
|
return x
|
|
if not isinstance(c, str) or len(c) not in (6, 8):
|
|
return x
|
|
f = (fmt8 or "DDMMYYYY") if len(c) == 8 else (fmt6 or "DDMMYY")
|
|
t = _parse_date_with_format(c, f)
|
|
if t is None and len(c) == 8:
|
|
t = _parse_date_with_format(c, "DDMMYYYY") or _parse_date_with_format(
|
|
c, "YYYYMMDD"
|
|
)
|
|
if t is None and len(c) == 6:
|
|
t = _parse_date_with_format(c, "DDMMYY")
|
|
if t is None:
|
|
return x
|
|
d, m, y = t
|
|
return f"{d:02d}/{m:02d}/{y:04d}"
|
|
|
|
return pd.Series(
|
|
[
|
|
_one(v, cser.iloc[i] if i < len(cser) else None) for i, v in enumerate(series)
|
|
],
|
|
index=series.index,
|
|
dtype=object,
|
|
)
|
|
|