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

acceldata/services/pipeline_response_parse.py

@@ -0,0 +1,209 @@
+"""Parse create/get pipeline API payloads for Pydantic v2 without fixing generated nested ``from_dict``."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from acceldata.services.pipeline_big_decimal_api import parse_optional_big_decimal_from_api
+from acceldata.models.api.pipeline.meta import Meta
+from acceldata.models.api.pipeline.notification_payload import NotificationPayload
+from acceldata.models.api.pipeline.pipeline import Pipeline
+from acceldata.models.api.pipeline.pipeline_baseline_metric import PipelineBaselineMetric
+from acceldata.models.api.pipeline.pipeline_response import PipelineResponse
+from acceldata.models.api.pipeline.span import Span
+from acceldata.models.api.pipeline.span_request import SpanRequest
+from acceldata.models.api.pipeline.spans_response import SpansResponse
+from acceldata.models.api.pipeline.tag import Tag
+from acceldata.services.api_timestamp import coerce_api_timestamp_to_datetime
+
+
+def _first_present(obj: dict[str, Any], *keys: str) -> Any:
+    """Return ``obj[k]`` for the first *k* in *keys* that exists in *obj* (including ``None`` values)."""
+    for k in keys:
+        if k in obj:
+            return obj[k]
+    return None
+
+
+def _coerce_pipeline_context(ctx: Any) -> Any:
+    """Map ``additionalProperties: Any`` payloads to the generated model shape ``Dict[str, Dict[str, Any]]``."""
+    if ctx is None:
+        return None
+    if not isinstance(ctx, dict):
+        return None
+    out: dict[str, Any] = {}
+    for key, val in ctx.items():
+        if isinstance(val, dict):
+            out[key] = val
+        else:
+            out[key] = {"value": val}
+    return out
+
+
+def tag_from_api_dict(obj: Any) -> Optional[Tag]:
+    """Parse pipeline :class:`~acceldata.models.api.pipeline.tag.Tag` wire JSON (object or plain name string)."""
+    if obj is None:
+        return None
+    if isinstance(obj, str):
+        name = obj.strip()
+        if not name:
+            return None
+        return Tag.model_validate({"name": name, "displayName": name})
+    if not isinstance(obj, dict):
+        return Tag.model_validate(obj)
+
+    name = obj.get("name")
+    if not name:
+        return None
+    display = _first_present(obj, "displayName", "display_name") or name
+    return Tag.model_validate(
+        {
+            "createdAt": coerce_api_timestamp_to_datetime(_first_present(obj, "createdAt", "created_at")),
+            "displayName": display,
+            "id": obj.get("id"),
+            "name": name,
+            "updatedAt": coerce_api_timestamp_to_datetime(_first_present(obj, "updatedAt", "updated_at")),
+        }
+    )
+
+
+def pipeline_baseline_metric_from_api_dict(obj: dict[str, Any]) -> PipelineBaselineMetric:
+    """Validate baseline metric using JSON alias keys (generated ``from_dict`` uses snake_case and fails on v2)."""
+    inc = obj.get("includeSuccessfulRunsOnly")
+    if inc is None:
+        inc = obj.get("include_successful_runs_only")
+    return PipelineBaselineMetric.model_validate(
+        {
+            "includeSuccessfulRunsOnly": inc,
+            "metrics": obj.get("metrics"),
+            "unit": obj.get("unit"),
+        }
+    )
+
+
+def pipeline_from_api_dict(obj: dict[str, Any]) -> Pipeline:
+    """Same logic as :meth:`Pipeline.from_dict` but with fixed baseline metric parsing."""
+    if obj is None:
+        raise TypeError("pipeline object is required")
+    if not isinstance(obj, dict):
+        return Pipeline.model_validate(obj)
+
+    sch = _first_present(obj, "schedulerType", "scheduler_type")
+    if sch is None:
+        sch = "INTERNAL"
+    src = _first_present(obj, "sourceType", "source_type")
+    if src is None:
+        src = "OTHERS"
+    nc = _first_present(obj, "notificationChannels", "notification_channels")
+    pbm = _first_present(obj, "pipelineBaselineMetric", "pipeline_baseline_metric")
+
+    # camelCase keys for aliased fields — Pydantic v2 model_validate ignores v1-style populate_by_name (see pipeline_run_from_api_dict).
+    return Pipeline.model_validate(
+        {
+            "context": obj.get("context"),
+            "createdAt": coerce_api_timestamp_to_datetime(_first_present(obj, "createdAt", "created_at")),
+            "description": obj.get("description"),
+            "enabled": obj.get("enabled") if obj.get("enabled") is not None else True,
+            "id": obj.get("id"),
+            "interrupt": obj.get("interrupt") if obj.get("interrupt") is not None else False,
+            "latestRunId": _first_present(obj, "latestRunId", "latest_run_id"),
+            "meta": Meta.from_dict(obj.get("meta")) if obj.get("meta") is not None else None,
+            "name": obj.get("name"),
+            "notificationChannels": NotificationPayload.from_dict(nc) if nc is not None else None,
+            "pipelineBaselineMetric": pipeline_baseline_metric_from_api_dict(pbm) if pbm is not None else None,
+            "schedule": obj.get("schedule"),
+            "scheduled": obj.get("scheduled") if obj.get("scheduled") is not None else False,
+            "schedulerType": sch,
+            "sourceType": src,
+            "tags": [
+                _t
+                for _item in (obj.get("tags") or [])
+                for _t in [tag_from_api_dict(_item)]
+                if _t is not None
+            ]
+            if obj.get("tags") is not None
+            else None,
+            "uid": obj.get("uid"),
+            "updatedAt": coerce_api_timestamp_to_datetime(_first_present(obj, "updatedAt", "updated_at")),
+        }
+    )
+
+
+def span_from_api_dict(obj: dict[str, Any]) -> Optional[Span]:
+    """Like :meth:`Span.from_dict` but accepts ``avgExecutionTime`` as a JSON number (float/int)."""
+    if obj is None:
+        return None
+    if not isinstance(obj, dict):
+        return Span.model_validate(obj)
+
+    avg_et = parse_optional_big_decimal_from_api(obj.get("avgExecutionTime"))
+
+    return Span.model_validate(
+        {
+            "avgExecutionTime": avg_et,
+            "errorEvents": obj.get("errorEvents") if obj.get("errorEvents") is not None else 0,
+            "finishedAt": obj.get("finishedAt"),
+            "id": obj.get("id"),
+            "parentSpanId": obj.get("parentSpanId"),
+            "pipelineRunId": obj.get("pipelineRunId"),
+            "startedAt": obj.get("startedAt"),
+            "status": obj.get("status") if obj.get("status") is not None else "INITIALIZED",
+            "successEvents": obj.get("successEvents") if obj.get("successEvents") is not None else 0,
+            "totalTime": obj.get("totalTime"),
+            "uid": obj.get("uid"),
+            "warningEvents": obj.get("warningEvents") if obj.get("warningEvents") is not None else 0,
+        }
+    )
+
+
+def span_request_from_api_dict(obj: dict[str, Any]) -> Optional[SpanRequest]:
+    """Parse span envelope when nested ``span`` may include numeric ``avgExecutionTime``."""
+    if obj is None:
+        return None
+    if not isinstance(obj, dict):
+        return SpanRequest.model_validate(obj)
+
+    span_raw = obj.get("span")
+    span_parsed = span_from_api_dict(span_raw) if isinstance(span_raw, dict) else None
+
+    return SpanRequest.model_validate(
+        {
+            "associatedJobUids": obj.get("associatedJobUids"),
+            "span": span_parsed,
+        }
+    )
+
+
+def spans_response_from_api_dict(obj: dict[str, Any]) -> SpansResponse:
+    """Like :meth:`SpansResponse.from_dict` but tolerates numeric ``avgExecutionTime`` on each span."""
+    if obj is None:
+        raise TypeError("spans response object is required")
+    if not isinstance(obj, dict):
+        return SpansResponse.model_validate(obj)
+
+    raw_spans = obj.get("spans")
+    if raw_spans is None:
+        spans_list: list[Span] = []
+    elif not isinstance(raw_spans, list):
+        raise TypeError("spans must be a list when present")
+    else:
+        spans_list = []
+        for item in raw_spans:
+            if not isinstance(item, dict):
+                raise TypeError("Each span must be an object")
+            s = span_from_api_dict(item)
+            if s is not None:
+                spans_list.append(s)
+
+    return SpansResponse.model_validate({"spans": spans_list})
+
+
+def pipeline_response_from_api_dict(obj: dict[str, Any]) -> PipelineResponse:
+    if obj is None:
+        raise TypeError("response object is required")
+    if not isinstance(obj, dict):
+        return PipelineResponse.model_validate(obj)
+    p = obj.get("pipeline")
+    if not isinstance(p, dict):
+        raise TypeError("Create pipeline response must include a 'pipeline' object")
+    return PipelineResponse.model_validate({"pipeline": pipeline_from_api_dict(p)})