langfun 0.1.2.dev202507250804__py3-none-any.whl → 0.1.2.dev202507270804__py3-none-any.whl

langfun/assistant/capabilities/gui/location_test.py

@@ -0,0 +1,230 @@
+# 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.
+"""Structures for location objects in an image."""
+
+import random
+import unittest
+from langfun.assistant.capabilities.gui import location
+
+
+class CoordinateTest(unittest.TestCase):
+
+  def test_basics(self):
+    pt = location.Coordinate(1, 2)
+    self.assertEqual(pt.x, 1)
+    self.assertEqual(pt.y, 2)
+    self.assertEqual(pt.as_tuple(), (1, 2))
+
+  def test_random(self):
+    bound = location.BBox(0, 0, 10, 10)
+    rand = random.Random(0)
+    for _ in range(10):
+      pt = location.Coordinate.random(bound, rand=rand)
+      self.assertIsInstance(pt, location.Coordinate)
+      self.assertIn(pt, bound)
+
+  def test_from_value(self):
+    pt = location.Coordinate.from_value((1, 2))
+    self.assertEqual(pt.x, 1)
+    self.assertEqual(pt.y, 2)
+    self.assertIs(location.Coordinate.from_value(pt), pt)
+
+  def test_arithmetic(self):
+    pt1 = location.Coordinate(1, 2)
+    pt2 = location.Coordinate(3, 4)
+    self.assertEqual(pt1 + pt2, location.Coordinate(4, 6))
+    self.assertEqual(pt2 + pt1, location.Coordinate(4, 6))
+    self.assertEqual(pt1 - pt2, location.Coordinate(-2, -2))
+    self.assertEqual(pt2 - pt1, location.Coordinate(2, 2))
+
+    pt1 = location.Coordinate(1, 2)
+    pt2 = (3, 4)
+    self.assertEqual(pt1 + pt2, location.Coordinate(4, 6))
+    self.assertEqual(pt2 + pt1, location.Coordinate(4, 6))
+    self.assertEqual(pt1 - pt2, location.Coordinate(-2, -2))
+    self.assertEqual(pt2 - pt1, location.Coordinate(2, 2))
+
+    self.assertEqual(pt1 * 2, location.Coordinate(2, 4))
+    self.assertEqual(2 * pt1, location.Coordinate(2, 4))
+
+  def test_distance_to(self):
+    pt1 = location.Coordinate(1, 2)
+    pt2 = location.Coordinate(3, 4)
+    # compare float values with a tolerance of 1e-6
+    self.assertAlmostEqual(pt1.distance_to(pt2), 2.8284271247461903, delta=1e-6)
+
+
+class BBoxTest(unittest.TestCase):
+
+  def test_invalid_bbox_creation(self):
+    with self.assertRaisesRegex(AssertionError, '.*'):
+      location.BBox(100, 50, 100, 450)  # Zero width.
+    with self.assertRaisesRegex(AssertionError, '.*'):
+      location.BBox(100, 50, 300, 50)  # Zero height.
+    with self.assertRaisesRegex(AssertionError, '.*'):
+      location.BBox(100, 50, 50, 50)  # Zero width and height
+
+  def test_basics(self):
+    bbox = location.BBox(100, 50, 300, 450)
+    self.assertEqual(bbox.x, 100)
+    self.assertEqual(bbox.y, 50)
+    self.assertEqual(bbox.right, 300)
+    self.assertEqual(bbox.bottom, 450)
+    self.assertEqual(bbox.left, 100)
+    self.assertEqual(bbox.top, 50)
+    self.assertEqual(bbox.width, 200)
+    self.assertEqual(bbox.height, 400)
+
+    self.assertEqual(bbox.center, location.Coordinate(200, 250))
+    self.assertEqual(bbox.top_left, location.Coordinate(100, 50))
+    self.assertEqual(bbox.bottom_right, location.Coordinate(300, 450))
+    self.assertEqual(bbox.area, 80000)
+    self.assertEqual(bbox.as_tuple(), (100, 50, 300, 450))
+
+  def test_contains(self):
+    bbox = location.BBox(100, 50, 300, 450)
+    self.assertIn((120, 200), bbox)
+    self.assertIn(location.Coordinate(120, 200), bbox)
+    self.assertNotIn(location.Coordinate(80, 200), bbox)
+    self.assertNotIn(location.Coordinate(120, 20), bbox)
+    self.assertNotIn(location.Coordinate(320, 200), bbox)
+    self.assertNotIn(location.Coordinate(120, 470), bbox)
+
+    self.assertIn((100, 50, 300, 450), bbox)
+    self.assertIn(location.BBox(100, 50, 300, 450), bbox)
+    self.assertIn(location.BBox(120, 70, 260, 410), bbox)
+    self.assertNotIn(location.BBox(60, 70, 260, 410), bbox)
+    self.assertNotIn(location.BBox(120, 45, 260, 410), bbox)
+    self.assertNotIn(location.BBox(120, 60, 310, 410), bbox)
+    self.assertNotIn(location.BBox(120, 60, 260, 470), bbox)
+    self.assertNotIn(location.BBox(0, 0, 400, 500), bbox)
+
+    with self.assertRaisesRegex(ValueError, 'Invalid tuple size'):
+      _ = (1, 2, 3) in bbox
+
+    with self.assertRaisesRegex(ValueError, 'Invalid type'):
+      _ = 'abc' in bbox  # pytype: disable=unsupported-operands
+
+  def test_intersects(self):
+    bbox = location.BBox(100, 50, 300, 450)
+    self.assertTrue(bbox.intersects(location.BBox(100, 50, 300, 450)))
+    self.assertTrue(bbox.intersects(location.BBox(120, 70, 260, 410)))
+    self.assertTrue(bbox.intersects(location.BBox(60, 70, 260, 470)))
+    self.assertFalse(bbox.intersects(location.BBox(0, 70, 90, 410)))
+    self.assertFalse(bbox.intersects(location.BBox(60, 10, 400, 30)))
+
+  def test_clip(self):
+    # BBox within image bounds
+    bbox = location.BBox(100, 50, 300, 450)
+    clipped_bbox = bbox.clip((400, 500))
+    self.assertEqual(clipped_bbox, bbox)
+
+    # BBox exceeds right and bottom bounds
+    bbox = location.BBox(100, 50, 500, 600)
+    clipped_bbox = bbox.clip((400, 500))
+    self.assertEqual(clipped_bbox, location.BBox(100, 50, 400, 500))
+
+    # BBox exceeds left and top bounds
+    bbox = location.BBox(-10, -20, 300, 450)
+    clipped_bbox = bbox.clip((400, 500))
+    self.assertEqual(clipped_bbox, location.BBox(0, 0, 300, 450))
+
+    # BBox larger than the image
+    bbox = location.BBox(-10, -20, 800, 700)
+    clipped_bbox = bbox.clip((400, 500))
+    self.assertEqual(clipped_bbox, location.BBox(0, 0, 400, 500))
+
+    # BBox starts outside the image boundaries (bottom/right)
+    bbox = location.BBox(500, 600, 700, 800)
+    clipped_bbox = bbox.clip((400, 500))
+    self.assertIsNone(clipped_bbox)
+
+  def test_random(self):
+    bound = location.BBox(0, 0, 800, 600)
+    rand = random.Random(0)
+    for _ in range(10):
+      bbox = location.BBox.random(bound, rand=rand)
+      self.assertIsInstance(bbox, location.BBox)
+      self.assertIn(bbox, bound)
+
+    with self.assertRaisesRegex(
+        ValueError, 'Minimum width or height is larger than the bound'
+    ):
+      _ = location.BBox.random(location.BBox(0, 0, 100, 100), min_width=110)
+
+  def test_matches(self):
+    bbox1 = location.BBox(100, 50, 300, 450)
+    self.assertFalse(bbox1.matches(location.BBox(10, 10, 11, 11)))
+
+    bbox2 = location.BBox(100, 50, 300, 450)
+    self.assertTrue(bbox1.matches(bbox2))
+    self.assertTrue(bbox2.matches(bbox1))
+
+    bbox3 = location.BBox(110, 40, 290, 450)
+    self.assertTrue(bbox1.matches(bbox3))
+    self.assertFalse(bbox3.matches(bbox1, area_diff_threshold=0.05))
+    self.assertFalse(bbox3.matches(bbox1, max_center_distance=1))
+
+  def test_expand(self):
+    # Test case 1: Expanding both width and height.
+    bbox = location.BBox(100, 50, 300, 450)
+    expanded_bbox = bbox.expand(width_scale=1.2, height_scale=1.1)
+    self.assertEqual(expanded_bbox.x, 80)
+    self.assertEqual(expanded_bbox.y, 30)
+    self.assertEqual(expanded_bbox.right, 320)
+    self.assertEqual(expanded_bbox.bottom, 470)
+    self.assertEqual(expanded_bbox.width, 240)
+    self.assertEqual(expanded_bbox.height, 440)
+    self.assertEqual(expanded_bbox.center, location.Coordinate(200, 250))
+
+    # Test case 2: Expanding only width.
+    bbox = location.BBox(100, 50, 300, 450)
+    expanded_bbox = bbox.expand(width_scale=1.2)
+    self.assertEqual(expanded_bbox.x, 80)
+    self.assertEqual(expanded_bbox.y, 50)
+    self.assertEqual(expanded_bbox.right, 320)
+    self.assertEqual(expanded_bbox.bottom, 450)
+    self.assertEqual(expanded_bbox.width, 240)
+    self.assertEqual(expanded_bbox.height, 400)
+    self.assertEqual(expanded_bbox.center, location.Coordinate(200, 250))
+
+    # Test case 3: Expanding only height.
+    bbox = location.BBox(100, 50, 300, 450)
+    expanded_bbox = bbox.expand(height_scale=1.1)
+    self.assertEqual(expanded_bbox.x, 100)
+    self.assertEqual(expanded_bbox.y, 30)
+    self.assertEqual(expanded_bbox.right, 300)
+    self.assertEqual(expanded_bbox.bottom, 470)
+    self.assertEqual(expanded_bbox.width, 200)
+    self.assertEqual(expanded_bbox.height, 440)
+    self.assertEqual(expanded_bbox.center, location.Coordinate(200, 250))
+
+    # Test case 4: Shrinking.
+    bbox = location.BBox(100, 50, 300, 450)
+    expanded_bbox = bbox.expand(width_scale=0.8, height_scale=0.9)
+    self.assertEqual(expanded_bbox.x, 120)
+    self.assertEqual(expanded_bbox.y, 70)
+    self.assertEqual(expanded_bbox.right, 280)
+    self.assertEqual(expanded_bbox.bottom, 430)
+    self.assertEqual(expanded_bbox.width, 160)
+    self.assertEqual(expanded_bbox.height, 360)
+    self.assertEqual(expanded_bbox.center, location.Coordinate(200, 250))
+
+    # Test case 5: No change.
+    bbox = location.BBox(100, 50, 300, 450)
+    expanded_bbox = bbox.expand(width_scale=1.0, height_scale=1.0)
+    self.assertEqual(expanded_bbox, bbox)
+
+if __name__ == '__main__':
+  unittest.main()

