langfun 0.1.2.dev202507240805__tar.gz → 0.1.2.dev202507260804__tar.gz

{langfun-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfun
-Version: 0.1.2.dev202507240805
+Version: 0.1.2.dev202507260804
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors

{langfun-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/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-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/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-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/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-0.1.2.dev202507260804/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-0.1.2.dev202507260804/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-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/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-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/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-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/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-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/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-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/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()

{langfun-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/langfun/core/structured/parsing.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Symbolic parsing."""
+
 from typing import Any, Callable, Type, Union
 
 import langfun.core as lf
@@ -183,6 +184,44 @@ def parse(
   return output if returns_message else output.result
 
 
+async def aparse(
+    message: Union[lf.Message, str],
+    schema: Union[
+        schema_lib.Schema, Type[Any], list[Type[Any]], dict[str, Any]
+    ],
+    default: Any = lf.RAISE_IF_HAS_ERROR,
+    *,
+    user_prompt: str | None = None,
+    lm: lf.LanguageModel | None = None,
+    examples: list[mapping.MappingExample] | None = None,
+    include_context: bool = False,
+    cache_seed: int | None = 0,
+    autofix: int = 0,
+    autofix_lm: lf.LanguageModel | None = None,
+    protocol: schema_lib.SchemaProtocol = 'python',
+    returns_message: bool = False,
+    **kwargs,
+) -> Any:
+  """Async version of `lf.parse`."""
+  # TODO(daiyip): implement native async parsing.
+  return await lf.invoke_async(
+      parse,
+      message,
+      schema,
+      default,
+      user_prompt=user_prompt,
+      lm=lm,
+      examples=examples,
+      include_context=include_context,
+      cache_seed=cache_seed,
+      autofix=autofix,
+      autofix_lm=autofix_lm,
+      protocol=protocol,
+      returns_message=returns_message,
+      **kwargs
+  )
+
+
 def call(
     prompt: str | lf.Template,
     schema: Union[
@@ -298,6 +337,44 @@ def call(
   return parsing_message if returns_message else parsing_message.result
 
 
+async def acall(
+    prompt: str | lf.Template,
+    schema: Union[
+        None, schema_lib.Schema, Type[Any], list[Type[Any]], dict[str, Any]
+    ] = None,
+    *,
+    lm: lf.LanguageModel | None = None,
+    parsing_lm: lf.LanguageModel | None = None,
+    parsing_examples: list[mapping.MappingExample] | None = None,
+    parsing_include_context: bool = False,
+    cache_seed: int | None = 0,
+    autofix: int = 0,
+    autofix_lm: lf.LanguageModel | None = None,
+    response_postprocess: Callable[[str], str] | None = None,
+    protocol: schema_lib.SchemaProtocol = 'python',
+    returns_message: bool = False,
+    **kwargs,
+) -> Any:
+  """Async version of `lf.call`."""
+  # TODO(daiyip): implement native async calling.
+  return await lf.invoke_async(
+      call,
+      prompt,
+      schema,
+      lm=lm,
+      parsing_lm=parsing_lm,
+      parsing_examples=parsing_examples,
+      parsing_include_context=parsing_include_context,
+      cache_seed=cache_seed,
+      autofix=autofix,
+      autofix_lm=autofix_lm,
+      response_postprocess=response_postprocess,
+      protocol=protocol,
+      returns_message=returns_message,
+      **kwargs
+  )
+
+
 def _parse_structure_cls(
     protocol: schema_lib.SchemaProtocol,
 ) -> Type[_ParseStructure]:

{langfun-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/langfun/core/structured/parsing_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Tests for structured parsing."""
 
+import asyncio
 import inspect
 import unittest
 
@@ -291,6 +292,10 @@ class ParseStructurePythonTest(unittest.TestCase):
         ),
     )
 
+  def test_aparse(self):
+    with lf.context(lm=fake.StaticResponse('1')):
+      self.assertEqual(asyncio.run(parsing.aparse('the answer is 1', int)), 1)
+
 
 class ParseStructureJsonTest(unittest.TestCase):
 
@@ -583,6 +588,16 @@ class CallTest(unittest.TestCase):
     ):
       self.assertEqual(parsing.call('Compute 1 + 2'), 'three')
 
