Reuse mapping key-copy helper in tools

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

Author: cursoragent

hyperbrowser/mapping_utils.py

@@ -46,3 +46,30 @@ def read_string_key_mapping(
                 original_error=exc,
             ) from exc
     return normalized_mapping
+
+
+def copy_mapping_values_by_string_keys(
+    mapping_value: MappingABC[object, Any],
+    keys: list[str],
+    *,
+    read_value_error_builder: Callable[[str], str],
+    key_display: Callable[[str], str],
+) -> Dict[str, object]:
+    normalized_mapping: Dict[str, object] = {}
+    for key in keys:
+        try:
+            normalized_mapping[key] = mapping_value[key]
+        except HyperbrowserError:
+            raise
+        except Exception as exc:
+            try:
+                key_text = key_display(key)
+                if type(key_text) is not str:
+                    raise TypeError("mapping key display must be a string")
+            except Exception:
+                key_text = "<unreadable key>"
+            raise HyperbrowserError(
+                read_value_error_builder(key_text),
+                original_error=exc,
+            ) from exc
+    return normalized_mapping

hyperbrowser/tools/__init__.py

@@ -1,10 +1,11 @@
 import inspect
 import json
 from collections.abc import Mapping as MappingABC
-from typing import Any, Callable, Dict, Mapping
+from typing import Any, Dict, Mapping
 
 from hyperbrowser.display_utils import normalize_display_text
 from hyperbrowser.exceptions import HyperbrowserError
+from hyperbrowser.mapping_utils import copy_mapping_values_by_string_keys
 from hyperbrowser.models.agents.browser_use import StartBrowserUseTaskParams
 from hyperbrowser.models.crawl import StartCrawlJobParams
 from hyperbrowser.models.extract import StartExtractJobParams
@@ -62,27 +63,6 @@ def _format_tool_param_key_for_error(key: str) -> str:
     return normalized_key
 
 
-def _copy_mapping_values_by_keys(
-    source_mapping: MappingABC[object, Any],
-    keys: list[str],
-    *,
-    read_error_message_builder: Callable[[str], str],
-) -> Dict[str, Any]:
-    normalized_values: Dict[str, Any] = {}
-    for key in keys:
-        try:
-            normalized_values[key] = source_mapping[key]
-        except HyperbrowserError:
-            raise
-        except Exception as exc:
-            key_display = _format_tool_param_key_for_error(key)
-            raise HyperbrowserError(
-                read_error_message_builder(key_display),
-                original_error=exc,
-            ) from exc
-    return normalized_values
-
-
 def _normalize_extract_schema_mapping(
     schema_value: MappingABC[object, Any],
 ) -> Dict[str, Any]:
@@ -100,12 +80,13 @@ def _normalize_extract_schema_mapping(
         if type(key) is not str:
             raise HyperbrowserError("Extract tool `schema` object keys must be strings")
         normalized_schema_keys.append(key)
-    return _copy_mapping_values_by_keys(
+    return copy_mapping_values_by_string_keys(
         schema_value,
         normalized_schema_keys,
-        read_error_message_builder=lambda key_display: (
+        read_value_error_builder=lambda key_display: (
             f"Failed to read extract tool `schema` value for key '{key_display}'"
         ),
+        key_display=_format_tool_param_key_for_error,
     )
 
 
@@ -197,12 +178,13 @@ def _to_param_dict(params: Mapping[str, Any]) -> Dict[str, Any]:
             continue
         raise HyperbrowserError("tool params keys must be strings")
     normalized_param_keys = [key for key in param_keys if type(key) is str]
-    return _copy_mapping_values_by_keys(
+    return copy_mapping_values_by_string_keys(
         params,
         normalized_param_keys,
-        read_error_message_builder=lambda key_display: (
+        read_value_error_builder=lambda key_display: (
             f"Failed to read tool param '{key_display}'"
         ),
+        key_display=_format_tool_param_key_for_error,
     )
 
 

tests/test_mapping_utils.py

@@ -3,7 +3,10 @@
 import pytest
 
 from hyperbrowser.exceptions import HyperbrowserError
-from hyperbrowser.mapping_utils import read_string_key_mapping
+from hyperbrowser.mapping_utils import (
+    copy_mapping_values_by_string_keys,
+    read_string_key_mapping,
+)
 
 
 class _BrokenKeysMapping(Mapping[object, object]):
@@ -111,3 +114,60 @@ def test_read_string_key_mapping_falls_back_for_unreadable_key_display():
             ),
             key_display=lambda key: key.encode("utf-8"),
         )
+
+
+def test_copy_mapping_values_by_string_keys_returns_selected_values():
+    copied_values = copy_mapping_values_by_string_keys(
+        {"field": "value", "other": "ignored"},
+        ["field"],
+        read_value_error_builder=lambda key_display: (
+            f"failed value for '{key_display}'"
+        ),
+        key_display=lambda key: key,
+    )
+
+    assert copied_values == {"field": "value"}
+
+
+def test_copy_mapping_values_by_string_keys_wraps_value_read_failures():
+    with pytest.raises(
+        HyperbrowserError, match="failed value for 'field'"
+    ) as exc_info:
+        copy_mapping_values_by_string_keys(
+            _BrokenValueMapping(),
+            ["field"],
+            read_value_error_builder=lambda key_display: (
+                f"failed value for '{key_display}'"
+            ),
+            key_display=lambda key: key,
+        )
+
+    assert isinstance(exc_info.value.original_error, RuntimeError)
+
+
+def test_copy_mapping_values_by_string_keys_preserves_hyperbrowser_failures():
+    with pytest.raises(HyperbrowserError, match="custom value read failure") as exc_info:
+        copy_mapping_values_by_string_keys(
+            _HyperbrowserValueFailureMapping(),
+            ["field"],
+            read_value_error_builder=lambda key_display: (
+                f"failed value for '{key_display}'"
+            ),
+            key_display=lambda key: key,
+        )
+
+    assert exc_info.value.original_error is None
+
+
+def test_copy_mapping_values_by_string_keys_falls_back_for_unreadable_key_display():
+    with pytest.raises(
+        HyperbrowserError, match="failed value for '<unreadable key>'"
+    ):
+        copy_mapping_values_by_string_keys(
+            _BrokenValueMapping(),
+            ["field"],
+            read_value_error_builder=lambda key_display: (
+                f"failed value for '{key_display}'"
+            ),
+            key_display=lambda key: key.encode("utf-8"),
+        )