fix(managed): read the run's warning defensively, and pin the fields

`warning_message` is read while building an error, which is the worst
place to assume an attribute: if an SDK release dropped it, the
`AttributeError` would replace a message naming the problem with one
naming nothing. `getattr` keeps the raise intact and loses only the
explanation.

Pinning the assumption is the better half of the fix, though. Every fake
in the managed-client tests is a `SimpleNamespace`, so nothing there
would notice a field being renamed or dropped -- the fakes would keep
answering and the suite would keep passing, with the cost landing at
runtime. A test now asserts the generated `QueryRunInfo` carries all four
fields this client reads off a run, not just the one that prompted this.

Author: anoop-narang

hotdata_framework/managed_client.py

@@ -196,10 +196,14 @@ def _await_query_run(self, query_run_id: str, *, database_id: str) -> str | None
                     # and write only its new batch, dropping what was there.
                     # Terminal rather than transient: re-running the query
                     # cannot save a result that was already discarded.
+                    # `getattr` because this runs while building an error: if
+                    # the field ever goes away, losing the explanation is a far
+                    # better outcome than an AttributeError replacing the raise.
+                    warning = getattr(run, "warning_message", None)
                     raise RuntimeError(
                         f"Query run {query_run_id} succeeded but its result was not "
                         f"saved, so the table cannot be read"
-                        + (f": {run.warning_message}" if run.warning_message else "")
+                        + (f": {warning}" if warning else "")
                     )
                 return run.result_id
             if run.status == "interrupted":

tests/test_managed_client.py

@@ -10,6 +10,7 @@
 from hotdata.arrow import ResultNotReadyError
 from hotdata.models.async_query_response import AsyncQueryResponse
 from hotdata.models.query_response import QueryResponse
+from hotdata.models.query_run_info import QueryRunInfo
 from hotdata.rest import ApiException
 
 import hotdata_framework.managed_client as mc
@@ -911,3 +912,17 @@ def get_result_arrow(self, result_id: str, **kwargs: Any) -> pa.Table:
     assert table is not None
     assert table.num_rows == 2
     assert len(attempts) == 3
+
+
+def test_query_run_model_carries_every_field_this_client_reads() -> None:
+    """Pins the attributes read off a query run against the generated model.
+
+    Every fake in this file is a `SimpleNamespace`, so nothing else here would
+    notice if one of these fields were renamed or dropped by an SDK release --
+    the fakes would keep answering and the tests would keep passing. The cost
+    lands at runtime, and worst on `warning_message`, which is read while
+    building an error: losing it turns a message naming the problem into an
+    `AttributeError` naming nothing.
+    """
+    for field in ("status", "result_id", "error_message", "warning_message"):
+        assert field in QueryRunInfo.model_fields, field