bump pydantic dep and linting fixes

Author: miguelg719

pyproject.toml

@@ -10,7 +10,7 @@ authors = [
 
 dependencies = [
   "httpx>=0.23.0, <1",
-  "pydantic>=1.9.0, <3",
+  "pydantic>=2.0.0, <3",
   "typing-extensions>=4.14, <5",
   "anyio>=3.5.0, <5",
   "distro>=1.7.0, <2",
@@ -46,12 +46,7 @@ aiohttp = ["aiohttp", "httpx_aiohttp>=0.1.9"]
 [tool.uv]
 managed = true
 required-version = ">=0.9"
-conflicts = [
-    [
-      { group = "pydantic-v1" },
-      { group = "pydantic-v2" },
-    ],
-]
+conflicts = []
 
 [dependency-groups]
 # version pins are in uv.lock
@@ -69,9 +64,6 @@ dev = [
     "pytest-xdist>=3.6.1",
     "dotenv>=0.9.9",
 ]
-pydantic-v1 = [
-    "pydantic>=1.9.0,<2",
-]
 pydantic-v2 = [
     "pydantic~=2.0 ; python_full_version < '3.14'",
     "pydantic~=2.12 ; python_full_version >= '3.14'",

src/stagehand/_pydantic_extract.py

@@ -66,8 +66,8 @@ def _convert_dict_keys_to_snake_case(data: Any) -> Any:
     if isinstance(data, dict):
         return {
             _camel_to_snake(k) if isinstance(k, str) else k: _convert_dict_keys_to_snake_case(v)
-            for k, v in data.items()
+            for k, v in data.items()  # type: ignore[union-attr]
         }
     if isinstance(data, list):
-        return [_convert_dict_keys_to_snake_case(item) for item in data]
+        return [_convert_dict_keys_to_snake_case(item) for item in data]  # type: ignore[union-attr]
     return data

src/stagehand/session.py

@@ -17,7 +17,7 @@
 )
 from ._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
 from ._exceptions import StagehandError
-from ._pydantic_extract import is_pydantic_model, pydantic_model_to_json_schema, validate_extract_response
+from ._pydantic_extract import is_pydantic_model, validate_extract_response, pydantic_model_to_json_schema
 from .types.session_act_response import SessionActResponse
 from .types.session_end_response import SessionEndResponse
 from .types.session_start_response import Data as SessionStartResponseData, SessionStartResponse
@@ -201,7 +201,7 @@ def observe(
             ),
         )
 
-    def extract(
+    def extract(  # type: ignore[misc]
         self,
         *,
         schema: dict[str, object] | type | None = None,
@@ -210,36 +210,37 @@ def extract(
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = not_given,
-        **params: Unpack[session_extract_params.SessionExtractParamsNonStreaming],
+        **params: Unpack[session_extract_params.SessionExtractParamsNonStreaming],  # pyright: ignore[reportGeneralTypeIssues]
     ) -> SessionExtractResponse:
         # If the caller passed schema via **params (TypedDict), prefer the explicit kwarg.
         params_schema = params.pop("schema", None)  # type: ignore[misc]
         resolved_schema = schema if schema is not None else params_schema
 
-        pydantic_cls = None
+        pydantic_cls: type[Any] | None = None
         if is_pydantic_model(resolved_schema):
-            pydantic_cls = resolved_schema
-            resolved_schema = pydantic_model_to_json_schema(resolved_schema)
+            pydantic_cls = resolved_schema  # type: ignore[assignment]
+            resolved_schema = pydantic_model_to_json_schema(pydantic_cls)  # type: ignore[arg-type]
 
         api_params: dict[str, Any] = _maybe_inject_frame_id(dict(params), page)
         if resolved_schema is not None:
             api_params["schema"] = resolved_schema
 
-        response = self._client.sessions.extract(
-            id=self.id,
-            extra_headers=extra_headers,
-            extra_query=extra_query,
-            extra_body=extra_body,
-            timeout=timeout,
-            **api_params,
+        response: SessionExtractResponse = cast(
+            SessionExtractResponse,
+            self._client.sessions.extract(
+                id=self.id,
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                **api_params,
+            ),
         )
 
-        # Pydantic validation only applies to non-streaming responses.
-        if pydantic_cls is not None and isinstance(response, SessionExtractResponse):
-            if response.data and response.data.result is not None:
-                response.data.result = validate_extract_response(response.data.result, pydantic_cls)
+        if pydantic_cls is not None and response.data and response.data.result is not None:
+            response.data.result = validate_extract_response(response.data.result, pydantic_cls)
 
-        return cast(SessionExtractResponse, response)
+        return response
 
     def execute(
         self,
@@ -354,7 +355,7 @@ async def observe(
             ),
         )
 
-    async def extract(
+    async def extract(  # type: ignore[misc]
         self,
         *,
         schema: dict[str, object] | type | None = None,
@@ -363,36 +364,37 @@ async def extract(
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = not_given,
-        **params: Unpack[session_extract_params.SessionExtractParamsNonStreaming],
+        **params: Unpack[session_extract_params.SessionExtractParamsNonStreaming],  # pyright: ignore[reportGeneralTypeIssues]
     ) -> SessionExtractResponse:
         # If the caller passed schema via **params (TypedDict), prefer the explicit kwarg.
         params_schema = params.pop("schema", None)  # type: ignore[misc]
         resolved_schema = schema if schema is not None else params_schema
 
-        pydantic_cls = None
+        pydantic_cls: type[Any] | None = None
         if is_pydantic_model(resolved_schema):
-            pydantic_cls = resolved_schema
-            resolved_schema = pydantic_model_to_json_schema(resolved_schema)
+            pydantic_cls = resolved_schema  # type: ignore[assignment]
+            resolved_schema = pydantic_model_to_json_schema(pydantic_cls)  # type: ignore[arg-type]
 
         api_params: dict[str, Any] = await _maybe_inject_frame_id_async(dict(params), page)
         if resolved_schema is not None:
             api_params["schema"] = resolved_schema
 
-        response = await self._client.sessions.extract(
-            id=self.id,
-            extra_headers=extra_headers,
-            extra_query=extra_query,
-            extra_body=extra_body,
-            timeout=timeout,
-            **api_params,
+        response: SessionExtractResponse = cast(
+            SessionExtractResponse,
+            await self._client.sessions.extract(
+                id=self.id,
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                **api_params,
+            ),
         )
 
-        # Pydantic validation only applies to non-streaming responses.
-        if pydantic_cls is not None and isinstance(response, SessionExtractResponse):
-            if response.data and response.data.result is not None:
-                response.data.result = validate_extract_response(response.data.result, pydantic_cls)
+        if pydantic_cls is not None and response.data and response.data.result is not None:
+            response.data.result = validate_extract_response(response.data.result, pydantic_cls)
 
-        return cast(SessionExtractResponse, response)
+        return response
 
     async def execute(
         self,