Use shared plain-type helpers in manager and tool boundaries

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

Author: cursoragent

hyperbrowser/client/managers/async_manager/computer_action.py

@@ -1,7 +1,7 @@
 from pydantic import BaseModel
 from typing import Union, List, Optional
 from hyperbrowser.exceptions import HyperbrowserError
-from hyperbrowser.type_utils import is_string_subclass_instance
+from hyperbrowser.type_utils import is_plain_string, is_string_subclass_instance
 from ..response_utils import parse_response_model
 from ..serialization_utils import serialize_model_dump_to_dict
 from hyperbrowser.models import (
@@ -32,7 +32,7 @@ def __init__(self, client):
     async def _execute_request(
         self, session: Union[SessionDetail, str], params: ComputerActionParams
     ) -> ComputerActionResponse:
-        if type(session) is str:
+        if is_plain_string(session):
             session = await self._client.sessions.get(session)
         elif is_string_subclass_instance(session):
             raise HyperbrowserError(
@@ -53,11 +53,11 @@ async def _execute_request(
             raise HyperbrowserError(
                 "Computer action endpoint not available for this session"
             )
-        if type(computer_action_endpoint) is not str:
+        if not is_plain_string(computer_action_endpoint):
             raise HyperbrowserError("session computer_action_endpoint must be a string")
         try:
             normalized_computer_action_endpoint = computer_action_endpoint.strip()
-            if type(normalized_computer_action_endpoint) is not str:
+            if not is_plain_string(normalized_computer_action_endpoint):
                 raise TypeError("normalized computer_action_endpoint must be a string")
         except HyperbrowserError:
             raise

hyperbrowser/client/managers/async_manager/session.py

@@ -3,7 +3,7 @@
 from typing import IO, List, Optional, Union, overload
 import warnings
 from hyperbrowser.exceptions import HyperbrowserError
-from hyperbrowser.type_utils import is_string_subclass_instance
+from hyperbrowser.type_utils import is_plain_string, is_string_subclass_instance
 from ...file_utils import ensure_existing_file_path
 from ..serialization_utils import serialize_model_dump_to_dict
 from ..session_utils import (
@@ -166,7 +166,7 @@ async def get_downloads_url(self, id: str) -> GetSessionDownloadsUrlResponse:
     async def upload_file(
         self, id: str, file_input: Union[str, PathLike[str], IO]
     ) -> UploadFileResponse:
-        if type(file_input) is str or isinstance(file_input, PathLike):
+        if is_plain_string(file_input) or isinstance(file_input, PathLike):
             try:
                 raw_file_path = os.fspath(file_input)
             except HyperbrowserError:

hyperbrowser/client/managers/sync_manager/computer_action.py

@@ -1,7 +1,7 @@
 from pydantic import BaseModel
 from typing import Union, List, Optional
 from hyperbrowser.exceptions import HyperbrowserError
-from hyperbrowser.type_utils import is_string_subclass_instance
+from hyperbrowser.type_utils import is_plain_string, is_string_subclass_instance
 from ..response_utils import parse_response_model
 from ..serialization_utils import serialize_model_dump_to_dict
 from hyperbrowser.models import (
@@ -32,7 +32,7 @@ def __init__(self, client):
     def _execute_request(
         self, session: Union[SessionDetail, str], params: ComputerActionParams
     ) -> ComputerActionResponse:
-        if type(session) is str:
+        if is_plain_string(session):
             session = self._client.sessions.get(session)
         elif is_string_subclass_instance(session):
             raise HyperbrowserError(
@@ -53,11 +53,11 @@ def _execute_request(
             raise HyperbrowserError(
                 "Computer action endpoint not available for this session"
             )
-        if type(computer_action_endpoint) is not str:
+        if not is_plain_string(computer_action_endpoint):
             raise HyperbrowserError("session computer_action_endpoint must be a string")
         try:
             normalized_computer_action_endpoint = computer_action_endpoint.strip()
-            if type(normalized_computer_action_endpoint) is not str:
+            if not is_plain_string(normalized_computer_action_endpoint):
                 raise TypeError("normalized computer_action_endpoint must be a string")
         except HyperbrowserError:
             raise

hyperbrowser/client/managers/sync_manager/session.py

@@ -3,7 +3,7 @@
 from typing import IO, List, Optional, Union, overload
 import warnings
 from hyperbrowser.exceptions import HyperbrowserError
-from hyperbrowser.type_utils import is_string_subclass_instance
+from hyperbrowser.type_utils import is_plain_string, is_string_subclass_instance
 from ...file_utils import ensure_existing_file_path
 from ..serialization_utils import serialize_model_dump_to_dict
 from ..session_utils import (
@@ -158,7 +158,7 @@ def get_downloads_url(self, id: str) -> GetSessionDownloadsUrlResponse:
     def upload_file(
         self, id: str, file_input: Union[str, PathLike[str], IO]
     ) -> UploadFileResponse:
-        if type(file_input) is str or isinstance(file_input, PathLike):
+        if is_plain_string(file_input) or isinstance(file_input, PathLike):
             try:
                 raw_file_path = os.fspath(file_input)
             except HyperbrowserError:

hyperbrowser/tools/__init__.py

@@ -9,7 +9,7 @@
     copy_mapping_values_by_string_keys,
     read_string_mapping_keys,
 )
-from hyperbrowser.type_utils import is_string_subclass_instance
+from hyperbrowser.type_utils import is_plain_string, is_string_subclass_instance
 from hyperbrowser.models.agents.browser_use import StartBrowserUseTaskParams
 from hyperbrowser.models.crawl import StartCrawlJobParams
 from hyperbrowser.models.extract import StartExtractJobParams
@@ -86,12 +86,12 @@ def _prepare_extract_tool_params(params: Mapping[str, Any]) -> Dict[str, Any]:
     normalized_params = _to_param_dict(params)
     schema_value = normalized_params.get("schema")
     if schema_value is not None and not (
-        type(schema_value) is str or isinstance(schema_value, MappingABC)
+        is_plain_string(schema_value) or isinstance(schema_value, MappingABC)
     ):
         raise HyperbrowserError(
             "Extract tool `schema` must be an object or JSON string"
         )
-    if type(schema_value) is str:
+    if is_plain_string(schema_value):
         try:
             parsed_schema = json.loads(schema_value)
         except HyperbrowserError:
@@ -121,7 +121,7 @@ def _to_param_dict(params: Mapping[str, Any]) -> Dict[str, Any]:
     for key in param_keys:
         try:
             normalized_key = key.strip()
-            if type(normalized_key) is not str:
+            if not is_plain_string(normalized_key):
                 raise TypeError("normalized tool param key must be a string")
             is_empty_key = len(normalized_key) == 0
         except HyperbrowserError:
@@ -176,7 +176,7 @@ def _serialize_extract_tool_data(data: Any) -> str:
         return ""
     try:
         serialized_data = json.dumps(data, allow_nan=False)
-        if type(serialized_data) is not str:
+        if not is_plain_string(serialized_data):
             raise TypeError("serialized extract tool response data must be a string")
         return serialized_data
     except HyperbrowserError:
@@ -195,10 +195,10 @@ def _normalize_optional_text_field_value(
 ) -> str:
     if field_value is None:
         return ""
-    if type(field_value) is str:
+    if is_plain_string(field_value):
         try:
             normalized_field_value = "".join(character for character in field_value)
-            if type(normalized_field_value) is not str:
+            if not is_plain_string(normalized_field_value):
                 raise TypeError("normalized text field must be a string")
             return normalized_field_value
         except HyperbrowserError:
@@ -213,7 +213,7 @@ def _normalize_optional_text_field_value(
     if isinstance(field_value, (bytes, bytearray, memoryview)):
         try:
             normalized_field_value = memoryview(field_value).tobytes().decode("utf-8")
-            if type(normalized_field_value) is not str:
+            if not is_plain_string(normalized_field_value):
                 raise TypeError("normalized text field must be a string")
             return normalized_field_value
         except (TypeError, ValueError, UnicodeDecodeError) as exc: