langfun 0.1.2.dev202506190804__tar.gz → 0.1.2.dev202512150805__tar.gz

{langfun-0.1.2.dev202506190804 → langfun-0.1.2.dev202512150805}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfun
-Version: 0.1.2.dev202506190804
+Version: 0.1.2.dev202512150805
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors
@@ -21,30 +21,32 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pyglove>=0.4.5.dev202409110000
+Requires-Dist: anyio>=4.7.0
 Requires-Dist: jinja2>=3.1.2
+Requires-Dist: mcp>=1.17.0
+Requires-Dist: puremagic>=1.20
+Requires-Dist: pyglove>=0.5.0.dev202510170226
 Requires-Dist: requests>=2.31.0
 Provides-Extra: all
-Requires-Dist: pyglove>=0.4.5.dev202409110000; extra == "all"
+Requires-Dist: anyio>=4.7.0; extra == "all"
 Requires-Dist: jinja2>=3.1.2; extra == "all"
+Requires-Dist: mcp>=1.17.0; extra == "all"
+Requires-Dist: puremagic>=1.20; extra == "all"
+Requires-Dist: pyglove>=0.5.0.dev202510170226; extra == "all"
 Requires-Dist: requests>=2.31.0; extra == "all"
-Requires-Dist: termcolor==1.1.0; extra == "all"
-Requires-Dist: tqdm>=4.64.1; extra == "all"
 Requires-Dist: google-auth>=2.16.0; extra == "all"
-Requires-Dist: python-magic>=0.4.27; extra == "all"
 Requires-Dist: pillow>=10.0.0; extra == "all"
-Provides-Extra: ui
-Requires-Dist: termcolor==1.1.0; extra == "ui"
-Requires-Dist: tqdm>=4.64.1; extra == "ui"
+Requires-Dist: termcolor==1.1.0; extra == "all"
+Requires-Dist: tqdm>=4.64.1; extra == "all"
 Provides-Extra: vertexai
 Requires-Dist: google-auth>=2.16.0; extra == "vertexai"
 Provides-Extra: mime
-Requires-Dist: python-magic>=0.4.27; extra == "mime"
 Requires-Dist: pillow>=10.0.0; extra == "mime"
-Provides-Extra: mime-auto
-Requires-Dist: python-magic>=0.4.27; extra == "mime-auto"
 Provides-Extra: mime-pil
 Requires-Dist: pillow>=10.0.0; extra == "mime-pil"
+Provides-Extra: ui
+Requires-Dist: termcolor==1.1.0; extra == "ui"
+Requires-Dist: tqdm>=4.64.1; extra == "ui"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -202,37 +204,14 @@ a tag from the list below:
 | all                 | All Langfun features.                    |
 | vertexai            | VertexAI access.                         |
 | mime                | All MIME supports.                       |
-| mime-auto           | Automatic MIME type detection.           |
 | mime-pil            | Image support for PIL.                   |
 | ui                  | UI enhancements                          |
 
 For example, to install a nightly build that includes VertexAI access, full
 modality support, and UI enhancements, use:
-```
-pip install langfun[vertexai,mime,ui] --pre
-```
-
-### Solving import issue with `libmagic`
-
-Langfun utilizes `libmagic` for automatic MIME type detection to support
-multi-modal functionalities. However, `pip install libmagic` may not work
-out-of-the-box on all operation systems, sometimes leading to an
-`'ImportError: failed to find libmagic.'` error after Langfun installation.
-
-If you encounter this error, you will need to follow the recommendations below
-to fix the installation of `libmagic` library.
 
-#### OSX
-
-```
-conda install conda-forge::libmagic
 ```
-
-#### Windows:
-```
-pip install python-magic
-pip uninstall python-magic-bin
-pip install python-magic-bin
+pip install langfun[vertexai,mime,ui] --pre
 ```
 
 *Disclaimer: this is not an officially supported Google product.*

{langfun-0.1.2.dev202506190804 → langfun-0.1.2.dev202512150805}/README.md

@@ -142,37 +142,14 @@ a tag from the list below:
 | all                 | All Langfun features.                    |
 | vertexai            | VertexAI access.                         |
 | mime                | All MIME supports.                       |
-| mime-auto           | Automatic MIME type detection.           |
 | mime-pil            | Image support for PIL.                   |
 | ui                  | UI enhancements                          |
 
 For example, to install a nightly build that includes VertexAI access, full
 modality support, and UI enhancements, use:
-```
-pip install langfun[vertexai,mime,ui] --pre
-```
-
-### Solving import issue with `libmagic`
-
-Langfun utilizes `libmagic` for automatic MIME type detection to support
-multi-modal functionalities. However, `pip install libmagic` may not work
-out-of-the-box on all operation systems, sometimes leading to an
-`'ImportError: failed to find libmagic.'` error after Langfun installation.
-
-If you encounter this error, you will need to follow the recommendations below
-to fix the installation of `libmagic` library.
 
-#### OSX
-
-```
-conda install conda-forge::libmagic
 ```
-
-#### Windows:
-```
-pip install python-magic
-pip uninstall python-magic-bin
-pip install python-magic-bin
+pip install langfun[vertexai,mime,ui] --pre
 ```
 
 *Disclaimer: this is not an officially supported Google product.*

{langfun-0.1.2.dev202506190804 → langfun-0.1.2.dev202512150805}/langfun/__init__.py

@@ -66,8 +66,8 @@ from langfun.core import agentic
 Action = agentic.Action
 Session = agentic.Session
 
+from langfun.core import mcp
 from langfun.core import memories
-
 from langfun.core import modalities
 
 Mime = modalities.Mime

langfun-0.1.2.dev202512150805/langfun/assistant/capabilities/gui/__init__.py

@@ -0,0 +1,36 @@
+# Copyright 2025 The Langfun Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""GUI understanding."""
+
+# pylint: disable=g-bad-import-order
+# pylint: disable=g-importing-member
+# pylint: disable=g-import-not-at-top
+
+from langfun.assistant.capabilities.gui.location import Coordinate
+from langfun.assistant.capabilities.gui.location import BBox
+from langfun.assistant.capabilities.gui import bounding_box_parser
+from langfun.assistant.capabilities.gui import drawing
+import pyglove as pg
+
+# For backward compatibility.
+pg.JSONConvertible.add_module_alias(
+    'langfun.assistant.capabilities.gui', (
+        'langfun.agents.gui',
+        'langfun.agents.tools.gui',
+    )
+)
+
+# pylint: enable=g-bad-import-order
+# pylint: enable=g-importing-member
+# pylint: enable=g-import-not-at-top

langfun-0.1.2.dev202512150805/langfun/assistant/capabilities/gui/bounding_box_parser.py

