Refactor manager serialization to shared helper

Co-authored-by: Shri Sukhani <shrisukhani@users.noreply.github.com>

Author: cursoragent

hyperbrowser/client/managers/async_manager/agents/browser_use.py

@@ -7,6 +7,7 @@
 )
 from ....schema_utils import resolve_schema_input
 from ...response_utils import parse_response_model
+from ...serialization_utils import serialize_model_dump_to_dict
 
 from .....models import (
     POLLING_ATTEMPTS,
@@ -16,7 +17,6 @@
     StartBrowserUseTaskParams,
     StartBrowserUseTaskResponse,
 )
-from .....exceptions import HyperbrowserError
 
 
 class BrowserUseManager:
@@ -26,17 +26,10 @@ def __init__(self, client):
     async def start(
         self, params: StartBrowserUseTaskParams
     ) -> StartBrowserUseTaskResponse:
-        try:
-            payload = params.model_dump(exclude_none=True, by_alias=True)
-        except HyperbrowserError:
-            raise
-        except Exception as exc:
-            raise HyperbrowserError(
-                "Failed to serialize browser-use start params",
-                original_error=exc,
-            ) from exc
-        if type(payload) is not dict:
-            raise HyperbrowserError("Failed to serialize browser-use start params")
+        payload = serialize_model_dump_to_dict(
+            params,
+            error_message="Failed to serialize browser-use start params",
+        )
         if params.output_model_schema:
             payload["outputModelSchema"] = resolve_schema_input(
                 params.output_model_schema

hyperbrowser/client/managers/async_manager/agents/claude_computer_use.py

@@ -6,7 +6,7 @@
     wait_for_job_result_async,
 )
 from ...response_utils import parse_response_model
-from .....exceptions import HyperbrowserError
+from ...serialization_utils import serialize_model_dump_to_dict
 
 from .....models import (
     POLLING_ATTEMPTS,
@@ -25,19 +25,10 @@ def __init__(self, client):
     async def start(
         self, params: StartClaudeComputerUseTaskParams
     ) -> StartClaudeComputerUseTaskResponse:
-        try:
-            payload = params.model_dump(exclude_none=True, by_alias=True)
-        except HyperbrowserError:
-            raise
-        except Exception as exc:
-            raise HyperbrowserError(
-                "Failed to serialize Claude Computer Use start params",
-                original_error=exc,
-            ) from exc
-        if type(payload) is not dict:
-            raise HyperbrowserError(
-                "Failed to serialize Claude Computer Use start params"
-            )
+        payload = serialize_model_dump_to_dict(
+            params,
+            error_message="Failed to serialize Claude Computer Use start params",
+        )
         response = await self._client.transport.post(
             self._client._build_url("/task/claude-computer-use"),
             data=payload,

hyperbrowser/client/managers/async_manager/agents/cua.py

@@ -6,7 +6,7 @@
     wait_for_job_result_async,
 )
 from ...response_utils import parse_response_model
-from .....exceptions import HyperbrowserError
+from ...serialization_utils import serialize_model_dump_to_dict
 
 from .....models import (
     POLLING_ATTEMPTS,
@@ -23,17 +23,10 @@ def __init__(self, client):
         self._client = client
 
     async def start(self, params: StartCuaTaskParams) -> StartCuaTaskResponse:
-        try:
-            payload = params.model_dump(exclude_none=True, by_alias=True)
-        except HyperbrowserError:
-            raise
-        except Exception as exc:
-            raise HyperbrowserError(
-                "Failed to serialize CUA start params",
-                original_error=exc,
-            ) from exc
-        if type(payload) is not dict:
-            raise HyperbrowserError("Failed to serialize CUA start params")
+        payload = serialize_model_dump_to_dict(
+            params,
+            error_message="Failed to serialize CUA start params",
+        )
         response = await self._client.transport.post(
             self._client._build_url("/task/cua"),
             data=payload,

hyperbrowser/client/managers/async_manager/agents/gemini_computer_use.py

@@ -6,7 +6,7 @@
     wait_for_job_result_async,
 )
 from ...response_utils import parse_response_model
-from .....exceptions import HyperbrowserError
+from ...serialization_utils import serialize_model_dump_to_dict
 
 from .....models import (
     POLLING_ATTEMPTS,
@@ -25,19 +25,10 @@ def __init__(self, client):
     async def start(
         self, params: StartGeminiComputerUseTaskParams
     ) -> StartGeminiComputerUseTaskResponse:
-        try:
-            payload = params.model_dump(exclude_none=True, by_alias=True)
-        except HyperbrowserError:
-            raise
-        except Exception as exc:
-            raise HyperbrowserError(
-                "Failed to serialize Gemini Computer Use start params",
-                original_error=exc,
-            ) from exc
-        if type(payload) is not dict:
-            raise HyperbrowserError(
-                "Failed to serialize Gemini Computer Use start params"
-            )
+        payload = serialize_model_dump_to_dict(
+            params,
+            error_message="Failed to serialize Gemini Computer Use start params",
+        )
         response = await self._client.transport.post(
             self._client._build_url("/task/gemini-computer-use"),
             data=payload,

hyperbrowser/client/managers/async_manager/agents/hyper_agent.py

@@ -6,7 +6,7 @@
     wait_for_job_result_async,
 )
 from ...response_utils import parse_response_model
-from .....exceptions import HyperbrowserError
+from ...serialization_utils import serialize_model_dump_to_dict
 
 from .....models import (
     POLLING_ATTEMPTS,
@@ -25,17 +25,10 @@ def __init__(self, client):
     async def start(
         self, params: StartHyperAgentTaskParams
     ) -> StartHyperAgentTaskResponse:
-        try:
-            payload = params.model_dump(exclude_none=True, by_alias=True)
-        except HyperbrowserError:
-            raise
-        except Exception as exc:
-            raise HyperbrowserError(
-                "Failed to serialize HyperAgent start params",
-                original_error=exc,
-            ) from exc
-        if type(payload) is not dict:
-            raise HyperbrowserError("Failed to serialize HyperAgent start params")
+        payload = serialize_model_dump_to_dict(
+            params,
+            error_message="Failed to serialize HyperAgent start params",
+        )
         response = await self._client.transport.post(
             self._client._build_url("/task/hyper-agent"),
             data=payload,

hyperbrowser/client/managers/async_manager/computer_action.py

@@ -2,6 +2,7 @@
 from typing import Union, List, Optional
 from hyperbrowser.exceptions import HyperbrowserError
 from ..response_utils import parse_response_model
+from ..serialization_utils import serialize_model_dump_to_dict
 from hyperbrowser.models import (
     SessionDetail,
     ComputerActionParams,
@@ -91,15 +92,12 @@ async def _execute_request(
             )
 
         if isinstance(params, BaseModel):
-            try:
-                payload = params.model_dump(by_alias=True, exclude_none=True)
-            except HyperbrowserError:
-                raise
-            except Exception as exc:
-                raise HyperbrowserError(
-                    "Failed to serialize computer action params",
-                    original_error=exc,
-                ) from exc
+            payload = serialize_model_dump_to_dict(
+                params,
+                error_message="Failed to serialize computer action params",
+                by_alias=True,
+                exclude_none=True,
+            )
         else:
             payload = params
 

hyperbrowser/client/managers/async_manager/extension.py

@@ -2,6 +2,7 @@
 
 from hyperbrowser.exceptions import HyperbrowserError
 from ...file_utils import ensure_existing_file_path
+from ..serialization_utils import serialize_model_dump_to_dict
 from ..extension_utils import parse_extension_list_response_data
 from ..response_utils import parse_response_model
 from hyperbrowser.models.extension import CreateExtensionParams, ExtensionResponse
@@ -23,17 +24,10 @@ async def create(self, params: CreateExtensionParams) -> ExtensionResponse:
                 "params.file_path is invalid",
                 original_error=exc,
             ) from exc
-        try:
-            payload = params.model_dump(exclude_none=True, by_alias=True)
-        except HyperbrowserError:
-            raise
-        except Exception as exc:
-            raise HyperbrowserError(
-                "Failed to serialize extension create params",
-                original_error=exc,
-            ) from exc
-        if type(payload) is not dict:
-            raise HyperbrowserError("Failed to serialize extension create params")
+        payload = serialize_model_dump_to_dict(
+            params,
+            error_message="Failed to serialize extension create params",
+        )
         payload.pop("filePath", None)
 
         file_path = ensure_existing_file_path(

hyperbrowser/client/managers/async_manager/extract.py

@@ -13,6 +13,7 @@
     ensure_started_job_id,
     wait_for_job_result_async,
 )
+from ..serialization_utils import serialize_model_dump_to_dict
 from ...schema_utils import resolve_schema_input
 from ..response_utils import parse_response_model
 
@@ -25,17 +26,10 @@ async def start(self, params: StartExtractJobParams) -> StartExtractJobResponse:
         if not params.schema_ and not params.prompt:
             raise HyperbrowserError("Either schema or prompt must be provided")
 
-        try:
-            payload = params.model_dump(exclude_none=True, by_alias=True)
-        except HyperbrowserError:
-            raise
-        except Exception as exc:
-            raise HyperbrowserError(
-                "Failed to serialize extract start params",
-                original_error=exc,
-            ) from exc
-        if type(payload) is not dict:
-            raise HyperbrowserError("Failed to serialize extract start params")
+        payload = serialize_model_dump_to_dict(
+            params,
+            error_message="Failed to serialize extract start params",
+        )
         if params.schema_:
             payload["schema"] = resolve_schema_input(params.schema_)
 

hyperbrowser/client/managers/async_manager/profile.py

@@ -1,6 +1,5 @@
 from typing import Optional
 
-from hyperbrowser.exceptions import HyperbrowserError
 from hyperbrowser.models.profile import (
     CreateProfileParams,
     CreateProfileResponse,
@@ -9,6 +8,7 @@
     ProfileResponse,
 )
 from hyperbrowser.models.session import BasicResponse
+from ..serialization_utils import serialize_model_dump_to_dict
 from ..response_utils import parse_response_model
 
 
@@ -21,17 +21,10 @@ async def create(
     ) -> CreateProfileResponse:
         payload = {}
         if params is not None:
-            try:
-                payload = params.model_dump(exclude_none=True, by_alias=True)
-            except HyperbrowserError:
-                raise
-            except Exception as exc:
-                raise HyperbrowserError(
-                    "Failed to serialize profile create params",
-                    original_error=exc,
-                ) from exc
-            if type(payload) is not dict:
-                raise HyperbrowserError("Failed to serialize profile create params")
+            payload = serialize_model_dump_to_dict(
+                params,
+                error_message="Failed to serialize profile create params",
+            )
         response = await self._client.transport.post(
             self._client._build_url("/profile"),
             data=payload,
@@ -66,17 +59,10 @@ async def list(
         self, params: Optional[ProfileListParams] = None
     ) -> ProfileListResponse:
         params_obj = params or ProfileListParams()
-        try:
-            query_params = params_obj.model_dump(exclude_none=True, by_alias=True)
-        except HyperbrowserError:
-            raise
-        except Exception as exc:
-            raise HyperbrowserError(
-                "Failed to serialize profile list params",
-                original_error=exc,
-            ) from exc
-        if type(query_params) is not dict:
-            raise HyperbrowserError("Failed to serialize profile list params")
+        query_params = serialize_model_dump_to_dict(
+            params_obj,
+            error_message="Failed to serialize profile list params",
+        )
         response = await self._client.transport.get(
             self._client._build_url("/profiles"),
             params=query_params,

hyperbrowser/client/managers/async_manager/web/__init__.py

@@ -1,13 +1,13 @@
 from .batch_fetch import BatchFetchManager
 from .crawl import WebCrawlManager
-from hyperbrowser.exceptions import HyperbrowserError
 from hyperbrowser.models import (
     FetchParams,
     FetchResponse,
     WebSearchParams,
     WebSearchResponse,
 )
 from ....schema_utils import inject_web_output_schemas
+from ...serialization_utils import serialize_model_dump_to_dict
 from ...response_utils import parse_response_model
 
 
@@ -18,17 +18,10 @@ def __init__(self, client):
         self.crawl = WebCrawlManager(client)
 
     async def fetch(self, params: FetchParams) -> FetchResponse:
-        try:
-            payload = params.model_dump(exclude_none=True, by_alias=True)
-        except HyperbrowserError:
-            raise
-        except Exception as exc:
-            raise HyperbrowserError(
-                "Failed to serialize web fetch params",
-                original_error=exc,
-            ) from exc
-        if type(payload) is not dict:
-            raise HyperbrowserError("Failed to serialize web fetch params")
+        payload = serialize_model_dump_to_dict(
+            params,
+            error_message="Failed to serialize web fetch params",
+        )
         inject_web_output_schemas(
             payload, params.outputs.formats if params.outputs else None
         )
@@ -44,17 +37,10 @@ async def fetch(self, params: FetchParams) -> FetchResponse:
         )
 
     async def search(self, params: WebSearchParams) -> WebSearchResponse:
-        try:
-            payload = params.model_dump(exclude_none=True, by_alias=True)
-        except HyperbrowserError:
-            raise
-        except Exception as exc:
-            raise HyperbrowserError(
-                "Failed to serialize web search params",
-                original_error=exc,
-            ) from exc
-        if type(payload) is not dict:
-            raise HyperbrowserError("Failed to serialize web search params")
+        payload = serialize_model_dump_to_dict(
+            params,
+            error_message="Failed to serialize web search params",
+        )
         response = await self._client.transport.post(
             self._client._build_url("/web/search"),
             data=payload,