langfun/core/__init__.py

@@ -40,6 +40,9 @@ from langfun.core.component import context
 as_context = context
 use_context = context
 
+# Invoke a callable object asynchronously.
+from langfun.core.async_support import invoke_async
+
 # Shortcut function for overriding components attributes, usually for
 # override settings.
 from langfun.core.component import use_settings

langfun/core/agentic/action.py

@@ -199,6 +199,24 @@ class Action(pg.Object):
     """Returns last invocation. None if the action is not executed."""
     return self._invocation
 
+  async def acall(
+      self,
+      session: Optional['Session'] = None,
+      *,
+      show_progress: bool = True,
+      verbose: bool = False,
+      **kwargs
+  ) -> Any:
+    """Async version of `__call__`."""
+    # TODO(daiyip): implement native async calling.
+    return await lf.invoke_async(
+        self.__call__,
+        session,
+        show_progress=show_progress,
+        verbose=verbose,
+        **kwargs
+    )
+
   def __call__(
       self,
       session: Optional['Session'] = None,

langfun/core/agentic/action_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Tests for base action."""
 
+import asyncio
 import unittest
 
 import langfun.core as lf
@@ -32,7 +33,7 @@ class Bar(action_lib.Action):
     session.add_metadata(note='bar')
     if self.simulate_action_error:
       raise ValueError('Bar error')
-    return 2
+    return 2 + pg.contextual_value('baz', 0)
 
 
 class Foo(action_lib.Action):
@@ -237,6 +238,12 @@ class SessionTest(unittest.TestCase):
     json_str = session.to_json_str(save_ref_value=True)
     self.assertIsInstance(pg.from_json_str(json_str), action_lib.Session)
 
+  def test_acall(self):
+    bar = Bar()
+    with lf.context(baz=1):
+      r = bar.acall(lm=fake.StaticResponse('lm response'))
+      self.assertEqual(asyncio.run(r), 3)
+
   def test_failed_action(self):
     lm = fake.StaticResponse('lm response')
     foo = Foo(1, simulate_action_error=True)

langfun/core/async_support.py

@@ -0,0 +1,28 @@
+# 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.
+"""Utility for async IO in Langfun."""
+
+import asyncio
+from typing import Any, Callable
+import pyglove as pg
+
+
+async def invoke_async(
+    callable_object: Callable[..., Any], *args, **kwargs
+) -> Any:
+  """Invokes a callable asynchronously with `lf.context` manager enabled."""
+  return await asyncio.to_thread(
+      # Enable `lf.context` manager for async calls.
+      pg.with_contextual_override(callable_object), *args, **kwargs
+  )

langfun/core/async_support_test.py

@@ -0,0 +1,39 @@
+# 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.
+
+import asyncio
+import time
+import unittest
+
+from langfun.core import async_support
+import pyglove as pg
+
+
+class AsyncSupportTest(unittest.TestCase):
+
+  def test_invoke_async(self):
+
+    def foo(x, *, y):
+      time.sleep(2)
+      return x + y + pg.contextual_value('z', 0)
+
+    t = time.time()
+    r = async_support.invoke_async(foo, 1, y=2)
+    self.assertLess(time.time() - t, 1)
+    with pg.contextual_override(z=3):
+      self.assertEqual(asyncio.run(r), 6)
+
+
+if __name__ == '__main__':
+  unittest.main()

langfun/core/concurrent_test.py

@@ -334,11 +334,12 @@ class ProgressBarTest(unittest.TestCase):
       sys.stderr.flush()
       time.sleep(1)
     self.assertIn('1/4', string_io.getvalue())
-    self.assertIn('2/4', string_io.getvalue())
-    self.assertIn('hello', string_io.getvalue())
-    self.assertNotIn('3/4', string_io.getvalue())
-    self.assertIn('4/4', string_io.getvalue())
-    self.assertIn('x=1', string_io.getvalue())
+    # TODO(daiyip): Re-enable once flakiness is fixed.
+    # self.assertIn('2/4', string_io.getvalue())
+    # self.assertIn('hello', string_io.getvalue())
+    # self.assertNotIn('3/4', string_io.getvalue())
+    # self.assertIn('4/4', string_io.getvalue())
+    # self.assertIn('x=1', string_io.getvalue())
 
 
 class ConcurrentMapTest(unittest.TestCase):

langfun/core/language_model.py

@@ -24,6 +24,7 @@ import re
 import threading
 import time
 from typing import Annotated, Any, Callable, ClassVar, Iterator, Literal, Optional, Sequence, Tuple, Type, Union, final
+from langfun.core import async_support
 from langfun.core import component
 from langfun.core import concurrent
 from langfun.core import console
@@ -922,6 +923,59 @@ class LanguageModel(component.Component):
   # Language model operations.
   #
 
+  async def asample(
+      self,
+      prompts: list[str | message_lib.Message],
+      *,
+      cache_seed: int = 0,
+      **kwargs,
+  ) -> message_lib.Message:
+    """Async version of sample."""
+    # TODO(daiyip): implement native async sampling.
+    return await async_support.invoke_async(
+        self.sample, prompts, cache_seed=cache_seed, **kwargs
+    )
+
+  async def acall(
+      self,
+      prompt: str | message_lib.Message,
+      *,
+      cache_seed: int = 0,
+      **kwargs
+  ) -> message_lib.Message:
+    """Async version of __call__."""
+    # TODO(daiyip): implement native async calling.
+    return await async_support.invoke_async(
+        self.__call__,
+        prompt,
+        cache_seed=cache_seed,
+        **kwargs
+    )
+
+  async def ascore(
+      self,
+      prompt: str | message_lib.Message | list[message_lib.Message],
+      completions: list[str | message_lib.Message],
+      **kwargs,
+  ) -> float:
+    """Async version of score."""
+    # TODO(daiyip): implement native async scoring.
+    return await async_support.invoke_async(
+        self.score,
+        prompt,
+        completions=completions,
+        **kwargs
+    )
+
+  async def atokenize(
+      self,
+      prompt: str | message_lib.Message,
+      **kwargs
+  ) -> list[int]:
+    """Async version of tokenize."""
+    # TODO(daiyip): implement native async tokenization.
+    return await async_support.invoke_async(self.tokenize, prompt, **kwargs)
+
   def sample(
       self,
       prompts: list[str | message_lib.Message],

langfun/core/language_model_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Tests for language model."""
 
+import asyncio
 import contextlib
 import io
 import unittest
@@ -436,6 +437,14 @@ class LanguageModelTest(unittest.TestCase):
         ]
     )
 
+  def test_sample_async(self):
+    lm = MockModel(top_k=1)
+    response = asyncio.run(lm.asample(['foo', 'bar']))
+    self.assertIsInstance(response, list)
+    self.assertEqual(len(response), 2)
+    self.assertIsInstance(response[0], lm_lib.LMSamplingResult)
+    self.assertIsInstance(response[1], lm_lib.LMSamplingResult)
+
   def test_call(self):
     lm = MockModel(sampling_options=lm_lib.LMSamplingOptions(top_k=1))
     response = lm(prompt='foo')
@@ -453,6 +462,11 @@ class LanguageModelTest(unittest.TestCase):
     # Test override individual flags within sampling_options.
     self.assertEqual(lm('foo', top_k=2), 'foo' * 2)
 
+  def test_acall(self):
+    lm = MockModel(sampling_options=lm_lib.LMSamplingOptions(top_k=1))
+    response = asyncio.run(lm.acall(prompt='foo'))
+    self.assertEqual(response.text, 'foo')
+
   def test_using_cache(self):
     cache = in_memory.InMemory()
     lm = MockModel(cache=cache, top_k=1)
@@ -765,6 +779,21 @@ class LanguageModelTest(unittest.TestCase):
       if debug_mode & lm_lib.LMDebugMode.PROMPT:
         self.assertIn('[0] MODALITY OBJECTS SENT TO LM', debug_info)
 
