Use parse_obj for Pydantic v1 compatibility in responses types tests

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: rushitat

tests/types/responses/test_response_create_response.py

@@ -2,14 +2,17 @@
 
 from __future__ import annotations
 
+from typing import Any
+
+from gradient._compat import parse_obj
 from gradient.types.responses import (
     ResponseOutputMessage,
     ResponseCreateResponse,
     ResponseOutputFunctionCall,
 )
 
 # Minimal valid response payload (static, no network).
-MINIMAL_RESPONSE = {
+MINIMAL_RESPONSE: dict[str, Any] = {
     "id": "resp_123",
     "output": [],
     "status": "completed",
@@ -21,23 +24,23 @@ class TestResponseCreateResponseParse:
     """Test that ResponseCreateResponse parses minimal and extended JSON."""
 
     def test_parse_minimal_response(self) -> None:
-        parsed = ResponseCreateResponse.model_validate(MINIMAL_RESPONSE)
+        parsed = parse_obj(ResponseCreateResponse, MINIMAL_RESPONSE)
         assert parsed.id == "resp_123"
         assert parsed.output == []
         assert parsed.status == "completed"
         assert parsed.model == "openai-gpt-5.2-pro"
         assert parsed.output_text == ""
 
     def test_parse_response_with_usage(self) -> None:
-        payload = {
+        payload: dict[str, Any] = {
             **MINIMAL_RESPONSE,
             "usage": {
                 "prompt_tokens": 10,
                 "completion_tokens": 5,
                 "total_tokens": 15,
             },
         }
-        parsed = ResponseCreateResponse.model_validate(payload)
+        parsed = parse_obj(ResponseCreateResponse, payload)
         assert parsed.usage is not None
         assert parsed.usage.prompt_tokens == 10
         assert parsed.usage.completion_tokens == 5
@@ -48,18 +51,18 @@ class TestResponseCreateResponseOutputText:
     """Test that output_text aggregates text from message items in output."""
 
     def test_output_text_aggregates_content(self) -> None:
-        payload = {
+        payload: dict[str, Any] = {
             **MINIMAL_RESPONSE,
             "output": [
                 {"type": "message", "role": "assistant", "content": "Hello "},
                 {"type": "message", "role": "assistant", "content": "world."},
             ],
         }
-        parsed = ResponseCreateResponse.model_validate(payload)
+        parsed = parse_obj(ResponseCreateResponse, payload)
         assert parsed.output_text == "Hello world."
 
     def test_output_text_prefers_output_text_field(self) -> None:
-        payload = {
+        payload: dict[str, Any] = {
             **MINIMAL_RESPONSE,
             "output": [
                 {
@@ -70,11 +73,11 @@ def test_output_text_prefers_output_text_field(self) -> None:
                 },
             ],
         }
-        parsed = ResponseCreateResponse.model_validate(payload)
+        parsed = parse_obj(ResponseCreateResponse, payload)
         assert parsed.output_text == "aggregated"
 
     def test_output_text_skips_function_call_items(self) -> None:
-        payload = {
+        payload: dict[str, Any] = {
             **MINIMAL_RESPONSE,
             "output": [
                 {"type": "message", "role": "assistant", "content": "Here is "},
@@ -87,38 +90,39 @@ def test_output_text_skips_function_call_items(self) -> None:
                 {"type": "message", "role": "assistant", "content": "the result."},
             ],
         }
-        parsed = ResponseCreateResponse.model_validate(payload)
+        parsed = parse_obj(ResponseCreateResponse, payload)
         assert parsed.output_text == "Here is the result."
 
     def test_output_text_empty_message_content_treated_as_empty(self) -> None:
-        payload = {
+        payload: dict[str, Any] = {
             **MINIMAL_RESPONSE,
             "output": [
                 {"type": "message", "role": "assistant", "content": None},
                 {"type": "message", "role": "assistant", "output_text": "only this"},
             ],
         }
-        parsed = ResponseCreateResponse.model_validate(payload)
+        parsed = parse_obj(ResponseCreateResponse, payload)
         assert parsed.output_text == "only this"
 
 
 class TestResponseOutputItemTypes:
     """Test that output item types parse correctly."""
 
     def test_message_item_parses(self) -> None:
-        msg = ResponseOutputMessage.model_validate({"type": "message", "role": "assistant", "content": "Hi"})
+        msg = parse_obj(ResponseOutputMessage, {"type": "message", "role": "assistant", "content": "Hi"})
         assert msg.type == "message"
         assert msg.role == "assistant"
         assert msg.content == "Hi"
 
     def test_function_call_item_parses(self) -> None:
-        fc = ResponseOutputFunctionCall.model_validate(
+        fc = parse_obj(
+            ResponseOutputFunctionCall,
             {
                 "type": "function_call",
                 "id": "call_1",
                 "name": "foo",
                 "arguments": '{"x": 1}',
-            }
+            },
         )
         assert fc.type == "function_call"
         assert fc.id == "call_1"