@@ -0,0 +1,195 @@
+# Copyright 2025 The Langfun Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Customized bounding box related to Gemini Object Detection."""
+
+import json
+import re
+from typing import Any, Dict, List, Tuple, Union
+
+from langfun.assistant.capabilities.gui import location
+import pyglove as pg
+
+
+class GeminiBBox(pg.Object):
+  """Customized bounding box.
+
+  Note: GeminiPro returns a unique JSON response structure for object detection
+  tasks, which differs from the standard location.BBox format. To accommodate 
+  this, we've created this custom class to adapt to GeminiPro's specific 
+  response structure.
+  """
+
+  ymin: int
+  xmin: int
+  ymax: int
+  xmax: int
+
+  def scale(self,
+            target_size: tuple[int, int],
+            source_size: tuple[int, int] = (1000, 1000)) -> 'GeminiBBox':
+
+    def _scale_x(v):
+      return (v * target_size[0]) // source_size[0]
+
+    def _scale_y(v):
+      return (v * target_size[1]) // source_size[1]
+
+    return GeminiBBox(
+        ymin=_scale_y(self.ymin),
+        xmin=_scale_x(self.xmin),
+        ymax=_scale_y(self.ymax),
+        xmax=_scale_x(self.xmax),
+    )
+
+  def resize(
+      self, image_size: Tuple[int, int], resize_factor: int = 3
+  ) -> 'GeminiBBox':
+    """Resize a bounding box from its center.
+
+    Args:
+        image_size: A tuple (width, height) representing the size of the image.
+        resize_factor: The factor by which to resize the bounding box. Defaults
+          to 3.
+
+    Returns:
+        A bounding box with the expanded dimensions.
+    """
+    center_x = (self.xmin + self.xmax) // 2
+    center_y = (self.ymin + self.ymax) // 2
+    width = self.xmax - self.xmin
+    height = self.ymax - self.ymin
+
+    new_width = width * resize_factor
+    new_height = height * resize_factor
+
+    new_xmin = max(0, int(center_x - new_width // 2))
+    new_ymin = max(0, int(center_y - new_height // 2))
+    new_xmax = min(image_size[0], int(center_x + new_width // 2))
+    new_ymax = min(image_size[1], int(center_y + new_height // 2))
+
+    return GeminiBBox(
+        xmin=new_xmin, ymin=new_ymin, xmax=new_xmax, ymax=new_ymax
+    )
+
+  def to_gui_bbox(self) -> location.BBox | None:
+    try:
+      return location.BBox(
+          x=self.xmin, y=self.ymin, right=self.xmax, bottom=self.ymax
+      )
+    except AssertionError:
+      # If the bounding box is not valid, return None.
+      return None
+
+
+def extract_json_candidate_from_text(raw_text: str) -> str:
+  """Extracts a JSON candidate string from raw text."""
+  # Try to find content within ```json ... ```
+  match = re.search(r'```json\s*([\s\S]+?)\s*```', raw_text, re.IGNORECASE)
+  if match:
+    return match.group(1).strip()
+
+  # Try to find content within ``` ... ```
+  match = re.search(r'```\s*([\s\S]+?)\s*```', raw_text)
+  if match:
+    return match.group(1).strip()
+
+  # If no code blocks, return the stripped raw text.
+  return raw_text.strip()
+
+
+def parse_and_convert_json(
+    text: str, screen_size: Tuple[int, int] = (1000, 1000)
+) -> Dict[str, location.BBox | None]:
+  """Parse and convert json to bounding box.
+
+  Args:
+    text: The text to parse.
+    screen_size: The screen size to scale the bounding box.
+
+  Returns:
+    A dictionary of bounding boxes.
+
+  Example:
+  >>> json_text = '```{"search button": [10, 20, 100, 200]}```'
+  >>> bboxes = parse_and_convert_json(json_text, screen_size=(800, 600))
+  >>> print(bboxes)
+  {'search button': BBox(x=16, y=6, right=160, bottom=60)}
+  """
+
+  def parse_json(t: str) -> Union[Dict[str, str], List[str], None]:
+    """Parse text to json."""
+    try:
+      return json.loads(t)
+    except json.JSONDecodeError:
+      return None
+
+  def can_cast_to_int(obj: Any) -> bool:
+    try:
+      int(obj)
+      return True
+    except (ValueError, TypeError):
+      return False
+
+  def convert_to_bbox(
+      data: Union[Dict[str, Any], List[Any], None], screen_size: Tuple[int, int]
+  ) -> Dict[str, location.BBox | None]:
+    """Convert data to bounding box."""
+    result = {}
+    if not data:
+      return result
+
+    if isinstance(data, list):
+      if len(data) == 4 and all(can_cast_to_int(item) for item in data):
+        return {
+            'element': (
+                GeminiBBox(
+                    xmin=int(data[1]),
+                    ymin=int(data[0]),
+                    xmax=int(data[3]),
+                    ymax=int(data[2]),
+                )
+                .scale(screen_size)
+                .to_gui_bbox()
+            )
+        }
+      for item in data:
+        if isinstance(item, dict):
+          result.update(convert_to_bbox(item, screen_size))
+      return result
+
+    for key, value in data.items():
+      if not value:
+        continue
+
+      if isinstance(value, list):
+        if len(value) == 4 and all(can_cast_to_int(item) for item in value):
+          result[key] = (
+              GeminiBBox(
+                  xmin=int(value[1]),
+                  ymin=int(value[0]),
+                  xmax=int(value[3]),
+                  ymax=int(value[2]),
+              )
+              .scale(screen_size)
+              .to_gui_bbox()
+          )
+      elif isinstance(value, dict):
+        result.update(convert_to_bbox(value, screen_size))
+    return result
+
+  parsed_data = parse_json(extract_json_candidate_from_text(text))
+  if parsed_data is None:
+    return {}
+
+  return convert_to_bbox(parsed_data, screen_size)

langfun-0.1.2.dev202512150805/langfun/assistant/capabilities/gui/bounding_box_parser_test.py

@@ -0,0 +1,313 @@
+# Copyright 2025 The Langfun Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Dict, Tuple
+import unittest
+
+from langfun.assistant.capabilities.gui import bounding_box_parser
+from langfun.assistant.capabilities.gui import location
+
+
+class BoundingBoxTest(unittest.TestCase):
+
+  def assert_bbox_equal(
+      self,
+      expected: Dict[str, Tuple[int, int, int, int]],
+      actual: Dict[str, location.BBox],
+  ):
+    self.assertEqual(len(expected), len(actual))
+    for key, value in expected.items():
+      self.assertIn(key, actual)
+      self.assertEqual(value[0], actual[key].x)
+      self.assertEqual(value[1], actual[key].y)
+      self.assertEqual(value[2], actual[key].right)
+      self.assertEqual(value[3], actual[key].bottom)
+
+  def test_bbox_basic_functionality(self):
+    bbox = bounding_box_parser.GeminiBBox(xmin=10, ymin=20, xmax=50, ymax=80)
+
+    self.assertEqual(bbox.xmin, 10)
+    self.assertEqual(bbox.ymin, 20)
+    self.assertEqual(bbox.xmax, 50)
+    self.assertEqual(bbox.ymax, 80)
+
+    # Test the `scale` method
+    target_size = (800, 600)
+    source_size = (1000, 1000)
+    scaled_bbox = bbox.scale(target_size, source_size)
+
+    self.assertEqual(scaled_bbox.xmin, 8)
+    self.assertEqual(scaled_bbox.ymin, 12)
+    self.assertEqual(scaled_bbox.xmax, 40)
+    self.assertEqual(scaled_bbox.ymax, 48)
+
+    # Test the `resize` method
+    resized_bbox = bbox.resize((1200, 800), 2)
+
+    self.assertEqual(resized_bbox.xmin, 0)
+    self.assertEqual(resized_bbox.ymin, 0)
+    self.assertEqual(resized_bbox.xmax, 70)
+    self.assertEqual(resized_bbox.ymax, 110)
+
+    # Test the `to_gui_bbox` method
+    gui_bbox = bbox.to_gui_bbox()
+    self.assertEqual(gui_bbox.x, 10)
+    self.assertEqual(gui_bbox.y, 20)
+    self.assertEqual(gui_bbox.right, 50)
+    self.assertEqual(gui_bbox.bottom, 80)
+
+  def test_simple_json(self):
+    json_text = '{"search button": [10, 20, 100, 200]}'
+    expected = {'search button': (16, 6, 160, 60)}
+    result = bounding_box_parser.parse_and_convert_json(
+        json_text, screen_size=(800, 600)
+    )
+    self.assert_bbox_equal(expected, result)
+
+  def test_multiple_objects(self):
+    json_text = (
+        '{"button1": [10, 20, 100, 200], "button2": [30, 40, 130, 240]}'
+    )
+    expected = {'button1': (16, 6, 160, 60), 'button2': (32, 18, 192, 78)}
+    result = bounding_box_parser.parse_and_convert_json(
+        json_text, screen_size=(800, 600)
+    )
+    self.assert_bbox_equal(expected, result)
+
+  def test_nested_json(self):
+    json_text = (
+        '{"buttons": {"search": [10, 20, 100, 200], "cancel": [30, 40, 130,'
+        ' 240]}}'
+    )
+    expected = {'search': (16, 6, 160, 60), 'cancel': (32, 18, 192, 78)}
+    result = bounding_box_parser.parse_and_convert_json(
+        json_text, screen_size=(800, 600)
+    )
+    self.assert_bbox_equal(expected, result)
+
+  def test_json_in_code_block(self):
+    json_text = '```\n{"search button": [10, 20, 100, 200]}\n```'
+    expected = {'search button': (16, 6, 160, 60)}
+    result = bounding_box_parser.parse_and_convert_json(
+        json_text, screen_size=(800, 600)
+    )
+    self.assert_bbox_equal(expected, result)
+
+  def test_extract_json_candidate_from_text(self):
+    test_cases = [
+        (
+            'Some text before ```json\n{"key": "value"}\n``` and after',
+            '{"key": "value"}',
+        ),
+        (
+            'Some text before ```\n{"key": "value"}\n``` and after',
+            '{"key": "value"}',
+        ),
+        ('{"key": "value"}', '{"key": "value"}'),
+        (
+            '```json\n{\n  "name": "Test",\n  "version": 1\n}\n```',
+            '{\n  "name": "Test",\n  "version": 1\n}',
+        ),
+        (
+            '```\n{\n  "name": "Test",\n  "version": 1\n}\n```',
+            '{\n  "name": "Test",\n  "version": 1\n}',
+        ),
+        (
+            '   ```json\n   {"spaced_json": true}   \n```   ',
+            '{"spaced_json": true}',
+        ),
+        (
+            'No code block here, just plain text.',
+            'No code block here, just plain text.',
+        ),
+        (
+            '```JSON\n{"case_test": "uppercase_json_tag"}\n```',
+            '{"case_test": "uppercase_json_tag"}',
+        ),
+        ('', ''),
+        ('   ', ''),
+        (
+            (
+                'First block: ```json\n{"first": true}\n``` Second block:'
+                ' ```json\n{"second": false}\n```'
+            ),
+            '{"first": true}',
+        ),
+        (
+            (
+                'First block: ```\n{"first_code": true}\n``` Second block:'
+                ' ```\n{"second_code": false}\n```'
+            ),
+            '{"first_code": true}',
+        ),
+        (
+            '```json  \n  {"leading_trailing_space_in_block": "test"}  \n  ```',
+            '{"leading_trailing_space_in_block": "test"}',
+        ),
+        (
+            (
+                '```\n  {"leading_trailing_space_in_block_no_json_tag": "test"}'
+                '  \n  ```'
+            ),
+            '{"leading_trailing_space_in_block_no_json_tag": "test"}',
+        ),
+    ]
+
+    for raw_text, expected_json_str in test_cases:
+      with self.subTest(raw_text=raw_text):
+        self.assertEqual(
+            bounding_box_parser.extract_json_candidate_from_text(raw_text),
+            expected_json_str,
+        )
+
+  def test_dict_in_list(self):
+    json_text = '```json\n[\n  {"box_2d": [61, 22, 160, 95]}\n]\n```'
+    expected = {'box_2d': (22, 61, 95, 160)}
+    result = bounding_box_parser.parse_and_convert_json(json_text)
+    self.assert_bbox_equal(expected, result)
+
+  def test_dict_with_label(self):
+    json_text = """```json
+[
+  {"box_2d": [634, 416, 820, 482], "label": "the inner vertical side of the rightmost lower protrusion of the green polygon"},
+  {"box_2d": [820, 328, 872, 352], "label": "the purple number '1' located to its left"}
+]
+```"""
+    expected = {'box_2d': (328, 820, 352, 872)}
+    result = bounding_box_parser.parse_and_convert_json(json_text)
+    print('result: ', result)
+    self.assert_bbox_equal(expected, result)
+
+  def test_invalid_json(self):
+    json_text = 'This is not a valid JSON'
+    result = bounding_box_parser.parse_and_convert_json(json_text)
+    self.assertEqual({}, result)
+
+  def test_empty_input(self):
+    json_text = ''
+    result = bounding_box_parser.parse_and_convert_json(json_text)
+    self.assertEqual({}, result)
+
+  def test_invalid_list_length(self):
+    # Test with a list of length 3
+    json_text = '{"button": [10, 20, 100]}'
+    result = bounding_box_parser.parse_and_convert_json(json_text)
+    self.assertEqual({}, result)
+
+    # Test with a list of length 5
+    json_text = '{"button": [10, 20, 100, 200, 300]}'
+    result = bounding_box_parser.parse_and_convert_json(json_text)
+    self.assertEqual({}, result)
+
+    # Test with an empty list
+    json_text = '{"button": []}'
+    result = bounding_box_parser.parse_and_convert_json(json_text)
+    self.assertEqual({}, result)
+
+  def test_list_input(self):
+    json_text = '[10, 20, 100, 200]'
+    expected = {'element': (20, 10, 200, 100)}
+    result = bounding_box_parser.parse_and_convert_json(json_text)
+    self.assert_bbox_equal(expected, result)
+
+  def test_default_screen_size(self):
+    json_text = '{"button": [10, 20, 100, 200]}'
+    expected = {'button': (20, 10, 200, 100)}
+    result = bounding_box_parser.parse_and_convert_json(json_text)
+    self.assert_bbox_equal(expected, result)
+
+  def test_float_numbers(self):
+    json_text = '{"button": [10.5, 20.2, 100.7, 200.9]}'
+    expected = {'button': (20, 10, 200, 100)}  # Expected integer coordinates
+    result = bounding_box_parser.parse_and_convert_json(
+        json_text, screen_size=(1000, 1000)
+    )
+    self.assert_bbox_equal(expected, result)
+
+  def test_type_error_handling(self):
+    json_text = '{"button": ["text", 20, 100, 200]}'
+    result = bounding_box_parser.parse_and_convert_json(
+        json_text, screen_size=(1000, 1000)
+    )
+    self.assertEqual({}, result)
+    json_text = '{"button": [None, 20, 100, 200]}'
+    result = bounding_box_parser.parse_and_convert_json(
+        json_text, screen_size=(1000, 1000)
+    )
+    self.assertEqual({}, result)
+
+  def test_malformed_json(self):
+    # Missing quotes around keys
+    json_text = '{search button: [10, 20, 100, 200]}'
+    result = bounding_box_parser.parse_and_convert_json(json_text)
+    self.assertEqual({}, result)
+
+    # Unbalanced brackets
+    json_text = '{"search button": [10, 20, 100, 200}'
+    result = bounding_box_parser.parse_and_convert_json(json_text)
+    self.assertEqual({}, result)
+
+    # Incorrect comma usage
+    json_text = '{"search button", [10, 20, 100, 200]}'
+    result = bounding_box_parser.parse_and_convert_json(json_text)
+    self.assertEqual({}, result)
+
+  def test_mixed_data_types(self):
+    # String values in coordinates
+    json_text = '{"button": ["10", "20", "100", "200"]}'
+    expected = {'button': (20, 10, 200, 100)}
+    result = bounding_box_parser.parse_and_convert_json(
+        json_text, screen_size=(1000, 1000)
+    )
+    self.assert_bbox_equal(expected, result)
+
+  def test_none_values(self):
+    json_text = '{"button": [null, 20, 100, 200]}'
+    result = bounding_box_parser.parse_and_convert_json(
+        json_text, screen_size=(1000, 1000)
+    )
+    self.assertEqual({}, result)
+
+    json_text = '{"button": [10, null, 100, 200]}'
+    result = bounding_box_parser.parse_and_convert_json(
+        json_text, screen_size=(1000, 1000)
+    )
+    self.assertEqual({}, result)
+
+  def test_large_coordinates(self):
+    json_text = '{"button": [10000, 20000, 100000, 200000]}'
+    expected = {'button': (20000, 10000, 200000, 100000)}
+    result = bounding_box_parser.parse_and_convert_json(
+        json_text, screen_size=(1000, 1000)
+    )
+    self.assert_bbox_equal(expected, result)
+
+  def test_different_string_formats(self):
+    # Newlines
+    json_text = '{\n"search button": [10, 20, 100, 200]\n}'
+    expected = {'search button': (16, 6, 160, 60)}
+    result = bounding_box_parser.parse_and_convert_json(
+        json_text, screen_size=(800, 600)
+    )
+    self.assert_bbox_equal(expected, result)
+
+  def test_deeply_nested_json(self):
+    json_text = (
+        '{"layer1": {"layer2": {"layer3": {"button": [10, 20, 100, 200]}}}}'
+    )
+    expected = {'button': (20, 10, 200, 100)}
+    result = bounding_box_parser.parse_and_convert_json(json_text)
+    self.assert_bbox_equal(expected, result)
+
+if __name__ == '__main__':
+  unittest.main()