+  def test_ascore(self):
+    lm = MockScoringModel()
+    self.assertEqual(
+        asyncio.run(
+            lm.ascore(
+                message_lib.UserMessage('hi'),
+                ['1', '2']
+            )
+        ),
+        [
+            lm_lib.LMScoringResult(score=-0.0),
+            lm_lib.LMScoringResult(score=-1.0),
+        ],
+    )
+
   def test_score_with_unmatched_prompt_and_completions(self):
     with self.assertRaises(ValueError):
       MockScoringModel().score(['hi',], ['1', '2', '3'])
@@ -828,6 +857,17 @@ class LanguageModelTest(unittest.TestCase):
       if debug_mode & lm_lib.LMDebugMode.PROMPT:
         self.assertIn('[0] MODALITY OBJECTS SENT TO LM', debug_info)
 
+  def test_atokenize(self):
+    lm = MockTokenizeModel()
+    self.assertEqual(
+        asyncio.run(
+            lm.atokenize(
+                message_lib.UserMessage('hi')
+            )
+        ),
+        [('hi', 0)],
+    )
+
   def test_tokenize_with_unsupported_model(self):
     with self.assertRaises(NotImplementedError):
       MockModel().tokenize('hi')

langfun/core/structured/__init__.py

@@ -51,13 +51,16 @@ from langfun.core.structured.mapping import MappingError
 from langfun.core.structured.mapping import MappingExample
 
 from langfun.core.structured.parsing import parse