+  def test_acall(self):
+    with lf.context(
+        lm=fake.StaticMapping({
+            'Compute 1 + 2': 'three',
+        })
+    ):
+      self.assertEqual(
+          asyncio.run(parsing.acall('Compute 1 + 2')), 'three'
+      )
+
   def test_call_with_template_str(self):
     with lf.context(
         lm=fake.StaticMapping({

{langfun-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/langfun/core/structured/querying.py

@@ -666,6 +666,48 @@ def query(
   return output_message.text if schema in (None, str) else output_message.result
 
 
+async def aquery(
+    prompt: Union[str, lf.Template, Any],
+    schema: schema_lib.SchemaType |  None = None,
+    default: Any = lf.RAISE_IF_HAS_ERROR,
+    *,
+    lm: lf.LanguageModel | list[lf.LanguageModel] | None = None,
+    num_samples: int | list[int] = 1,
+    system_message: str | lf.Template | None = None,
+    examples: list[mapping.MappingExample] | None = None,
+    cache_seed: int | None = 0,
+    response_postprocess: Callable[[str], str] | None = None,
+    autofix: int = 0,
+    autofix_lm: lf.LanguageModel | None = None,
+    protocol: str | None = None,
+    returns_message: bool = False,
+    skip_lm: bool = False,
+    invocation_id: str | None = None,
+    **kwargs,
+) -> Any:
+  """Async version of `lf.query`."""
+  # TODO(daiyip): implement native async querying.
+  return await lf.invoke_async(
+      query,
+      prompt,
+      schema,
+      default,
+      lm=lm,
+      num_samples=num_samples,
+      system_message=system_message,
+      examples=examples,
+      cache_seed=cache_seed,
+      response_postprocess=response_postprocess,
+      autofix=autofix,
+      autofix_lm=autofix_lm,
+      protocol=protocol,
+      returns_message=returns_message,
+      skip_lm=skip_lm,
+      invocation_id=invocation_id,
+      **kwargs
+  )
+
+
 @contextlib.contextmanager
 def query_protocol(protocol: str) -> Iterator[None]:
   """Context manager for setting the query protocol for the scope."""

{langfun-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/langfun/core/structured/querying_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Tests for structured query."""
 
+import asyncio
 import inspect
 import math
 import time
@@ -1336,6 +1337,15 @@ class LfQueryJsonV1Test(unittest.TestCase):
           querying.query('what is 1 + 0', int, lm=lm), 1
       )
 
+  def test_aquery(self):
+    with lf.context(lm=fake.StaticResponse('{"result": 1}')):
+      self.assertEqual(
+          asyncio.run(
+              querying.aquery('what is 1 + 0', int, protocol='json')
+          ),
+          1
+      )
+
 
 class QueryInvocationTest(unittest.TestCase):
 

{langfun-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/langfun/core/structured/scoring.py

@@ -179,3 +179,31 @@ def _get_first_oneof(value: Any) -> pg.hyper.OneOf:
   pg.traverse(value, select_oneofs)
   assert oneofs
   return oneofs[0]
+
+
+async def ascore(
+    prompt: Union[str, pg.Symbolic] | list[str | pg.Symbolic],
+    completions: list[str | pg.Symbolic],
+    schema: Union[
+        schema_lib.Schema, Type[Any], list[Type[Any]], dict[str, Any], None
+    ] = None,
+    *,
+    lm: lf.LanguageModel | None = None,
+    examples: list[mapping.MappingExample] | None = None,
+    protocol: schema_lib.SchemaProtocol = 'python',
+    return_scoring_results: bool = False,
+    **kwargs,
+) -> list[float] | list[lf.LMScoringResult]:
+  """Async version of `lf.score`."""
+  # TODO(daiyip): implement native async scoring.
+  return await lf.invoke_async(
+      score,
+      prompt,
+      completions,
+      schema=schema,
+      lm=lm,
+      examples=examples,
+      protocol=protocol,
+      return_scoring_results=return_scoring_results,
+      **kwargs,
+  )

{langfun-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/langfun/core/structured/scoring_test.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
 import unittest
 import langfun.core as lf
 from langfun.core.llms import fake
@@ -50,6 +51,13 @@ class ScoringTest(unittest.TestCase):
   def test_score(self):
     self.assertEqual(scoring.score('hi', [1, 2], lm=fake.Echo()), [0.0, -1.0])
 
+  def test_ascore(self):
+    with lf.context(lm=fake.Echo()):
+      self.assertEqual(
+          asyncio.run(scoring.ascore('hi', [1, 2], lm=fake.Echo())),
+          [0.0, -1.0]
+      )
+
   def test_score_on_field_values(self):
     self.assertEqual(
         scoring.score(

{langfun-0.1.2.dev202507240805 → langfun-0.1.2.dev202507260804}/langfun/core/structured/tokenization.py

@@ -62,3 +62,27 @@ def tokenize(
     lm = lm_override.value
 
   return lm.tokenize(input_message)
+
+
+async def atokenize(
+    prompt: Union[str, pg.Symbolic] | list[str | pg.Symbolic],
+    schema: Union[
+        schema_lib.Schema, Type[Any], list[Type[Any]], dict[str, Any], None
+    ] = None,
+    *,
+    lm: lf.LanguageModel | None = None,
+    examples: list[mapping.MappingExample] | None = None,
+    protocol: schema_lib.SchemaProtocol = 'python',
+    **kwargs,
+) -> list[tuple[str | bytes, int]]:
+  """Async version of `lf.tokenize`."""
+  # TODO(daiyip): implement native async tokenization.
+  return await lf.invoke_async(
+      tokenize,
+      prompt,
+      schema,
+      lm=lm,
+      examples=examples,
+      protocol=protocol,
+      **kwargs,
+  )