acceldata-sdk-python 26.7.0__py3-none-any.whl

acceldata/openapi_deserialization_patches.py

@@ -0,0 +1,161 @@
+"""Runtime deserialization fixes for selected generated OpenAPI DTOs.
+
+OpenAPI Generator emits strict discriminator checks that reject wire JSON when Kotlin/Jackson
+omits ``type`` on nested configs (e.g. relative threshold ``config`` with only ``direction``).
+Generated model files under ``acceldata.models.api`` are not edited; this module patches
+``from_json`` / ``from_dict`` at package import time.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Callable, Type
+
+_applied = False
+
+_RELATIVE_DIRECTION_TO_TYPE: dict[str, str] = {
+    "CHANGES_BY": "io.ad.catalog.api.model.quality.ChangesByConfig",
+    "DECREASED_BY": "io.ad.catalog.api.model.quality.DecreasedByConfig",
+    "INCREASED_BY": "io.ad.catalog.api.model.quality.IncreasedByConfig",
+}
+
+_ROOT_CAUSE_FRACTION_FIELDS = ("badFraction", "goodFraction", "totalFraction")
+
+_ASSET_TAG_DEFAULTS: dict[str, Any] = {
+    "accelDataDefined": False,
+    "assets": 0,
+    "classification": "USER",
+    "createdAt": "1970-01-01T00:00:00Z",
+    "domains": [],
+    "enabled": True,
+    "processingStatus": "PROCESSED",
+    "strategy": "MANUAL",
+}
+
+
+def _inject_relative_config_type(parsed: dict[str, Any]) -> dict[str, Any]:
+    if parsed.get("type"):
+        return parsed
+    direction = parsed.get("direction")
+    inferred = _RELATIVE_DIRECTION_TO_TYPE.get(direction)
+    if not inferred:
+        return parsed
+    out = dict(parsed)
+    out["type"] = inferred
+    return out
+
+
+def _infer_rule_threshold_type(parsed: dict[str, Any]) -> str | None:
+    if parsed.get("type"):
+        return parsed.get("type")
+    if "operationalConfig" in parsed:
+        return "RELATIVE"
+    config = parsed.get("config")
+    if not isinstance(config, dict):
+        return None
+    if "successSensitivityLevel" in config:
+        return "ANOMALY"
+    if any(key in config for key in ("window", "windowType", "lookBackWindowType")):
+        return "TIME_BASED"
+    if "direction" in config:
+        return "ABSOLUTE"
+    nested_type = config.get("type")
+    if isinstance(nested_type, str):
+        if "RelativeThresholdConfig" in nested_type or "RelativeConfig" in nested_type:
+            return "RELATIVE"
+        if "AbsoluteThresholdConfig" in nested_type or "AbsoluteConfig" in nested_type:
+            return "ABSOLUTE"
+        if "AnomalyThresholdConfig" in nested_type:
+            return "ANOMALY"
+        if "TimeBasedThresholdConfig" in nested_type:
+            return "TIME_BASED"
+    return None
+
+
+def _inject_rule_threshold_type(parsed: dict[str, Any]) -> dict[str, Any]:
+    inferred = _infer_rule_threshold_type(parsed)
+    if not inferred:
+        return parsed
+    out = dict(parsed)
+    out["type"] = inferred
+    return out
+
+
+def _coerce_quoted_decimal_strings(obj: dict[str, Any], fields: tuple[str, ...]) -> dict[str, Any]:
+    out = dict(obj)
+    for key in fields:
+        val = out.get(key)
+        if isinstance(val, str):
+            try:
+                out[key] = float(val)
+            except ValueError:
+                pass
+    return out
+
+
+def _normalize_root_cause_analysis_dict(obj: dict[str, Any]) -> dict[str, Any]:
+    return _coerce_quoted_decimal_strings(obj, _ROOT_CAUSE_FRACTION_FIELDS)
+
+
+def _normalize_asset_tag_dict(obj: dict[str, Any]) -> dict[str, Any]:
+    out = dict(obj)
+    for key, default in _ASSET_TAG_DEFAULTS.items():
+        if out.get(key) is None:
+            out[key] = default
+    if out.get("domains") is None:
+        out["domains"] = []
+    return out
+
+
+def _patch_json_loader(
+    cls: Type[Any],
+    *,
+    normalizer: Callable[[dict[str, Any]], dict[str, Any]],
+) -> None:
+    original = cls.from_json.__func__  # type: ignore[attr-defined]
+
+    @classmethod
+    def from_json_patched(subcls: Type[Any], json_str: str) -> Any:
+        parsed = json.loads(json_str)
+        if isinstance(parsed, dict):
+            parsed = normalizer(parsed)
+            json_str = json.dumps(parsed)
+        return original(subcls, json_str)
+
+    cls.from_json = from_json_patched  # type: ignore[method-assign, assignment]
+
+
+def _patch_dict_loader(
+    cls: Type[Any],
+    *,
+    normalizer: Callable[[dict[str, Any]], dict[str, Any]],
+) -> None:
+    original = cls.from_dict.__func__  # type: ignore[attr-defined]
+
+    @classmethod
+    def from_dict_patched(subcls: Type[Any], obj: Any) -> Any:
+        if isinstance(obj, dict):
+            obj = normalizer(obj)
+        return original(subcls, obj)
+
+    cls.from_dict = from_dict_patched  # type: ignore[method-assign, assignment]
+
+
+def apply_openapi_deserialization_patches() -> None:
+    """Idempotently patch selected generated models for real catalog wire JSON."""
+    global _applied
+    if _applied:
+        return
+
+    from acceldata.models.api.catalog.asset_tag_info import AssetTagInfo
+    from acceldata.models.api.catalog.relative_config import RelativeConfig
+    from acceldata.models.api.catalog.root_cause_analysis import RootCauseAnalysis
+    from acceldata.models.api.catalog.rule_threshold_configuration import RuleThresholdConfiguration
+
+    _patch_json_loader(RelativeConfig, normalizer=_inject_relative_config_type)
+    _patch_json_loader(RuleThresholdConfiguration, normalizer=_inject_rule_threshold_type)
+    _patch_dict_loader(AssetTagInfo, normalizer=_normalize_asset_tag_dict)
+    _patch_dict_loader(RootCauseAnalysis, normalizer=_normalize_root_cause_analysis_dict)
+    _patch_json_loader(RootCauseAnalysis, normalizer=_normalize_root_cause_analysis_dict)
+
+    _applied = True

acceldata/openapi_repr_patches.py

@@ -0,0 +1,62 @@
+"""Compact ``repr`` / ``str`` for selected generated polymorphic DTOs.
+
+The OpenAPI client emits wrapper types whose default Pydantic representation is dominated
+by internal discriminator fields. This module replaces ``__repr__`` / ``__str__`` on those
+classes so logs and interactive use show the resolved payload instead. Generated model
+files under ``acceldata.models.api`` are not edited.
+"""
+
+from __future__ import annotations
+
+import importlib
+from typing import Any, Callable, Type
+
+_applied = False
+
+# (module, class) pairs for polymorphic oneOf / anyOf wrappers. Missing modules are skipped so a
+# partial or in-progress model regen (after ``--clear-sdk-api-models``) does not break package import.
+_REPR_PATCH_TARGETS: tuple[tuple[str, str], ...] = (
+    ("acceldata.models.api.catalog.absolute_configs", "AbsoluteConfigs"),
+    ("acceldata.models.api.catalog.generic_execution", "GenericExecution"),
+    ("acceldata.models.api.catalog.generic_rule_execution", "GenericRuleExecution"),
+    ("acceldata.models.api.catalog.marker_config", "MarkerConfig"),
+    ("acceldata.models.api.catalog.relative_config", "RelativeConfig"),
+    ("acceldata.models.api.catalog.rule_threshold_configuration", "RuleThresholdConfiguration"),
+    ("acceldata.models.api.catalog.above_configs_success", "AboveConfigsSuccess"),
+)
+
+
+def _compact_polymorphic_wrapper_repr(self: Any) -> str:
+    inner = self.actual_instance
+    name = type(self).__name__
+    if inner is not None:
+        return f"{name}({inner!r})"
+    return f"{name}(actual_instance=None)"
+
+
+def _load_repr_patch_class(module_path: str, class_name: str) -> Type[Any] | None:
+    try:
+        module = importlib.import_module(module_path)
+        return getattr(module, class_name)
+    except (ImportError, AttributeError):
+        return None
+
+
+def apply_openapi_repr_patches() -> None:
+    """Idempotently replace ``__repr__`` / ``__str__`` on selected wrapper classes."""
+    global _applied
+    if _applied:
+        return
+
+    # Catalog/pipeline ``Any`` JSON wrappers are omitted here: importing them pulls in
+    # legacy ``Field(..., const=True)`` models that fail under Pydantic v2 at import time.
+
+    fn: Callable[[Any], str] = _compact_polymorphic_wrapper_repr
+    for module_path, class_name in _REPR_PATCH_TARGETS:
+        cls = _load_repr_patch_class(module_path, class_name)
+        if cls is None:
+            continue
+        cls.__repr__ = fn  # type: ignore[method-assign, assignment]
+        cls.__str__ = fn  # type: ignore[method-assign, assignment]
+
+    _applied = True

acceldata/services/api_timestamp.py

@@ -0,0 +1,31 @@
+"""Normalize API timestamp payloads to ``datetime`` for Pydantic v2 API models."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+
+def coerce_api_timestamp_to_datetime(val: Any) -> datetime | None:
+    """Map epoch ms int, ``epochMillis`` dict, or ISO string to timezone-aware UTC ``datetime``."""
+    if val is None:
+        return None
+    if isinstance(val, datetime):
+        return val
+    if isinstance(val, dict):
+        ms = val.get("epochMillis")
+        if ms is None:
+            ms = val.get("epoch_millis")
+        if ms is not None:
+            return datetime.fromtimestamp(int(ms) / 1000.0, tz=timezone.utc)
+        return None
+    if isinstance(val, (int, float)):
+        n = int(val)
+        sec = n / 1000.0 if n > 10**12 else float(n)
+        return datetime.fromtimestamp(sec, tz=timezone.utc)
+    if isinstance(val, str):
+        try:
+            return datetime.fromisoformat(val.replace("Z", "+00:00"))
+        except ValueError:
+            return None
+    return None