+from langfun.core.structured.parsing import aparse
 from langfun.core.structured.parsing import call
+from langfun.core.structured.parsing import acall
 
 from langfun.core.structured.querying import track_queries
 from langfun.core.structured.querying import QueryInvocation
 
 from langfun.core.structured.querying import LfQuery
 from langfun.core.structured.querying import query
+from langfun.core.structured.querying import aquery
 from langfun.core.structured.querying import query_and_reduce
 from langfun.core.structured.querying import query_protocol
 
@@ -67,10 +70,14 @@ from langfun.core.structured.querying import query_reward
 
 from langfun.core.structured.description import describe
 from langfun.core.structured.completion import complete
+from langfun.core.structured.completion import acomplete
 
 from langfun.core.structured.scoring import score
+from langfun.core.structured.scoring import ascore
 
 from langfun.core.structured.tokenization import tokenize
+from langfun.core.structured.tokenization import atokenize
+
 
 # Expose default examples for structured operations so users could refer to
 # them.

langfun/core/structured/completion.py

@@ -251,3 +251,31 @@ def complete(
 
   output = t(lm=lm, cache_seed=cache_seed, autofix_lm=autofix_lm or lm)
   return output if returns_message else output.result
+
+
+async def acomplete(
+    input_value: pg.Symbolic,
+    default: Any = lf.RAISE_IF_HAS_ERROR,
+    *,
+    lm: lf.LanguageModel | None = None,
+    examples: list[mapping.MappingExample] | None = None,
+    cache_seed: int | None = 0,
+    autofix: int = 0,
+    autofix_lm: lf.LanguageModel | None = None,
+    returns_message: bool = False,
+    **kwargs,
+) -> Any:
+  """Async version of `lf.complete`."""
+  # TODO(daiyip): implement native async completion.
+  return await lf.invoke_async(
+      complete,
+      input_value,
+      default,
+      lm=lm,
+      examples=examples,
+      cache_seed=cache_seed,
+      autofix=autofix,
+      autofix_lm=autofix_lm,
+      returns_message=returns_message,
+      **kwargs
+  )

langfun/core/structured/completion_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Tests for langfun.core.structured.completion."""
 
+import asyncio
 import inspect
 import unittest
 
@@ -620,6 +621,41 @@ class CompleteStructureTest(unittest.TestCase):
     ):
       self.assertIsNone(completion.complete(Activity.partial(), None))
 
+  def test_acomplete(self):
+    response = """
+    ```python
+        TripPlan(
+          place='San Francisco',
+          itineraries=[
+            Itinerary(
+                day=1,
+                type='daytime',
+                activities=[
+                    Activity(description='Arrive in San Francisco and check into your hotel.'),
+                    Activity(description='Take a walk around Fisherman\\'s Wharf and have dinner at one of the many seafood restaurants.'),
+                    Activity(description='Visit Pier 39 and see the sea lions.'),
+                ], 
+            ),
+          ]
+        )
+    ```
+    """
+    with lf.context(
+        lm=fake.StaticSequence(
+            [response],
+        ),
+        override_attrs=True,
+    ):
+      r = completion.acomplete(
+          TripPlan.partial(
+              place='San Francisco',
+              itineraries=[
+                  Itinerary.partial(day=1),
+              ],
+          )
+      )
+      self.assertIsInstance(asyncio.run(r), TripPlan)
+
 
 if __name__ == '__main__':
   unittest.main()