limitsdb 0.5.0__py3-none-any.whl

limitsdb/core/ldb_errors.py

@@ -0,0 +1,30 @@
+"""Domain errors exposed by LimitsDb boundaries.
+
+All errors retain their original exception through ``raise ... from exc`` at
+the boundary where low-level parsing, cryptography, database, or worker errors
+are translated.
+"""
+
+
+class LimitsDbError(Exception):
+    """Base class for recoverable LimitsDb failures."""
+
+
+class ConfigurationError(LimitsDbError, ValueError):
+    """Configuration could not be read or interpreted."""
+
+
+class SecretError(ConfigurationError):
+    """Secret storage, key management, or decryption failed."""
+
+
+class DatabaseConnectionError(LimitsDbError, ConnectionError):
+    """A database connection could not be established or checked."""
+
+
+class ValidationError(LimitsDbError, ValueError):
+    """Configuration or runtime state failed domain validation."""
+
+
+class ExecutionError(LimitsDbError, RuntimeError):
+    """An ILM or administrative operation failed."""

limitsdb/core/ldb_ilm_config.py

@@ -0,0 +1,228 @@
+# limitsdb/core/ldb_ilm_config.py
+from __future__ import annotations
+
+from collections.abc import ItemsView, Mapping
+from typing import Any, NotRequired, TypedDict, cast
+
+import yaml
+
+from limitsdb.core.ldb_config_loader import load_ilm_config
+
+_id_counter = 0
+_loaded_tables: set[tuple[str, str]] = set()
+
+_VALID_ROOT_KEYS: set[str] = {"tables"}
+
+_VALID_TABLE_KEYS: set[str] = {
+    "source_owner",
+    "history_owner",
+    "table_name",
+    "retain_months_source",
+    "retain_months_history",
+    "exec_day",
+    "frecuency",
+    "purge_date_expr",
+    "additional_filter_expr",
+    "history_addtl_filter_expr",
+    "history_hint_expr",
+    "orphan_check_column",
+    "referencing_tables",
+    "join_expr",
+    "hint_expr",
+    "long_columns",
+    "source_orphan_purge",
+    "has_lob_columns",
+}
+
+_VALID_COND_KEYS: set[str] = _VALID_TABLE_KEYS | {"is_active"}
+
+
+class IlmRule(TypedDict):
+    """Normalized engine-neutral ILM rule consumed by the runner."""
+
+    id: int
+    source_owner: str
+    history_owner: str
+    table_name: str
+    retain_months_source: int | None
+    retain_months_history: int | None
+    exec_day: int | None
+    frecuency: str | None
+    is_active: str
+    purge_date_expr: str | None
+    additional_filter_expr: str | None
+    history_addtl_filter_expr: str | None
+    history_hint_expr: str | None
+    source_orphan_purge: str
+    orphan_check_column: str | None
+    has_lob_columns: str
+    referencing_tables: str | None
+    join_expr: str | None
+    hint_expr: str | None
+    long_columns: str | None
+    ctl_status: str | None
+    cond_expr: NotRequired[str]
+
+
+def _assert_valid_keys(keys: set[str], *, where: str, allowed: set[str]) -> None:
+    """Raise if any key in `keys` is not present in `allowed`."""
+    invalid = sorted(k for k in keys if k not in allowed)
+    if invalid:
+        allowed_sorted = ", ".join(sorted(allowed))
+        invalid_sorted = ", ".join(invalid)
+        raise KeyError(f"Invalid key(s) in ILM config at {where}: {invalid_sorted}. Expected only: {allowed_sorted}")
+
+
+def _normalize_bool(val: Any) -> Any:
+    return "Y" if val else "N" if val is not None else None
+
+
+def normalize_table_row(table: dict[str, Any], cond: dict[str, Any]) -> IlmRule:
+    global _id_counter
+    row: dict[str, Any] = {}
+    # Merge the table definition with the condition (excluding nested "conds").
+    for key, value in list(table.items()) + list(cond.items()):
+        if key == "conds":
+            continue
+        row[key] = _normalize_bool(value) if isinstance(value, bool) else value
+        row["ctl_status"] = None
+    # Ensure default flags are present when omitted.
+    for key in ["is_active", "source_orphan_purge", "has_lob_columns"]:
+        if key not in row:
+            row[key] = "N" if key != "is_active" else "Y"
+    for key in [
+        "source_owner",
+        "history_owner",
+        "table_name",
+        "retain_months_source",
+        "retain_months_history",
+        "exec_day",
+        "frecuency",
+        "purge_date_expr",
+        "additional_filter_expr",
+        "history_addtl_filter_expr",
+        "history_hint_expr",
+        "orphan_check_column",
+        "referencing_tables",
+        "join_expr",
+        "hint_expr",
+        "long_columns",
+    ]:
+        if key not in row:
+            row[key] = None
+    row["id"] = _id_counter
+    _id_counter += 1
+    return cast(IlmRule, row)
+
+
+def _ensure_mapping(obj: Any, where: str) -> dict[str, Any]:
+    """Ensure obj is a mapping[str, Any] and return a plain dict[str, Any]."""
+    if obj is None:
+        return {}
+    if not isinstance(obj, Mapping):
+        raise TypeError(f"YAML root at {where} must be a mapping (dict). Got {type(obj).__name__}")
+    out: dict[str, Any] = {}
+    # Explicitly type the ItemsView iterator for mypy.
+    obj_items: ItemsView[Any, Any] = obj.items()
+    for k_any, v_any in obj_items:
+        key: str = str(k_any)
+        val: Any = v_any
+        out[key] = val
+    return out
+
+
+def _ensure_list_of_mappings(obj: Any, where: str) -> list[dict[str, Any]]:
+    """Ensure obj is a list of mapping-like items and normalize each to dict[str, Any]."""
+    if obj is None:
+        return []
+    if not isinstance(obj, list):
+        raise TypeError(f"'{where}' must be a list. Got {type(obj).__name__}")
+    out: list[dict[str, Any]] = []
+    # Cast the heterogeneous list so we can iterate with type checking.
+    obj_list: list[Any] = obj
+    for i, el_any in enumerate(obj_list):
+        if not isinstance(el_any, Mapping):
+            raise TypeError(f"'{where}[{i}]' must be a mapping (dict). Got {type(el_any).__name__}")
+        el_map: Mapping[Any, Any] = el_any
+        d: dict[str, Any] = {}
+        el_items: ItemsView[Any, Any] = el_map.items()
+        for k_any, v_any in el_items:
+            key: str = str(k_any)
+            val: Any = v_any
+            d[key] = val
+        out.append(d)
+    return out
+
+
+def load_rows_from_yaml(yaml_path: str) -> list[IlmRule]:
+    _loaded_tables: set[tuple[str, str]] = set()
+    with open(yaml_path, encoding="utf-8") as f:
+        data_any: Any = yaml.safe_load(f)
+    data: dict[str, Any] = _ensure_mapping(data_any, yaml_path)
+    _assert_valid_keys(set(data.keys()), where=f"{yaml_path} (root)", allowed=_VALID_ROOT_KEYS)
+    rows: list[IlmRule] = []
+    tables: list[dict[str, Any]] = _ensure_list_of_mappings(data.get("tables"), "tables")
+    for idx, table in enumerate(tables):
+        table_keys = set(table.keys()) - {"conds"}
+        _assert_valid_keys(table_keys, where=f"{yaml_path} tables[{idx}]", allowed=_VALID_TABLE_KEYS)
+        owner: str = str(table.get("source_owner", "") or "")
+        table_name: str = str(table.get("table_name", "") or "")
+        if (owner, table_name) in _loaded_tables:
+            raise ValueError(f"Duplicate table in ilm-config-file: {owner}.{table_name}")
+        # Normalize nested "conds" entries for the table.
+        conds_any = table.get("conds")
+        conds: list[dict[str, Any]] = _ensure_list_of_mappings(conds_any, "conds") if conds_any is not None else []
+        if not conds:
+            conds = [{"is_active": True}]
+        active_conds: list[dict[str, Any]] = []
+        for c_idx, cond in enumerate(conds):
+            _assert_valid_keys(
+                set(cond.keys()), where=f"{yaml_path} tables[{idx}].conds[{c_idx}]", allowed=_VALID_COND_KEYS
+            )
+            if bool(cond.get("is_active")) is True:
+                active_conds.append(cond)
+        for cond in active_conds:
+            rows.append(normalize_table_row(table, cond))
+        if active_conds:
+            _loaded_tables.add((owner, table_name))
+    return rows
+
+
+def resolve_and_load_ilm_rows(*, schema: str, profile: str | None, config_dir: str | None = None) -> list[IlmRule]:
+    """Load merged ILM for schema/profile and return normalized rows."""
+    ilm_dict: dict[str, Any] = load_ilm_config(schema=schema, profile=profile, explicit_config_dir=config_dir)
+    rows: list[IlmRule] = []
+    global _loaded_tables, _id_counter
+    _loaded_tables = set()
+    _id_counter = 0
+    _assert_valid_keys(
+        set(ilm_dict.keys()), where=f"ILM config for schema={schema} profile={profile} (root)", allowed=_VALID_ROOT_KEYS
+    )
+    tables: list[dict[str, Any]] = _ensure_list_of_mappings(ilm_dict.get("tables"), "tables")
+    for idx, table in enumerate(tables):
+        table_keys = set(table.keys()) - {"conds"}
+        _assert_valid_keys(
+            table_keys, where=f"ILM config tables[{idx}] (schema={schema} profile={profile})", allowed=_VALID_TABLE_KEYS
+        )
+        owner: str = str(table.get("source_owner", "") or "")
+        table_name: str = str(table.get("table_name", "") or "")
+        if (owner, table_name) in _loaded_tables:
+            raise ValueError(f"Duplicate table in ILM config: {owner}.{table_name}")
+        conds_any = table.get("conds")
+        conds: list[dict[str, Any]] = _ensure_list_of_mappings(conds_any, "conds") if conds_any is not None else []
+        if not conds:
+            conds = [{"is_active": True}]
+        active_conds: list[dict[str, Any]] = []
+        for c_idx, cond in enumerate(conds):
+            _assert_valid_keys(
+                set(cond.keys()),
+                where=f"ILM config tables[{idx}].conds[{c_idx}] (schema={schema} profile={profile})",
+                allowed=_VALID_COND_KEYS,
+            )
+            if bool(cond.get("is_active")) is True:
+                active_conds.append(cond)
+        for cond in active_conds:
+            rows.append(normalize_table_row(table, cond))
+        if active_conds:
+            _loaded_tables.add((owner, table_name))
+    return rows

limitsdb/core/ldb_logger.py

@@ -0,0 +1,57 @@
+# ldb_logger.py
+import logging
+import threading
+
+_base_name = "ldb"
+_configured = False
+_lock = threading.RLock()
+
+# Un único formato legible (sin JSON, sin ambientes)
+_FORMAT = logging.Formatter(
+    fmt="%(asctime)s [%(levelname)s] %(processName)s-%(name)s: %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+
+
+def configure_logger(level: str = "INFO", base_name: str = _base_name) -> logging.Logger:
+    """Configura el logger base una sola vez (handlers/format)."""
+    global _configured, _base_name
+    with _lock:
+        _base_name = base_name
+        base = logging.getLogger(_base_name)
+        lvl = getattr(logging, level.upper(), logging.INFO)
+
+        if not _configured:
+            base.setLevel(lvl)
+            base.propagate = False  # evita duplicar en root
+            ch = logging.StreamHandler()
+            ch.setLevel(lvl)
+            ch.setFormatter(_FORMAT)
+            base.addHandler(ch)
+            _configured = True
+        else:
+            base.setLevel(lvl)
+            for h in base.handlers:
+                h.setLevel(lvl)
+                h.setFormatter(_FORMAT)
+        return base
+
+
+def get_logger(name: str = _base_name) -> logging.Logger:
+    """Devuelve el logger base o un hijo ('limitsdb.<name>')."""
+    if not _configured:
+        configure_logger()
+    if name == _base_name or name == "":
+        return logging.getLogger(_base_name)
+    return logging.getLogger(f"{_base_name}.{name}")
+
+
+def reconfigure_logger(level: str = "INFO") -> None:
+    """Ajusta el nivel del logger base y sus handlers."""
+    if not _configured:
+        return
+    lvl = getattr(logging, level.upper(), logging.INFO)
+    base = logging.getLogger(_base_name)
+    base.setLevel(lvl)
+    for h in base.handlers:
+        h.setLevel(lvl)

limitsdb/core/ldb_meta.py

@@ -0,0 +1,31 @@
+# limitsdb/core/ldb_meta.py
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Help:
+    text: str
+
+
+@dataclass(frozen=True)
+class Cli:
+    flag: str  # e.g. "--parallel-max"
+
+
+@dataclass(frozen=True)
+class Secret:
+    enabled: bool = True  # default marks the field as secret
+
+
+@dataclass(frozen=True)
+class Env:
+    name: str  # e.g. "LDB_PARALLEL_MAX"
+
+
+@dataclass(frozen=True)
+class CliOnly:
+    """Marker for fields that are used only through CLI (never stored in config.yml)."""
+
+    enabled: bool = True